From f0946ebcda4f0f311d71ad46831fbaac95695351 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sun, 2 Feb 2014 13:42:57 +0400
Subject: [PATCH 001/309] rx.js: updated to version 2.2.13

---
 rx.js/rx.d.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index f055452e3..949baa68e 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS
+// Type definitions for RxJS v2.2.13
 // Project: http://rx.codeplex.com/
 // Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
 // Revision by: Igor Oleinikov <https://github.com/Igorbek>
@@ -167,7 +167,6 @@ declare module Rx {
 	// Current Thread IScheduler
 	interface ICurrentThreadScheduler extends IScheduler {
 		scheduleRequired(): boolean;
-		ensureTrampoline(action: () =>IDisposable): IDisposable;
 	}
 
 	// Notifications

From e44e9dbc1645ef515617ad22fe0f35bfaee52a4c Mon Sep 17 00:00:00 2001
From: VWINDHA <hansrwindhoff@gmail.com>
Date: Wed, 12 Feb 2014 20:28:33 -0700
Subject: [PATCH 002/309] for https://github.com/dc-js/dc.js

---
 dcjs/dc.d.ts    | 198 +++++++++++++++++++++++++++++++++++++++
 dcjs/dc.test.ts | 244 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 442 insertions(+)
 create mode 100644 dcjs/dc.d.ts
 create mode 100644 dcjs/dc.test.ts

diff --git a/dcjs/dc.d.ts b/dcjs/dc.d.ts
new file mode 100644
index 000000000..ca4f8fdc8
--- /dev/null
+++ b/dcjs/dc.d.ts
@@ -0,0 +1,198 @@
+// Type definitions for DCJS
+// Project: https://github.com/dc-js
+// Definitions by: hans windhoff
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+// this makes only sense together with d3 and crossfilter so you need the d3.d.ts and crossfilter.d.ts files
+
+///<reference path="../d3/d3.d.ts" />
+///<reference path="../crossfilter/crossfilter.d.ts" />
+
+
+
+declare module dc {
+
+  // helper for get/set situation
+  interface IGetSet<T, V> {
+    (): T;
+    (T): V;
+  }
+
+  export interface IBaseChart<T> {
+    width: IGetSet<number, T>;
+    height: IGetSet<number, T>;
+    minWidth: IGetSet<number, T>;
+    minHeight: IGetSet<number, T>;
+    dimension: IGetSet<number, T>;
+    group: IGetSet<string, T>; // not sure here
+    transitionDuration: IGetSet<number, T>;
+    colors: IGetSet<string[], T>;
+    keyAccessor: IGetSet<(d) => number, T>;
+    valueAccessor: IGetSet<(d) => number, T>;
+    label: IGetSet<(any) => string, T>;
+    renderLabel: IGetSet<boolean, T>;
+    renderlet: (fnctn: (T) => void) => T;
+    title: IGetSet<(any) => string, T>;
+    filter: IGetSet<any, T>;
+    filterAll: () => void;
+    expireCache: () => void;
+    legend: (ILegendwidget) => T;
+    chartID: () => number;
+    options: (Object)=>void ;
+    select: (selector: D3.Selection) => D3.Selection;
+    selectAll: (selector: D3.Selection) => D3.Selection;
+  }
+
+  export interface IEvents {
+    trigger(fnctn: () => void, delay?: number);
+  }
+
+  export var events: IEvents;
+
+  export interface IListener<T> {
+    on: (eventName: string, fnctn: (IChart) => void) => T;
+  }
+
+  export interface ImarginObj {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+    
+  }
+
+  export interface IMarginable<T> {
+    margins: IGetSet<ImarginObj, T>;
+  }
+
+  // abstract interfaces  
+  export interface IAbstractColorChart<T> {
+    colorDomain: IGetSet<number[], T>;
+  }
+  export interface IAbstractStackableChart<T> {
+    stack: (group, name?, retriever?) => T;
+  }
+
+  export interface IAbstractCoordinateGridChart<T> {
+    x: IGetSet<any, T>;
+    y: IGetSet<any, T>;
+    elasticY: IGetSet<boolean, T>;
+    xAxis: IGetSet<D3.Svg.Axis, T>;
+    yAxis: IGetSet<D3.Svg.Axis, T>;
+    yAxisPadding: IGetSet<number, T>;
+    xAxisPadding: IGetSet<number, T>;
+    renderHorizontalGridLines: IGetSet<boolean, T>;
+    
+  }
+
+  export interface IAbstractBubblechart<T> {
+    r: IGetSet<number, T>;
+    radiusValueAccessor: IGetSet<(d) => number, T>;
+  }
+
+
+
+  // function interfaces
+  export interface columnFunction {
+    (any): any;
+  }
+  export interface sortbyFunction {
+    (any): any;
+  }
+  export interface orderFunction {
+    <T>(a: T, b: T): number;
+  }
+
+
+  // chart interfaces  
+  export interface ILegendwidget {
+    x: IGetSet<number, number>;
+    y: IGetSet<number, number>;
+    gap: IGetSet<number, number>;
+    itemHeight: IGetSet<number, number>;
+    horizontal: IGetSet<boolean, boolean>;
+    legendWidth: IGetSet<number, number>;
+    itemWidth: IGetSet<number, number>;
+  }
+
+  export interface IBubblechart extends
+  IBaseChart<IBubblechart>,
+  IAbstractColorChart<IBubblechart>,
+  IAbstractBubblechart<IBubblechart>,
+  IAbstractCoordinateGridChart<IBubblechart>,
+  IMarginable<IBubblechart>,
+  IListener<IBubblechart> {
+  }
+
+  export interface IPiechart extends
+  IBaseChart<IPiechart>,
+  IAbstractColorChart<IPiechart>,
+  IAbstractBubblechart<IPiechart>,
+  IAbstractCoordinateGridChart<IPiechart>,
+  IMarginable<IPiechart>,
+  IListener<IPiechart> {
+    radius: IGetSet<number, IPiechart>;
+    minAngleForLabel: IGetSet<number, IPiechart>;
+
+  }
+
+  export interface IBarchart extends
+  IBaseChart<IBarchart>,
+  IAbstractStackableChart<IBarchart>,
+  IAbstractCoordinateGridChart<IBarchart>,
+  IMarginable<IBarchart>,
+  IListener<IBarchart> {
+    centerBar: (boolean) => IBarchart;
+    gap: (gapBetweenBars: number) => IBarchart;
+  }
+
+  export interface ILinechart extends
+  IBaseChart<ILinechart>,
+  IAbstractStackableChart<ILinechart>,
+  IAbstractCoordinateGridChart<ILinechart>,
+  IMarginable<ILinechart>,
+  IListener<ILinechart> {
+  }
+
+
+  export interface IDatachart extends
+  IBaseChart<IDatachart>,
+  IAbstractStackableChart<IDatachart>,
+  IAbstractCoordinateGridChart<IDatachart>,
+  IMarginable<IDatachart>,
+  IListener<IDatachart> {
+    size: IGetSet<number, IDatachart>;
+    columns: IGetSet<columnFunction[], IDatachart>;
+    sortBy: IGetSet<sortbyFunction[], IDatachart>;
+    order: IGetSet<orderFunction[], IDatachart>;
+  }
+
+
+  export interface IRowchart extends
+  IBaseChart<IRowchart>,
+  IAbstractColorChart<IRowchart>,
+  IAbstractStackableChart<IRowchart>,
+  IAbstractCoordinateGridChart<IRowchart>,
+  IMarginable<IRowchart>,
+  IListener<IRowchart> {
+  }
+
+
+
+
+  // utilities
+  export interface IChartGroup { }
+
+  export function filterAll(chartGroup?: IChartGroup): void;
+  export function renderAll(chartGroup?: IChartGroup);
+  export function redrawAll(chartGroup?: IChartGroup);
+
+
+  export function bubbleChart(cssSel: string): IBubblechart;
+  export function pieChart(cssSel: string): IPiechart;
+  export function barChart(cssSel: string): IBarchart;
+  export function lineChart(cssSel: string): ILinechart;
+  export function dataTable(cssSel: string): IDatachart;
+  export function rowChart(cssSel: string): IRowchart;
+
+
+}
\ No newline at end of file
diff --git a/dcjs/dc.test.ts b/dcjs/dc.test.ts
new file mode 100644
index 000000000..6e2bf6f97
--- /dev/null
+++ b/dcjs/dc.test.ts
@@ -0,0 +1,244 @@
+///<reference path="../d3/d3.d.ts" />
+///<reference path="../crossfilter/crossfilter.d.ts" />
+///<reference path="dc.d.ts" />
+
+
+interface IYelpData {
+  city: string;
+  review_count: number;
+  name: string;
+  neighborhoods: string[];
+  type: string;
+  business_id: string;
+  full_address: string;
+  state: string;
+  longitude: number;
+  stars: number;
+  latitude: number;
+  open: boolean;
+  categories: string[]
+}
+
+
+interface IYelpDataExtended {
+  count: number;
+  review_sum: number;
+  star_sum: number;
+  review_avg: number;
+  star_avg: number;
+}
+
+
+/********************************************************
+*														*
+* 	dj.js example using Yelp Kaggle Test Dataset		*
+* 	Eamonn O'Loughlin 9th May 2013 						*
+*														*
+********************************************************/
+
+/********************************************************
+*														*
+* 	Step0: Load data from json file						*
+*														*
+********************************************************/
+d3.json("data/yelp_test_set_business.json", function (yelp_data:IYelpData[]) {
+  
+/********************************************************
+*                           *
+*   Step1: Create the dc.js chart objects & ling to div *
+*                           *
+********************************************************/
+var bubbleChart = dc.bubbleChart("#dc-bubble-graph");
+var pieChart = dc.pieChart("#dc-pie-graph");
+var volumeChart = dc.barChart("#dc-volume-chart");
+var lineChart = dc.lineChart("#dc-line-chart");
+var dataTable = dc.dataTable("#dc-table-graph");
+var rowChart = dc.rowChart("#dc-row-graph");
+
+/********************************************************
+*                           *
+*   Step2:  Run data through crossfilter        *
+*                           *
+********************************************************/
+var ndx = crossfilter(yelp_data);
+  
+/********************************************************
+*                           *
+*   Step3:  Create Dimension that we'll need      *
+*                           *
+********************************************************/
+
+  // for volumechart
+  var cityDimension = ndx.dimension(function (d) { return d.city; });
+  var cityGroup = cityDimension.group();
+  var cityDimensionGroup = cityDimension.group().reduce(
+    //add
+    function(p: IYelpDataExtended,v:IYelpData){
+      ++p.count;
+      p.review_sum += v.review_count;
+      p.star_sum += v.stars;
+      p.review_avg = p.review_sum / p.count;
+      p.star_avg = p.star_sum / p.count;
+      return p;
+    },
+    //remove
+    function(p: IYelpDataExtended,v:IYelpData){
+      --p.count;
+      p.review_sum -= v.review_count;
+      p.star_sum -= v.stars;
+      p.review_avg = p.review_sum / p.count;
+      p.star_avg = p.star_sum / p.count;
+      return p;
+    },
+    //init
+    function(){
+      return {count:0, review_sum: 0, star_sum: 0, review_avg: 0, star_avg: 0};
+    }
+  );
+
+  // for pieChart
+    var startValue = ndx.dimension(function (d) {
+    return d.stars*1.0;
+    });
+    var startValueGroup = startValue.group();
+
+  // For datatable
+  var businessDimension = ndx.dimension(function (d) { return d.business_id; });
+/********************************************************
+*                           *
+*   Step4: Create the Visualisations          *
+*                           *
+********************************************************/
+  
+ bubbleChart.width(650)
+      .height(300)
+      .dimension(cityDimension)
+      .group(cityDimensionGroup)
+      .transitionDuration(1500)
+      .colors(["#a60000","#ff0000", "#ff4040","#ff7373","#67e667","#39e639","#00cc00"])
+      .colorDomain([-12000, 12000])
+    
+      .x(d3.scale.linear().domain([0, 5.5]))
+      .y(d3.scale.linear().domain([0, 5.5]))
+      .r(d3.scale.linear().domain([0, 2500]))
+      .keyAccessor(function (p) {
+        return p.value.star_avg;
+      })
+      .valueAccessor(function (p) {
+        return p.value.review_avg;
+      })
+      .radiusValueAccessor(function (p) {
+        return p.value.count;
+      })
+      .transitionDuration(1500)
+      .elasticY(true)
+      .yAxisPadding(1)
+      .xAxisPadding(1)
+      .label(function (p) {
+        return p.key;
+        })
+      .renderLabel(true)
+      .renderlet(function (chart) {
+            rowChart.filter(chart.filter());
+        })
+        .on("postRedraw", function (chart) {
+            dc.events.trigger(function () {
+                rowChart.filter(chart.filter());
+            });
+                  });
+        ;
+
+
+pieChart.width(200)
+    .height(200)
+    .transitionDuration(1500)
+    .dimension(startValue)
+    .group(startValueGroup)
+    .radius(90)
+    .minAngleForLabel(0)
+    .label(function(d) { return d.data.key; })
+    .on("filtered", function (chart) {
+      dc.events.trigger(function () {
+        if(chart.filter()) {
+          console.log(chart.filter());
+          volumeChart.filter([chart.filter()-.25,chart.filter()-(-0.25)]);
+          }
+        else volumeChart.filterAll();
+      });
+    });
+
+volumeChart.width(230)
+            .height(200)
+            .dimension(startValue)
+            .group(startValueGroup)
+      .transitionDuration(1500)
+            .centerBar(true)  
+      .gap(17)
+            .x(d3.scale.linear().domain([0.5, 5.5]))
+      .elasticY(true)
+      .on("filtered", function (chart) {
+        dc.events.trigger(function () {
+          if(chart.filter()) {
+            console.log(chart.filter());
+            lineChart.filter(chart.filter());
+            }
+          else
+          {lineChart.filterAll()}
+        });
+      })
+      .xAxis().tickFormat(function(v) {return v;}); 
+
+console.log(startValueGroup.top(1)[0].value);
+
+lineChart.width(230)
+    .height(200)
+    .dimension(startValue)
+    .group(startValueGroup)
+    .x(d3.scale.linear().domain([0.5, 5.5]))
+    .valueAccessor(function(d) {
+      return d.value;
+      })
+      .renderHorizontalGridLines(true)
+      .elasticY(true)
+      .xAxis().tickFormat(function(v) {return v;}); ;
+
+rowChart.width(340)
+      .height(850)
+      .dimension(cityDimension)
+      .group(cityGroup)
+      .renderLabel(true)
+      .colors(["#a60000","#ff0000", "#ff4040","#ff7373","#67e667","#39e639","#00cc00"])
+      .colorDomain([0, 0])
+        .renderlet(function (chart) {
+            bubbleChart.filter(chart.filter());
+        })
+        .on("filtered", function (chart) {
+            dc.events.trigger(function () {
+                bubbleChart.filter(chart.filter());
+            });
+                  });
+
+
+dataTable.width(800).height(800)
+  .dimension(businessDimension)
+  .group(function(d) { return "List of all Selected Businesses"
+   })
+  .size(100)
+    .columns([
+        function(d) { return d.name; },
+        function(d) { return d.city; },
+        function(d) { return d.stars; },
+        function(d) { return d.review_count; },
+    function(d) { return '<a href=\"http://maps.google.com/maps?z=12&t=m&q=loc:' + d.latitude + '+' + d.longitude +"\" target=\"_blank\">Map</a>"}
+    ])
+    .sortBy(function(d){ return d.stars; })
+    // (optional) sort order, :default ascending
+    .order(d3.ascending);
+/********************************************************
+*                           *
+*   Step6:  Render the Charts             *
+*                           *
+********************************************************/
+      
+  dc.renderAll();
+});

From 594302f0b63ca759b47695c77bdfc698ec67f4ca Mon Sep 17 00:00:00 2001
From: "Mike H. Hawley" <mikehhawley@gmail.com>
Date: Fri, 21 Feb 2014 22:26:33 +0400
Subject: [PATCH 003/309] node-ffi: fix Callback interface

---
 node-ffi/node-ffi-tests.ts |  4 ++++
 node-ffi/node-ffi.d.ts     | 12 ++++++------
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/node-ffi/node-ffi-tests.ts b/node-ffi/node-ffi-tests.ts
index 407036d39..383470503 100644
--- a/node-ffi/node-ffi-tests.ts
+++ b/node-ffi/node-ffi-tests.ts
@@ -28,6 +28,10 @@ import TArray = require('ref-array');
     func(-5);
     func.async(-5, function(err: any, res: any) {});
 }
+{
+    var funcPtr = ffi.Callback('int', [ 'int' ], Math.abs);
+    var func    = ffi.ForeignFunction(funcPtr, 'int', [ 'int' ]);
+}
 {
     var printfPointer = ffi.DynamicLibrary().get('printf');
     var printfGen = ffi.VariadicForeignFunction(printfPointer, 'void', [ 'string' ]);
diff --git a/node-ffi/node-ffi.d.ts b/node-ffi/node-ffi.d.ts
index b2bdd522d..957cf5793 100644
--- a/node-ffi/node-ffi.d.ts
+++ b/node-ffi/node-ffi.d.ts
@@ -140,10 +140,10 @@ declare module "ffi" {
      * accept C callback functions.
      */
     export var Callback: {
-        new (retType: any, argTypes: any[], abi: number, fn: Function): NodeBuffer;
-        new (retType: any, argTypes: any[], fn: Function): NodeBuffer;
-        (retType: any, argTypes: any[], abi: number, fn: Function): NodeBuffer;
-        (retType: any, argTypes: any[], fn: Function): NodeBuffer;
+        new (retType: any, argTypes: any[], abi: number, fn: any): NodeBuffer;
+        new (retType: any, argTypes: any[], fn: any): NodeBuffer;
+        (retType: any, argTypes: any[], abi: number, fn: any): NodeBuffer;
+        (retType: any, argTypes: any[], fn: any): NodeBuffer;
     }
 
     export var ffiType: {
@@ -154,8 +154,8 @@ declare module "ffi" {
         FFI_TYPE: StructType;
     }
 
-    export var CIF: Function;
-    export var CIF_var: Function;
+    export var CIF: (retType: any, types: any[], abi?: any) => NodeBuffer
+    export var CIF_var: (retType: any, types: any[], numFixedArgs: number, abi?: any) => NodeBuffer;
     export var HAS_OBJC: boolean;
     export var FFI_TYPES: {[key: string]: NodeBuffer};
     export var FFI_OK: number;

From ab5eeab4d3a391d752da62e7fd7256e06767c5c0 Mon Sep 17 00:00:00 2001
From: hansrwindhoff <hansrwindhoff@gmail.com>
Date: Mon, 17 Feb 2014 21:47:47 -0700
Subject: [PATCH 004/309] fixed Travis-CI failed.
 https://travis-ci.org/borisyankov/DefinitelyTyped/builds/18779631

---
 dcjs/{dc.test.ts => dc-tests.ts} |  4 +-
 dcjs/dc.d.ts                     | 64 ++++++++++++++++----------------
 2 files changed, 33 insertions(+), 35 deletions(-)
 rename dcjs/{dc.test.ts => dc-tests.ts} (99%)

diff --git a/dcjs/dc.test.ts b/dcjs/dc-tests.ts
similarity index 99%
rename from dcjs/dc.test.ts
rename to dcjs/dc-tests.ts
index 6e2bf6f97..60d3aa059 100644
--- a/dcjs/dc.test.ts
+++ b/dcjs/dc-tests.ts
@@ -2,7 +2,6 @@
 ///<reference path="../crossfilter/crossfilter.d.ts" />
 ///<reference path="dc.d.ts" />
 
-
 interface IYelpData {
   city: string;
   review_count: number;
@@ -19,7 +18,6 @@ interface IYelpData {
   categories: string[]
 }
 
-
 interface IYelpDataExtended {
   count: number;
   review_sum: number;
@@ -221,7 +219,7 @@ rowChart.width(340)
 
 dataTable.width(800).height(800)
   .dimension(businessDimension)
-  .group(function(d) { return "List of all Selected Businesses"
+  .group(function(d:Object) { return "List of all Selected Businesses"
    })
   .size(100)
     .columns([
diff --git a/dcjs/dc.d.ts b/dcjs/dc.d.ts
index ca4f8fdc8..0391d2502 100644
--- a/dcjs/dc.d.ts
+++ b/dcjs/dc.d.ts
@@ -14,42 +14,50 @@ declare module dc {
   // helper for get/set situation
   interface IGetSet<T, V> {
     (): T;
-    (T): V;
+    (t:T): V;
+  }
+export interface ILegendwidget {
+    x: IGetSet<number, number>;
+    y: IGetSet<number, number>;
+    gap: IGetSet<number, number>;
+    itemHeight: IGetSet<number, number>;
+    horizontal: IGetSet<boolean, boolean>;
+    legendWidth: IGetSet<number, number>;
+    itemWidth: IGetSet<number, number>;
   }
-
   export interface IBaseChart<T> {
     width: IGetSet<number, T>;
     height: IGetSet<number, T>;
     minWidth: IGetSet<number, T>;
     minHeight: IGetSet<number, T>;
-    dimension: IGetSet<number, T>;
-    group: IGetSet<string, T>; // not sure here
+    dimension: IGetSet<any, T>;
+    group: IGetSet<any, T>; // not sure here
     transitionDuration: IGetSet<number, T>;
     colors: IGetSet<string[], T>;
-    keyAccessor: IGetSet<(d) => number, T>;
-    valueAccessor: IGetSet<(d) => number, T>;
-    label: IGetSet<(any) => string, T>;
+    keyAccessor: IGetSet<(d:any) => number, T>;
+    valueAccessor: IGetSet<(d:any) => number, T>;
+    label: IGetSet<(l:any) => string, T>;
     renderLabel: IGetSet<boolean, T>;
-    renderlet: (fnctn: (T) => void) => T;
-    title: IGetSet<(any) => string, T>;
+    renderlet: (fnctn: (t:T) => void) => T;
+    title: IGetSet<(t:string) => string, T>;
     filter: IGetSet<any, T>;
     filterAll: () => void;
     expireCache: () => void;
-    legend: (ILegendwidget) => T;
+    legend: (l:ILegendwidget) => T;
     chartID: () => number;
-    options: (Object)=>void ;
+    options: (o:Object)=>void ;
     select: (selector: D3.Selection) => D3.Selection;
     selectAll: (selector: D3.Selection) => D3.Selection;
   }
 
   export interface IEvents {
-    trigger(fnctn: () => void, delay?: number);
+    trigger(fnctn: () => void, delay?: number):void;
   }
 
   export var events: IEvents;
 
   export interface IListener<T> {
-    on: (eventName: string, fnctn: (IChart) => void) => T;
+    on: (eventName: string, fnctn: (c:T) => void) => T;
   }
 
   export interface ImarginObj {
@@ -69,7 +77,7 @@ declare module dc {
     colorDomain: IGetSet<number[], T>;
   }
   export interface IAbstractStackableChart<T> {
-    stack: (group, name?, retriever?) => T;
+    stack: (group: IChartGroup, name?:string, retriever?: (d:Object)=>number) => T;
   }
 
   export interface IAbstractCoordinateGridChart<T> {
@@ -85,18 +93,18 @@ declare module dc {
   }
 
   export interface IAbstractBubblechart<T> {
-    r: IGetSet<number, T>;
-    radiusValueAccessor: IGetSet<(d) => number, T>;
+    r: IGetSet<any, T>;
+    radiusValueAccessor: IGetSet<(d:any) => number, T>;
   }
 
 
 
   // function interfaces
   export interface columnFunction {
-    (any): any;
+    (rowinfo:any): string;
   }
   export interface sortbyFunction {
-    (any): any;
+    (rowinfo:any): any;
   }
   export interface orderFunction {
     <T>(a: T, b: T): number;
@@ -104,15 +112,7 @@ declare module dc {
 
 
   // chart interfaces  
-  export interface ILegendwidget {
-    x: IGetSet<number, number>;
-    y: IGetSet<number, number>;
-    gap: IGetSet<number, number>;
-    itemHeight: IGetSet<number, number>;
-    horizontal: IGetSet<boolean, boolean>;
-    legendWidth: IGetSet<number, number>;
-    itemWidth: IGetSet<number, number>;
-  }
+  
 
   export interface IBubblechart extends
   IBaseChart<IBubblechart>,
@@ -141,7 +141,7 @@ declare module dc {
   IAbstractCoordinateGridChart<IBarchart>,
   IMarginable<IBarchart>,
   IListener<IBarchart> {
-    centerBar: (boolean) => IBarchart;
+    centerBar: (b:boolean) => IBarchart;
     gap: (gapBetweenBars: number) => IBarchart;
   }
 
@@ -162,8 +162,8 @@ declare module dc {
   IListener<IDatachart> {
     size: IGetSet<number, IDatachart>;
     columns: IGetSet<columnFunction[], IDatachart>;
-    sortBy: IGetSet<sortbyFunction[], IDatachart>;
-    order: IGetSet<orderFunction[], IDatachart>;
+    sortBy: IGetSet<sortbyFunction, IDatachart>;
+    order: IGetSet<orderFunction, IDatachart>;
   }
 
 
@@ -183,8 +183,8 @@ declare module dc {
   export interface IChartGroup { }
 
   export function filterAll(chartGroup?: IChartGroup): void;
-  export function renderAll(chartGroup?: IChartGroup);
-  export function redrawAll(chartGroup?: IChartGroup);
+  export function renderAll(chartGroup?: IChartGroup): void;
+  export function redrawAll(chartGroup?: IChartGroup): void;
 
 
   export function bubbleChart(cssSel: string): IBubblechart;

From 7fa3c077500289739efc6aa593371dab6b47997c Mon Sep 17 00:00:00 2001
From: Louis-Philippe Perras <lpperras@outlook.com>
Date: Mon, 24 Feb 2014 10:06:55 -0500
Subject: [PATCH 005/309] addMethod params arguments vs array syntax

jQUery Validation does not send arguments but an array of the argument already built. By using the ... syntax of TypeScript, we get an array with one item that has the array sent by jQuery validation. I think the definition should use an array instead of arguments syntax.
---
 jquery.validation/jquery.validation.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/jquery.validation/jquery.validation.d.ts b/jquery.validation/jquery.validation.d.ts
index 301bf6bc6..2e13bc427 100644
--- a/jquery.validation/jquery.validation.d.ts
+++ b/jquery.validation/jquery.validation.d.ts
@@ -51,7 +51,7 @@ interface Validator
 {
 	addClassRules(name: string, rules: any): void;
 	addClassRules(rules: any): void;
-	addMethod(name: string, method: (value: any, element: any, ...params: any[]) => any, message?: any): void;
+	addMethod(name: string, method: (value: any, element: any, params: any[]) => any, message?: any): void;
 	element(element: any): boolean;
 	form(): boolean;
 	format(template: string, ...arguments: string[]): string;
@@ -82,4 +82,4 @@ interface JQueryStatic
 {
 	format(template: string, ...arguments: string[]): string;
 	validator: Validator;
-}
\ No newline at end of file
+}

From 90779813c5debb8c647db732e039585b0be428d3 Mon Sep 17 00:00:00 2001
From: Louis-Philippe Perras <lpperras@outlook.com>
Date: Mon, 24 Feb 2014 16:39:27 -0500
Subject: [PATCH 006/309] Changed the any[] to be any

http://jqueryvalidation.org/jQuery.validator.addMethod#jQuery-validator-addMethod-name-method-message
---
 jquery.validation/jquery.validation.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/jquery.validation/jquery.validation.d.ts b/jquery.validation/jquery.validation.d.ts
index 2e13bc427..ec2114f08 100644
--- a/jquery.validation/jquery.validation.d.ts
+++ b/jquery.validation/jquery.validation.d.ts
@@ -51,7 +51,7 @@ interface Validator
 {
 	addClassRules(name: string, rules: any): void;
 	addClassRules(rules: any): void;
-	addMethod(name: string, method: (value: any, element: any, params: any[]) => any, message?: any): void;
+	addMethod(name: string, method: (value: any, element: any, params: any) => any, message?: any): void;
 	element(element: any): boolean;
 	form(): boolean;
 	format(template: string, ...arguments: string[]): string;

From 016693e8415c23eb6009c7998e14dd35ded53697 Mon Sep 17 00:00:00 2001
From: Jay Querido <jason@marsworks.com>
Date: Tue, 25 Feb 2014 11:41:07 -0500
Subject: [PATCH 007/309] Fixed bootstrap.paginator "itemTexts" option
 signature

---
 bootstrap.paginator/bootstrap.paginator.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bootstrap.paginator/bootstrap.paginator.d.ts b/bootstrap.paginator/bootstrap.paginator.d.ts
index e45f1c3ce..535c3ec5e 100644
--- a/bootstrap.paginator/bootstrap.paginator.d.ts
+++ b/bootstrap.paginator/bootstrap.paginator.d.ts
@@ -14,7 +14,7 @@ interface PaginatorOptions{
     totalPages?: number;
     pageUrl?: (type, page, current) => string;
     shouldShowPage?: boolean;
-    itemText?: (type, page, current) => any;
+    itemTexts?: (type:string, page:number, current:number) => string;
     tooltipTitles?: (type, page, current) => string;
     useBootstrapTooltip?: boolean;
     bootstrapTooltipOptions?: {};

From e8111a8a306655bc5762ef077bf118ef6fc31a3c Mon Sep 17 00:00:00 2001
From: Jay Querido <jason@marsworks.com>
Date: Tue, 25 Feb 2014 11:46:52 -0500
Subject: [PATCH 008/309] Added missing bootstrap.paginator option

bootstrapMajorVersion
---
 bootstrap.paginator/bootstrap.paginator.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bootstrap.paginator/bootstrap.paginator.d.ts b/bootstrap.paginator/bootstrap.paginator.d.ts
index 535c3ec5e..1e6c17c28 100644
--- a/bootstrap.paginator/bootstrap.paginator.d.ts
+++ b/bootstrap.paginator/bootstrap.paginator.d.ts
@@ -18,6 +18,7 @@ interface PaginatorOptions{
     tooltipTitles?: (type, page, current) => string;
     useBootstrapTooltip?: boolean;
     bootstrapTooltipOptions?: {};
+    bootstrapMajorVersion?: number;
     onPageClicked?: (event, originalEvent, type, page) => void;
     onPageChanged?: (event, originalEvent, type, page) => void;
 }

From a8ad85fec135d6e96858bb1e22a0efa49d471e8f Mon Sep 17 00:00:00 2001
From: SomaticIT <contact@somatic.fr>
Date: Tue, 25 Feb 2014 22:35:36 +0100
Subject: [PATCH 009/309] Fix knockout ko.utils.stringifyJson definition

---
 knockout/knockout.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/knockout/knockout.d.ts b/knockout/knockout.d.ts
index b41846ca5..66ebe2719 100644
--- a/knockout/knockout.d.ts
+++ b/knockout/knockout.d.ts
@@ -310,7 +310,7 @@ interface KnockoutUtils {
 
     parseJson(jsonString: string): any;
 
-    stringifyJson(data: any, replacer: Function, space: string): string;
+    stringifyJson(data: any, replacer?: Function, space?: string): string;
 
     postJson(urlOrForm: any, data: any, options: any): void;
 

From 31b03fb9b8f02ee7d3f2aa486ee42ddba1f99367 Mon Sep 17 00:00:00 2001
From: SomaticIT <contact@somatic.fr>
Date: Tue, 25 Feb 2014 22:40:08 +0100
Subject: [PATCH 010/309] Add amd definition for knockout.mapping

---
 knockout.mapping/knockout.mapping.d.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/knockout.mapping/knockout.mapping.d.ts b/knockout.mapping/knockout.mapping.d.ts
index 2213d87c3..cc116096d 100644
--- a/knockout.mapping/knockout.mapping.d.ts
+++ b/knockout.mapping/knockout.mapping.d.ts
@@ -46,3 +46,7 @@ interface KnockoutMapping {
 interface KnockoutStatic {
     mapping: KnockoutMapping;
 }
+
+declare module "knockout.mapping" {
+    export = KnockoutMapping;
+}

From 4539e391169a558cde50a3870b9f80e61c6a487b Mon Sep 17 00:00:00 2001
From: Tom Crockett <crockett@jpl.nasa.gov>
Date: Tue, 25 Feb 2014 16:05:59 -0800
Subject: [PATCH 011/309] Typings for runtime components

---
 vega/vega.d.ts | 303 ++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 225 insertions(+), 78 deletions(-)

diff --git a/vega/vega.d.ts b/vega/vega.d.ts
index 29ed1ba15..f12871625 100644
--- a/vega/vega.d.ts
+++ b/vega/vega.d.ts
@@ -4,14 +4,11 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 declare module Vega {
-  export interface VG {
-    parse: Parse;
-  }
 
   export interface Parse {
     spec(url: string, callback: (chart: (args: ViewArgs) => View) => void): void;
     spec(spec: Spec, callback: (chart: (args: ViewArgs) => View) => void): void;
-    data(dataSet: Vega.Data[], callback: () => void): void;
+    data(dataSet: Data[], callback: () => void): void;
     // TODO all the other stuff
   }
 
@@ -39,14 +36,20 @@ declare module Vega {
 
     renderer(r: string): View;
 
-    data(): any;
-    data(d: any): View;
+    data(): Runtime.DataSets;
+    data(d: any/*TODO*/): View;
 
-    initialize(i: any): View;
+    initialize(selector: string): View;
+    initialize(node: Element): View;
 
     render(r?: any[]): View;
 
     update(options?: UpdateOptions): View;
+
+    model(): Vega.Model;
+
+    defs(): Defs;
+    defs(defs: Defs): View;
   }
 
   export interface Padding {
@@ -65,6 +68,123 @@ declare module Vega {
     ease?: string; 
   }
 
+  export interface Bounds {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    clear(): Bounds;
+    set(x1: number, y1: number, x2: number, y2: number): Bounds;
+    add(x: number, y: number): Bounds;
+    expand(d: number): Bounds;
+    round(): Bounds;
+    translate(dx: number, dy: number): Bounds;
+    rotate(angle: number, x: number, y: number): Bounds;
+    union(b: Bounds): Bounds;
+    encloses(b: Bounds): boolean;
+    intersects(b: Bounds): boolean;
+    contains(x: number, y: number): boolean;
+    width(): number;
+    height(): number;
+  }
+
+  export interface Model {
+    defs(): Defs;
+    defs(defs: Defs): Model;
+
+    data(): Runtime.DataSets;
+    data(data: Runtime.DataSets): Model;
+
+    ingest(name: string, tx: any/*TODO*/, input: any/*TODO*/): void;
+
+    dependencies(name: string, tx: any/*TODO*/): void;
+
+    width(w: number): Model;
+
+    height(h: number): Model;
+
+    scene(): Node;
+    scene(node: Node): Model;
+
+    build(): Model;
+
+    encode(trans?: any/*TODO*/, request?: string, item?: any): Model;
+
+    reset(): Model;
+  }
+
+  export module Runtime {
+    export interface DataSets {
+      [name: string]: Datum[];
+    }
+
+    export interface Datum {
+      [key: string]: any
+    }
+
+    export interface Marks {
+      type: string;
+      width: number;
+      height: number;
+      scales: Scale[];
+      axes: Axis[];
+      legends: Legend[];
+      marks: Mark[];
+    }
+
+    export interface Mark {
+      // Stuff from Spec.Mark
+      type: string;
+      name?: string;
+      description?: string;
+      from?: Mark.From;
+      key?: string;
+      delay?: Properties;
+
+      // Runtime PropertySets
+      properties?: PropertySets;
+    }
+
+    export interface PropertySets {
+      enter?: Properties;
+      exit?: Properties;
+      update?: Properties;
+      hover?: Properties;
+    }
+
+    export interface Properties {
+      (item: Node, group: Node, trans: any/*TODO*/): void;
+    }
+  }
+
+  export interface Node {
+    def: Runtime.Mark;
+    marktype: string;
+    interactive: boolean;
+    items: Node[];
+    bounds: Bounds;
+
+    // mark item members
+    hasPropertySet(name: string): boolean;
+    cousin(offset: number, index: number): Node;
+    sibling(offset: number): Node;
+    remove(): Node;
+    touch(): void;
+
+    // group members
+    scales?: {[name: string]: any};
+    axisItems?: any[];
+  }
+
+  export interface Defs {
+    width: number;
+    height: number;
+    viewport?: number[];
+    padding: any;
+    marks: Runtime.Marks;
+    data: Data[];
+  }
+
   export interface Spec {
     /**
     * A unique name for the visualization specification.
@@ -227,12 +347,12 @@ declare module Vega {
 
   export module Axis {
     export interface Properties {
-      majorTicks?: Mark.PropertySet;
-      minorTicks?: Mark.PropertySet;
-      grid?: Mark.PropertySet;
-      labels?: Mark.PropertySet;
-      title?: Mark.PropertySet;
-      axis?: Mark.PropertySet;
+      majorTicks?: PropertySet;
+      minorTicks?: PropertySet;
+      grid?: PropertySet;
+      labels?: PropertySet;
+      title?: PropertySet;
+      axis?: PropertySet;
     }
   }
 
@@ -246,9 +366,9 @@ declare module Vega {
     name?: string;
     description?: string;
     from?: Mark.From;
-    properties?: Mark.PropertySets;
+    properties?: PropertySets;
     key?: string;
-    delay?: Mark.ValueRef;
+    delay?: ValueRef;
   }
 
   export module Mark {
@@ -257,80 +377,107 @@ declare module Vega {
       data?: string;
       transform?: Data.Transform[];
     }
+  }
 
-    export interface PropertySets {
-      // TODO docs
-      enter?: PropertySet;
-      exit?: PropertySet;
-      update?: PropertySet;
-      hover?: PropertySet;
-    }
+  export interface PropertySets {
+    // TODO docs
+    enter?: PropertySet;
+    exit?: PropertySet;
+    update?: PropertySet;
+    hover?: PropertySet;
+  }
 
-    export interface PropertySet {
-      // TODO docs
+  export interface PropertySet {
+    // TODO docs
 
-      // -- Shared visual properties
-      x?: ValueRef;
-      x2?: ValueRef;
-      width?: ValueRef;
-      y?: ValueRef;
-      y2?: ValueRef;
-      height?: ValueRef;
-      opacity?: ValueRef;
-      fill?: ValueRef;
-      fillOpacity?: ValueRef;
-      stroke?: ValueRef;
-      strokeWidth?: ValueRef;
-      strokeOpacity?: ValueRef;
-      strokeDash?: ValueRef;
-      strokeDashOffset?: ValueRef;
+    // -- Shared visual properties
+    x?: ValueRef;
+    x2?: ValueRef;
+    width?: ValueRef;
+    y?: ValueRef;
+    y2?: ValueRef;
+    height?: ValueRef;
+    opacity?: ValueRef;
+    fill?: ValueRef;
+    fillOpacity?: ValueRef;
+    stroke?: ValueRef;
+    strokeWidth?: ValueRef;
+    strokeOpacity?: ValueRef;
+    strokeDash?: ValueRef;
+    strokeDashOffset?: ValueRef;
 
-      // -- symbol
-      size?: ValueRef;
-      shape?: ValueRef;
+    // -- symbol
+    size?: ValueRef;
+    shape?: ValueRef;
 
-      // -- path
-      path?: ValueRef;
+    // -- path
+    path?: ValueRef;
 
-      // -- arc
-      innerRadius?: ValueRef;
-      outerRadius?: ValueRef;
-      startAngle?: ValueRef;
-      endAngle?: ValueRef;
+    // -- arc
+    innerRadius?: ValueRef;
+    outerRadius?: ValueRef;
+    startAngle?: ValueRef;
+    endAngle?: ValueRef;
 
-      // -- area / line
-      interpolate?: ValueRef;
-      tension?: ValueRef;
+    // -- area / line
+    interpolate?: ValueRef;
+    tension?: ValueRef;
 
-      // -- image / text
-      align?: ValueRef;
-      baseline?: ValueRef;
+    // -- image / text
+    align?: ValueRef;
+    baseline?: ValueRef;
 
-      // -- image
-      url?: ValueRef;
+    // -- image
+    url?: ValueRef;
 
-      // -- text
-      text?: ValueRef;
-      dx?: ValueRef;
-      dy?: ValueRef;
-      angle?: ValueRef;
-      font?: ValueRef;
-      fontSize?: ValueRef;
-      fontWeight?: ValueRef;
-      fontStyle?: ValueRef;
-    }
+    // -- text
+    text?: ValueRef;
+    dx?: ValueRef;
+    dy?: ValueRef;
+    angle?: ValueRef;
+    font?: ValueRef;
+    fontSize?: ValueRef;
+    fontWeight?: ValueRef;
+    fontStyle?: ValueRef;
+  }
 
-    export interface ValueRef {
-      // TODO docs
-      value?: any;
-      field?: any;
-      group?: any;
-      scale?: any;
-      mult?: number;
-      offset?: number;
-      band?: boolean;
-    }
+  export interface ValueRef {
+    // TODO docs
+    value?: any;
+    field?: any;
+    group?: any;
+    scale?: any;
+    mult?: number;
+    offset?: number;
+    band?: boolean;
   }
 }
 
-declare var vg: Vega.VG;
\ No newline at end of file
+declare module vg {
+  export var parse: Vega.Parse;
+  export module scene {
+    export function item(mark: Vega.Node): Vega.Node;
+  }
+  
+  export class Bounds implements Vega.Bounds {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    clear(): Bounds;
+    set(x1: number, y1: number, x2: number, y2: number): Bounds;
+    add(x: number, y: number): Bounds;
+    expand(d: number): Bounds;
+    round(): Bounds;
+    translate(dx: number, dy: number): Bounds;
+    rotate(angle: number, x: number, y: number): Bounds;
+    union(b: Bounds): Bounds;
+    encloses(b: Bounds): boolean;
+    intersects(b: Bounds): boolean;
+    contains(x: number, y: number): boolean;
+    width(): number;
+    height(): number;
+  }
+
+  // TODO: classes for View, Model, etc.
+}
\ No newline at end of file

From 0a923c753caf2b2c7393c7071854db84f1148cca Mon Sep 17 00:00:00 2001
From: Tom Crockett <crockett@jpl.nasa.gov>
Date: Tue, 25 Feb 2014 16:32:43 -0800
Subject: [PATCH 012/309] Axis items are Nodes

---
 vega/vega.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vega/vega.d.ts b/vega/vega.d.ts
index f12871625..ebe89da02 100644
--- a/vega/vega.d.ts
+++ b/vega/vega.d.ts
@@ -173,7 +173,7 @@ declare module Vega {
 
     // group members
     scales?: {[name: string]: any};
-    axisItems?: any[];
+    axisItems?: Node[];
   }
 
   export interface Defs {

From ec9eac3e8bd54b0bf3fbbe0be47e7e6881a79638 Mon Sep 17 00:00:00 2001
From: Alex Puchkov <me@apuchkov.com>
Date: Thu, 27 Feb 2014 11:22:04 -0500
Subject: [PATCH 013/309] Fix angularjs/angular-route.d.ts

IRoute.caseInsensitiveMatch was missing
---
 angularjs/angular-route.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/angularjs/angular-route.d.ts b/angularjs/angular-route.d.ts
index b8d1db50b..628d746df 100644
--- a/angularjs/angular-route.d.ts
+++ b/angularjs/angular-route.d.ts
@@ -41,6 +41,7 @@ declare module ng.route {
         resolve?: any;
         redirectTo?: any;
         reloadOnSearch?: boolean;
+        caseInsensitiveMatch?: boolean;
     }
 
     // see http://docs.angularjs.org/api/ng.$route#current

From 9006a88ab5a9cc9695c8640a19af3babf0e38f52 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Fri, 28 Feb 2014 00:09:59 +0100
Subject: [PATCH 014/309] converted lazy.js to generics

---
 lazy.js/lazy.js-tests.ts | 232 +++++++++++++++++---------------
 lazy.js/lazy.js.d.ts     | 280 ++++++++++++++++++++-------------------
 2 files changed, 270 insertions(+), 242 deletions(-)

diff --git a/lazy.js/lazy.js-tests.ts b/lazy.js/lazy.js-tests.ts
index 356ee177b..59331377c 100644
--- a/lazy.js/lazy.js-tests.ts
+++ b/lazy.js/lazy.js-tests.ts
@@ -1,9 +1,32 @@
 /// <reference path="lazy.js.d.ts" />
 
-var sequence: LazyJS.Sequence;
-var arraySeq: LazyJS.ArrayLikeSequence;
-var objectSeq: LazyJS.ObjectLikeSequence;
-var asyncSeq: LazyJS.AsyncSequence;
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+interface Foo {
+	foo(): string;
+}
+interface Bar {
+	bar(): string;
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+var foo: Foo;
+var bar: Bar;
+
+var fooArr: Foo[];
+var barArr: Bar[];
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+var fooSequence: LazyJS.Sequence<Foo>;
+var barSequence: LazyJS.Sequence<Bar>;
+var fooArraySeq: LazyJS.ArrayLikeSequence<Foo>;
+var barArraySeq: LazyJS.ArrayLikeSequence<Bar>;
+var fooObjectSeq: LazyJS.ObjectLikeSequence<Foo>;
+var anyObjectSeq: LazyJS.ObjectLikeSequence<any>;
+var fooAsyncSeq: LazyJS.AsyncSequence<Foo>;
+
 var stringSeq: LazyJS.StringLikeSequence;
 
 var obj: Object;
@@ -23,141 +46,142 @@ function fnErrorCallback(error: any): void {
 
 }
 
-function fnValueCallback(value: any): void {
+function fnValueCallback(value: Foo): void {
 }
 
-function fnGetKeyCallback(value: any): string {
-	return '';
+function fnGetKeyCallback(value: Foo): string {
+	return str;
 }
 
-function fnTestCallback(value: any): boolean {
-	return false;
+function fnTestCallback(value: Foo): boolean {
+	return bool;
 }
 
-function fnMapCallback(value: any): any {
-	return null;
+function fnMapCallback(value: Foo): Bar {
+	return bar;
 }
 
 function fnMapStringCallback(value: string): string {
-	return '';
+	return str;
 }
 
-function fnNumberCallback(value: any): number {
-	return 0;
+function fnNumberCallback(value: Foo): number {
+	return num;
 }
 
-function fnMemoCallback(memo: any, value: any): any {
-	return null;
+function fnMemoCallback(memo: Bar, value: Foo): Bar {
+	return bar;
 }
 
-function fnGeneratorCallback(index: number): any {
-	return null;
+function fnGeneratorCallback(index: number): Foo {
+	return foo;
 }
 
 // Lazy
 
-arraySeq = Lazy([]);
-objectSeq = Lazy({});
-stringSeq = Lazy('');
+fooArraySeq = Lazy(fooArr);
+fooObjectSeq = Lazy<Foo>({a:foo, b:foo});
+anyObjectSeq = Lazy<any>({a:num, b:str});
+stringSeq = Lazy(str);
 
 // Strict
 
 var Strict = Lazy.strict();
-arraySeq = Strict([1, 2, num]).pop();
+fooArraySeq = Strict([foo, foo]).pop();
 
 // Sequence
 
-asyncSeq = sequence.async(num);
-sequence = sequence.chunk(num);
-sequence = sequence.compact();
-sequence = sequence.concat(arr);
-sequence = sequence.consecutive(num);
-bool = sequence.contains(x);
-sequence = sequence.countBy(str);
-sequence = sequence.countBy(fnGetKeyCallback);
-sequence = sequence.dropWhile(fnTestCallback);
-sequence = sequence.each(fnValueCallback);
-bool = sequence.every(fnTestCallback);
-sequence = sequence.filter(fnTestCallback);
-sequence = sequence.find(fnTestCallback);
-sequence = sequence.findWhere(obj);
+fooAsyncSeq = fooSequence.async(num);
+fooSequence = fooSequence.chunk(num);
+fooSequence = fooSequence.compact();
+fooSequence = fooSequence.concat(arr);
+fooSequence = fooSequence.consecutive(num);
+bool = fooSequence.contains(foo);
+fooSequence = fooSequence.countBy(str);
+fooObjectSeq = fooSequence.countBy(fnGetKeyCallback);
+fooSequence = fooSequence.dropWhile(fnTestCallback);
+fooSequence = fooSequence.each(fnValueCallback);
+bool = fooSequence.every(fnTestCallback);
+fooSequence = fooSequence.filter(fnTestCallback);
+fooSequence = fooSequence.find(fnTestCallback);
+fooSequence = fooSequence.findWhere(obj);
 
-x = sequence.first();
-sequence = sequence.first(num);
+x = fooSequence.first();
+fooSequence = fooSequence.first(num);
 
-sequence = sequence.flatten();
-objectSeq = sequence.groupBy(fnGetKeyCallback);
-sequence = sequence.indexOf(x);
-sequence = sequence.initial();
-sequence = sequence.initial(num);
-sequence = sequence.intersection(arr);
-sequence = sequence.invoke(str);
-bool = sequence.isEmpty();
-str = sequence.join();
-str = sequence.join(str);
+fooSequence = fooSequence.flatten();
+fooObjectSeq = fooSequence.groupBy(fnGetKeyCallback);
+fooSequence = fooSequence.indexOf(x);
+fooSequence = fooSequence.initial();
+fooSequence = fooSequence.initial(num);
+fooSequence = fooSequence.intersection(arr);
+fooSequence = fooSequence.invoke(str);
+bool = fooSequence.isEmpty();
+str = fooSequence.join();
+str = fooSequence.join(str);
 
-x = sequence.last();
-sequence = sequence.last(num);
+foo = fooSequence.last();
+fooSequence = fooSequence.last(num);
 
-sequence = sequence.lastIndexOf(x);
-sequence = sequence.map(fnMapCallback);
-x = sequence.max();
-x = sequence.max(fnNumberCallback);
-x = sequence.min();
-x = sequence.min(fnNumberCallback);
-sequence = sequence.pluck(str);
-x = sequence.reduce(fnMemoCallback);
-x = sequence.reduce(fnMemoCallback, x);
-x = sequence.reduceRight(fnMemoCallback, x);
-sequence = sequence.reject(fnTestCallback);
-sequence = sequence.rest(num);
-sequence = sequence.reverse();
-sequence = sequence.shuffle();
-bool = sequence.some();
-bool = sequence.some(fnTestCallback);
-sequence = sequence.sortBy(fnNumberCallback);
-sequence = sequence.sortedIndex(x);
-sequence = sequence.sum();
-sequence = sequence.sum(fnNumberCallback);
-sequence = sequence.takeWhile(fnTestCallback);
-sequence = sequence.union(arr);
-sequence = sequence.uniq();
-sequence = sequence.where(obj);
-sequence = sequence.without(arr);
-sequence = sequence.zip(arr);
+fooSequence = fooSequence.lastIndexOf(foo);
+fooSequence = fooSequence.map(fnMapCallback);
+foo = fooSequence.max();
+foo = fooSequence.max(fnNumberCallback);
+foo = fooSequence.min();
+foo = fooSequence.min(fnNumberCallback);
+fooSequence = fooSequence.pluck(str);
+bar = fooSequence.reduce(fnMemoCallback);
+bar = fooSequence.reduce(fnMemoCallback, bar);
+bar = fooSequence.reduceRight(fnMemoCallback, bar);
+fooSequence = fooSequence.reject(fnTestCallback);
+fooSequence = fooSequence.rest(num);
+fooSequence = fooSequence.reverse();
+fooSequence = fooSequence.shuffle();
+bool = fooSequence.some();
+bool = fooSequence.some(fnTestCallback);
+fooSequence = fooSequence.sortBy(fnNumberCallback);
+fooSequence = fooSequence.sortedIndex(foo);
+fooSequence = fooSequence.sum();
+fooSequence = fooSequence.sum(fnNumberCallback);
+fooSequence = fooSequence.takeWhile(fnTestCallback);
+fooSequence = fooSequence.union(fooArr);
+fooSequence = fooSequence.uniq();
+fooSequence = fooSequence.where(obj);
+fooSequence = fooSequence.without(fooArr);
+fooSequence = fooSequence.zip(arr);
 
-arr = sequence.toArray();
-obj = sequence.toObject();
+fooArr = fooSequence.toArray();
+obj = fooSequence.toObject();
 
 // ArrayLikeSequence
 
-arraySeq = arraySeq.concat();
-arraySeq = arraySeq.first();
-arraySeq = arraySeq.first(num);
-x = arraySeq.get(num);
-num = arraySeq.length();
-arraySeq = arraySeq.map(fnMapCallback);
-arraySeq = arraySeq.pop();
-arraySeq = arraySeq.rest();
-arraySeq = arraySeq.rest(num);
-arraySeq = arraySeq.reverse();
-arraySeq = arraySeq.shift();
-arraySeq = arraySeq.slice(num);
-arraySeq = arraySeq.slice(num, num);
+fooArraySeq = fooArraySeq.concat();
+fooArraySeq = fooArraySeq.first();
+fooArraySeq = fooArraySeq.first(num);
+foo = fooArraySeq.get(num);
+num = fooArraySeq.length();
+barArraySeq = fooArraySeq.map(fnMapCallback);
+fooArraySeq = fooArraySeq.pop();
+fooArraySeq = fooArraySeq.rest();
+fooArraySeq = fooArraySeq.rest(num);
+fooArraySeq = fooArraySeq.reverse();
+fooArraySeq = fooArraySeq.shift();
+fooArraySeq = fooArraySeq.slice(num);
+fooArraySeq = fooArraySeq.slice(num, num);
 
 // ObjectLikeSequence
 
-objectSeq = objectSeq.defaults(obj);
-sequence = objectSeq.functions();
-objectSeq = objectSeq.get(str);
-objectSeq = objectSeq.invert();
-sequence = objectSeq.keys();
-objectSeq = objectSeq.omit(strArr);
-sequence = objectSeq.pairs();
-objectSeq = objectSeq.pick(strArr);
-arr = objectSeq.toArray();
-obj = objectSeq.toObject();
-sequence = objectSeq.values();
+fooObjectSeq = fooObjectSeq.defaults(obj);
+fooSequence = fooObjectSeq.functions();
+fooObjectSeq = fooObjectSeq.get(str);
+fooObjectSeq = fooObjectSeq.invert();
+stringSeq = fooObjectSeq.keys();
+fooObjectSeq = fooObjectSeq.omit(strArr);
+fooSequence = fooObjectSeq.pairs();
+fooObjectSeq = fooObjectSeq.pick(strArr);
+arr = fooObjectSeq.toArray();
+obj = fooObjectSeq.toObject();
+fooSequence = fooObjectSeq.values();
 
 // StringLikeSequence
 
@@ -181,8 +205,8 @@ stringSeq = stringSeq.mapString(fnMapStringCallback);
 stringSeq = stringSeq.match(exp);
 stringSeq = stringSeq.reverse();
 
-sequence = stringSeq.split(str);
-sequence = stringSeq.split(exp);
+stringSeq = stringSeq.split(str);
+stringSeq = stringSeq.split(exp);
 
 bool = stringSeq.startsWith(str);
 stringSeq = stringSeq.substring(num);
diff --git a/lazy.js/lazy.js.d.ts b/lazy.js/lazy.js.d.ts
index 47925bdf9..53de92ae3 100644
--- a/lazy.js/lazy.js.d.ts
+++ b/lazy.js/lazy.js.d.ts
@@ -6,28 +6,31 @@
 declare module LazyJS {
 
 	interface LazyStatic {
-		(value:string):StringLikeSequence;
-		(value:any[]):ArrayLikeSequence;
-		(value:Object):ObjectLikeSequence;
-		(value:ArrayLike):ArrayLikeSequence;
+		(value: string):StringLikeSequence;
+
+		<T>(value: T[]):ArrayLikeSequence<T>;
+		(value: any[]):ArrayLikeSequence<any>;
+		<T>(value: Object):ObjectLikeSequence<T>;
+		(value: Object):ObjectLikeSequence<any>;
 
 		strict():LazyStatic;
 
-		generate(generatorFn:GeneratorCallback, length?:number):GeneratedSequence;
+		generate<T>(generatorFn: GeneratorCallback<T>, length?: number):GeneratedSequence<T>;
 
-		range(to:number):GeneratedSequence;
-		range(from:number, to:number, step?:number):GeneratedSequence;
+		range(to: number):GeneratedSequence<number>;
+		range(from: number, to: number, step?: number):GeneratedSequence<number>;
 
-		repeat(value:any, count?:number):GeneratedSequence;
+		repeat<T>(value: T, count?: number):GeneratedSequence<T>;
 
-		on(eventType:string):Sequence;
+		on<T>(eventType: string):Sequence<T>;
 
-		readFile(path:string):StringLikeSequence;
-		makeHttpRequest(path:string):StringLikeSequence;
+		readFile(path: string):StringLikeSequence;
+		makeHttpRequest(path: string):StringLikeSequence;
 	}
 
-	interface ArrayLike {
+	interface ArrayLike<T> {
 		length:number;
+		[index:number]:T;
 	}
 
 	interface Callback {
@@ -35,212 +38,213 @@ declare module LazyJS {
 	}
 
 	interface ErrorCallback {
-		(error:any):void;
+		(error: any):void;
 	}
 
-	interface ValueCallback {
-		(value:any):void;
+	interface ValueCallback<T> {
+		(value: T):void;
 	}
 
-	interface GetKeyCallback {
-		(value:any):string;
+	interface GetKeyCallback<T> {
+		(value: T):string;
 	}
 
-	interface TestCallback {
-		(value:any):boolean;
+	interface TestCallback<T> {
+		(value: T):boolean;
 	}
 
-	interface MapCallback {
-		(value:any):any;
+	interface MapCallback<T, U> {
+		(value: T):U;
 	}
 
 	interface MapStringCallback {
-		(value:string):string;
+		(value: string):string;
 	}
 
-	interface NumberCallback {
-		(value:any):number;
+	interface NumberCallback<T> {
+		(value: T):number;
 	}
 
-	interface MemoCallback {
-		(memo:any, value:any):any;
+	interface MemoCallback<T, U> {
+		(memo: U, value: T):U;
 	}
 
-	interface GeneratorCallback {
-		(index:number):any;
+	interface GeneratorCallback<T> {
+		(index: number):T;
 	}
 
 	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-	interface Iterator {
-		new(sequence:Sequence):Iterator;
-		current():any;
+	interface Iterator<T> {
+		new (sequence: Sequence<T>):Iterator<T>;
+		current():T;
 		moveNext():boolean;
 	}
 
-	interface GeneratedSequence extends Sequence {
-		new(generatorFn:GeneratorCallback, length:number):GeneratedSequence;
+	interface GeneratedSequence<T> extends Sequence<T> {
+		new(generatorFn: GeneratorCallback<T>, length: number):GeneratedSequence<T>;
 		length():number;
 	}
 
-	interface AsyncSequence extends SequenceBase {
-		each(callback:ValueCallback):AsyncHandle;
+	interface AsyncSequence<T> extends SequenceBase<T> {
+		each(callback: ValueCallback<T>):AsyncHandle<T>;
 	}
 
-	interface AsyncHandle {
+	interface AsyncHandle<T> {
 		cancel():void;
-		onComplete(callback:Callback):void;
-		onError(callback:ErrorCallback):void;
+		onComplete(callback: Callback):void;
+		onError(callback: ErrorCallback):void;
 	}
 
 	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	module Sequence {
-		function define(methodName:string[], overrides:Object):Function;
+		function define(methodName: string[], overrides: Object): Function;
 	}
 
-	interface Sequence extends SequenceBase {
-		each(eachFn:ValueCallback):Sequence;
+	interface Sequence<T> extends SequenceBase<T> {
+		each(eachFn: ValueCallback<T>):Sequence<T>;
 	}
 
-	interface SequenceBase extends SequenceBaser {
+	interface SequenceBase<T> extends SequenceBaser<T> {
 		first():any;
-		first(count:number):Sequence;
-		indexOf(value:any, startIndex?:number):Sequence;
+		first(count: number):Sequence<T>;
+		indexOf(value: any, startIndex?: number):Sequence<T>;
 
 		last():any;
-		last(count:number):Sequence;
-		lastIndexOf(value:any):Sequence;
+		last(count: number):Sequence<T>;
+		lastIndexOf(value: any):Sequence<T>;
 
-		reverse():Sequence;
+		reverse():Sequence<T>;
 	}
 
-	interface SequenceBaser {
+	interface SequenceBaser<T> {
 		// TODO improve define() (needs ugly overload)
-		async(interval:number):AsyncSequence;
-		chunk(size:number):Sequence;
-		compact():Sequence;
-		concat(var_args:any[]):Sequence;
-		consecutive(length:number):Sequence;
-		contains(value:any):boolean;
-		countBy(propertyName:string):Sequence;
-		countBy(keyFn:GetKeyCallback):Sequence;
-		dropWhile(predicateFn:TestCallback):Sequence;
-		every(predicateFn:TestCallback):boolean;
-		filter(predicateFn:TestCallback):Sequence;
-		find(predicateFn:TestCallback):Sequence;
-		findWhere(properties:Object):Sequence;
+		async(interval: number):AsyncSequence<T>;
+		chunk(size: number):Sequence<T>;
+		compact():Sequence<T>;
+		concat(var_args: T[]):Sequence<T>;
+		consecutive(length: number):Sequence<T>;
+		contains(value: T):boolean;
+		countBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
+		countBy(propertyName: string): ObjectLikeSequence<T>;
+		dropWhile(predicateFn: TestCallback<T>): Sequence<T>;
+		every(predicateFn: TestCallback<T>): boolean;
+		filter(predicateFn: TestCallback<T>): Sequence<T>;
+		find(predicateFn: TestCallback<T>): Sequence<T>;
+		findWhere(properties: Object): Sequence<T>;
 
-		flatten():Sequence;
-		groupBy(keyFn:GetKeyCallback):ObjectLikeSequence;
-		initial(count?:number):Sequence;
-		intersection(var_args:any[]):Sequence;
-		invoke(methodName:string):Sequence;
-		isEmpty():boolean;
-		join(delimiter?:string):string;
-		map(mapFn:MapCallback):Sequence;
-		max(valueFn?:NumberCallback):any;
-		min(valueFn?:NumberCallback):any;
-		pluck(propertyName:string):Sequence;
-		reduce(aggregatorFn:MemoCallback, memo?:any):any;
-		reduceRight(aggregatorFn:MemoCallback, memo:any):any;
-		reject(predicateFn:TestCallback):Sequence;
-		rest(count?:number):Sequence;
-		shuffle():Sequence;
-		some(predicateFn?:TestCallback):boolean;
-		sortBy(sortFn:NumberCallback):Sequence;
-		sortedIndex(value:any):Sequence;
-		sum(valueFn?:NumberCallback):Sequence;
-		takeWhile(predicateFn:TestCallback):Sequence;
-		union(var_args:any[]):Sequence;
-		uniq():Sequence;
-		where(properties:Object):Sequence;
-		without(var_args:any[]):Sequence;
-		zip(var_args:any[]):Sequence;
+		flatten(): Sequence<T>;
+		groupBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
+		initial(count?: number): Sequence<T>;
+		intersection(var_args: T[]): Sequence<T>;
+		invoke(methodName: string): Sequence<T>;
+		isEmpty(): boolean;
+		join(delimiter?: string): string;
+		map<U>(mapFn: MapCallback<T, U>): Sequence<T>;
 
-		toArray():any[];
-		toObject():Object;
+		max(valueFn?: NumberCallback<T>): T;
+		min(valueFn?: NumberCallback<T>): T;
+		pluck(propertyName: string): Sequence<T>;
+		reduce<U>(aggregatorFn: MemoCallback<T, U>, memo?: U): U;
+		reduceRight<U>(aggregatorFn: MemoCallback<T, U>, memo: U): U;
+		reject(predicateFn: TestCallback<T>): Sequence<T>;
+		rest(count?: number): Sequence<T>;
+		shuffle(): Sequence<T>;
+		some(predicateFn?: TestCallback<T>): boolean;
+		sortBy(sortFn: NumberCallback<T>): Sequence<T>;
+		sortedIndex(value: T): Sequence<T>;
+		sum(valueFn?: NumberCallback<T>): Sequence<T>;
+		takeWhile(predicateFn: TestCallback<T>): Sequence<T>;
+		union(var_args: T[]): Sequence<T>;
+		uniq(): Sequence<T>;
+		where(properties: Object): Sequence<T>;
+		without(var_args: T[]): Sequence<T>;
+		zip(var_args: T[]): Sequence<T>;
+
+		toArray(): T[];
+		toObject(): Object;
 	}
 
 	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	module ArrayLikeSequence {
-		function define(methodName:string[], overrides:Object):Function;
+		function define(methodName: string[], overrides: Object): Function;
 	}
 
-	interface ArrayLikeSequence extends Sequence {
+	interface ArrayLikeSequence<T> extends Sequence<T> {
 		// define()X;
-		concat():ArrayLikeSequence;
-		first(count?:number):ArrayLikeSequence;
-		get(index:number):any;
-		length():number;
-		map(mapFn:MapCallback):ArrayLikeSequence;
-		pop():ArrayLikeSequence;
-		rest(count?:number):ArrayLikeSequence;
-		reverse():ArrayLikeSequence;
-		shift():ArrayLikeSequence;
-		slice(begin:number, end?:number):ArrayLikeSequence;
+		concat(): ArrayLikeSequence<T>;
+		first(count?: number): ArrayLikeSequence<T>;
+		get(index: number): T;
+		length(): number;
+		map<U>(mapFn: MapCallback<T, U>): ArrayLikeSequence<U>;
+		pop(): ArrayLikeSequence<T>;
+		rest(count?: number): ArrayLikeSequence<T>;
+		reverse(): ArrayLikeSequence<T>;
+		shift(): ArrayLikeSequence<T>;
+		slice(begin: number, end?: number): ArrayLikeSequence<T>;
 	}
 
 	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	module ObjectLikeSequence {
-		function define(methodName:string[], overrides:Object):Function;
+		function define(methodName: string[], overrides: Object): Function;
 	}
 
-	interface ObjectLikeSequence extends Sequence {
-		assign(other:Object):ObjectLikeSequence;
+	interface ObjectLikeSequence<T> extends Sequence<T> {
+		assign(other: Object): ObjectLikeSequence<T>;
 		// throws error
-		//async():X;
-		defaults(defaults:Object):ObjectLikeSequence;
-		functions():Sequence;
-		get(property:string):ObjectLikeSequence;
-		invert():ObjectLikeSequence;
-		keys():Sequence;
-		omit(properties:string[]):ObjectLikeSequence;
-		pairs():Sequence;
-		pick(properties:string[]):ObjectLikeSequence;
-		toArray():any[];
-		toObject():Object;
-		values():Sequence;
+		//async(): X;
+		defaults(defaults: Object): ObjectLikeSequence<T>;
+		functions(): Sequence<T>;
+		get(property: string): ObjectLikeSequence<T>;
+		invert(): ObjectLikeSequence<T>;
+		keys(): StringLikeSequence;
+		omit(properties: string[]): ObjectLikeSequence<T>;
+		pairs(): Sequence<T>;
+		pick(properties: string[]): ObjectLikeSequence<T>;
+		toArray(): T[];
+		toObject(): Object;
+		values(): Sequence<T>;
 	}
 
 	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	module StringLikeSequence {
-		function define(methodName:string[], overrides:Object):Function;
+		function define(methodName: string[], overrides: Object): Function;
 	}
 
-	interface StringLikeSequence extends SequenceBaser {
-		charAt(index:number):string;
-		charCodeAt(index:number):number;
-		contains(value:string):boolean;
-		endsWith(suffix:string):boolean;
+	interface StringLikeSequence extends SequenceBaser<string> {
+		charAt(index: number): string;
+		charCodeAt(index: number): number;
+		contains(value: string): boolean;
+		endsWith(suffix: string): boolean;
 
-		first():string;
-		first(count:number):StringLikeSequence;
+		first(): string;
+		first(count: number): StringLikeSequence;
 
-		indexOf(substring:string, startIndex?:number):number;
+		indexOf(substring: string, startIndex?: number): number;
 
-		last():string;
-		last(count:number):StringLikeSequence;
+		last(): string;
+		last(count: number): StringLikeSequence;
 
-		lastIndexOf(substring:string, startIndex?:number):number;
-		mapString(mapFn:MapStringCallback):StringLikeSequence;
-		match(pattern:RegExp):StringLikeSequence;
-		reverse():StringLikeSequence;
+		lastIndexOf(substring: string, startIndex?: number): number;
+		mapString(mapFn: MapStringCallback): StringLikeSequence;
+		match(pattern: RegExp): StringLikeSequence;
+		reverse(): StringLikeSequence;
 
-		split(delimiter:string):Sequence;
-		split(delimiter:RegExp):Sequence;
+		split(delimiter: string): StringLikeSequence;
+		split(delimiter: RegExp): StringLikeSequence;
 
-		startsWith(prefix:string):boolean;
-		substring(start:number, stop?:number):StringLikeSequence;
-		toLowerCase():StringLikeSequence;
-		toUpperCase():StringLikeSequence;
+		startsWith(prefix: string): boolean;
+		substring(start: number, stop?: number): StringLikeSequence;
+		toLowerCase(): StringLikeSequence;
+		toUpperCase(): StringLikeSequence;
 	}
 }
 
-declare var Lazy:LazyJS.LazyStatic;
+declare var Lazy: LazyJS.LazyStatic;
 
 declare module 'lazy.js' {
 export = Lazy;

From 7078d20cc2a9b892ded59f829b0755b6e99e63da Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gy=C3=B6rgy=20Bal=C3=A1ssy?= <balassy@aut.bme.hu>
Date: Sun, 2 Mar 2014 10:45:33 +0100
Subject: [PATCH 015/309] Support AMD

Added an export module, because the original state-machine.js supports AMD, which feature was not available from TypeScript before this patch.
---
 state-machine/state-machine.d.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/state-machine/state-machine.d.ts b/state-machine/state-machine.d.ts
index 0805a1db3..c5c9c83bf 100644
--- a/state-machine/state-machine.d.ts
+++ b/state-machine/state-machine.d.ts
@@ -79,3 +79,7 @@ interface StateMachine {
 }
 
 declare var StateMachine: StateMachineStatic;
+
+declare module "state-machine" { 
+    export = StateMachineStatic; 
+}

From 4dbe22c2673033fb0c56adf56654648b7fc28885 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=A1clav=20Oborn=C3=ADk?= <register.ufon@gmail.com>
Date: Sun, 2 Mar 2014 13:52:38 +0100
Subject: [PATCH 016/309] Moved definitions from global (evil) context to
 'restify' module/namespace, added inheritance of Server, Request and Response
 from nodejs 'http' module

---
 restify/restify.d.ts | 48 +++++++++++++++++++++++++-------------------
 1 file changed, 27 insertions(+), 21 deletions(-)

diff --git a/restify/restify.d.ts b/restify/restify.d.ts
index cd65e6666..57d00b67f 100644
--- a/restify/restify.d.ts
+++ b/restify/restify.d.ts
@@ -3,13 +3,20 @@
 // Definitions by: Bret Little <https://github.com/blittle>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-interface addressInterface {
+/// <reference path="../node/node.d.ts" />
+
+
+declare module "restify" {
+  import http = require('http');
+
+
+  interface addressInterface {
     port: number;
     family: string;
     address: string;
-}
+  }
 
-interface Request {
+  interface Request extends http.ServerRequest {
     header: (key: string, defaultValue?: string) => any;
     accepts: (type: string) => boolean;
     is: (type: string) => boolean;
@@ -24,9 +31,9 @@ interface Request {
     secure: boolean;
     time: number;
     params: any;
-}
+  }
 
-interface Response {
+  interface Response extends http.ServerResponse {
     header: (key: string, value ?: any) => any;
     cache: (type?: any, options?: Object) => any;
     status: (code: number) => any;
@@ -39,9 +46,9 @@ interface Response {
     headers: Object;
     statusCode: number;
     id: string;
-}
+  }
 
-interface Server {
+  interface Server extends http.Server {
     use: (... handler: any[]) => any;
     post: (route: any, routeCallBack: RequestHadler) => any;
     patch: (route: any, routeCallBack: RequestHadler) => any;
@@ -60,9 +67,9 @@ interface Server {
     close: (... args: any[]) => any;
     pre: (routeCallBack: RequestHadler) => any;
 
-}
+  }
 
-interface ServerOptions {
+  interface ServerOptions {
     certificate ?: string;
     key ?: string;
     formatters ?: Object;
@@ -72,9 +79,9 @@ interface ServerOptions {
     version ?: string;
     responseTimeHeader ?: string;
     responseTimeFormatter ?: (durationInMilliseconds: number) => any;
-}
+  }
 
-interface ClientOptions {
+  interface ClientOptions {
     accept?: string;
     connectTimeout?: number;
     dtrace?: Object;
@@ -86,26 +93,26 @@ interface ClientOptions {
     url?: string;
     userAgent?: string;
     version?: string;
-}
+  }
 
-interface Client {
+  interface Client {
     get: (path: string, callback?: (err: any, req: Request, res: Response, obj: any) => any) => any;
     head: (path: string, callback?: (err: any, req: Request, res: Response) => any) => any;
     post: (path: string, object: any, callback?: (err: any, req: Request, res: Response, obj: any) => any) => any;
     put: (path: string, object: any, callback?: (err: any, req: Request, res: Response, obj: any) => any) => any;
     del: (path: string, callback?: (err: any, req: Request, res: Response) => any) => any;
     basicAuth: (username: string, password: string) => any;
-}
+  }
 
-interface HttpClient extends Client {
+  interface HttpClient extends Client {
     get: (path?: any, callback?: Function) => any;
     head: (path?:any, callback?: Function) => any;
     post: (opts?: any, callback?: Function) => any;
     put: (opts?: any, callback?: Function) => any;
     del: (opts?: any, callback?: Function) => any;
-}
+  }
 
-interface ThrottleOptions {
+  interface ThrottleOptions {
     burst?: number;
     rate?: number;
     ip?: boolean;
@@ -114,13 +121,12 @@ interface ThrottleOptions {
     tokensTable?: Object;
     maxKeys?: number;
     overrides?: Object;
-}
+  }
 
-interface RequestHadler {
+  interface RequestHadler {
     (req: Request, res: Response, next: Function): any;
-}
+  }
 
-declare module "restify" {
     export function createServer(options?: ServerOptions): Server;
 
     export function createJsonClient(options?: ClientOptions): Client;

From 4a4c40b9a42c01a0e0370e9c81d12eff1be446ea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=A1clav=20Oborn=C3=ADk?= <register.ufon@gmail.com>
Date: Sun, 2 Mar 2014 14:17:41 +0100
Subject: [PATCH 017/309] removed 'on' method from Server definition, it is
 inherited now

---
 restify/restify.d.ts | 75 ++++++++++++++++++++++----------------------
 1 file changed, 38 insertions(+), 37 deletions(-)

diff --git a/restify/restify.d.ts b/restify/restify.d.ts
index 57d00b67f..8f02f4b0b 100644
--- a/restify/restify.d.ts
+++ b/restify/restify.d.ts
@@ -31,6 +31,8 @@ declare module "restify" {
     secure: boolean;
     time: number;
     params: any;
+
+    body?: any; //available when bodyParser plugin is used
   }
 
   interface Response extends http.ServerResponse {
@@ -56,7 +58,6 @@ declare module "restify" {
     del: (route: any, routeCallBack: RequestHadler) => any;
     get: (route: any, routeCallBack: RequestHadler) => any;
     head: (route: any, routeCallBack: RequestHadler) => any;
-    on: (event: string, callback: Function) => any;
     name: string;
     version: string;
     log: Object;
@@ -127,43 +128,43 @@ declare module "restify" {
     (req: Request, res: Response, next: Function): any;
   }
 
-    export function createServer(options?: ServerOptions): Server;
+  export function createServer(options?: ServerOptions): Server;
 
-    export function createJsonClient(options?: ClientOptions): Client;
-    export function createStringClient(options?: ClientOptions): Client;
-    export function createClient(options?: ClientOptions): HttpClient;
+  export function createJsonClient(options?: ClientOptions): Client;
+  export function createStringClient(options?: ClientOptions): Client;
+  export function createClient(options?: ClientOptions): HttpClient;
 
-    export class ConflictError { constructor(message?: any); }
-    export class InvalidArguementError { constructor(message?: any); }
-    export class RestError { constructor(message?: any); }
-    export class BadDigestError { constructor(message: any); }
-    export class BadMethodError { constructor(message: any); }
-    export class BadRequestError { constructor(message: any); }
-    export class InternalError { constructor(message: any); }
-    export class InvalidContentError { constructor(message: any); }
-    export class InvalidCredentialsError { constructor(message: any); }
-    export class InvalidHeaderError { constructor(message: any); }
-    export class InvalidVersionError { constructor(message: any); }
-    export class MissingParameterError { constructor(message: any); }
-    export class NotAuthorizedError { constructor(message: any); }
-    export class RequestExpiredError { constructor(message: any); }
-    export class RequestThrottledError { constructor(message: any); }
-    export class ResourceNotFoundError { constructor(message: any); }
-    export class WrongAcceptError { constructor(message: any); }
+  export class ConflictError { constructor(message?: any); }
+  export class InvalidArguementError { constructor(message?: any); }
+  export class RestError { constructor(message?: any); }
+  export class BadDigestError { constructor(message: any); }
+  export class BadMethodError { constructor(message: any); }
+  export class BadRequestError { constructor(message: any); }
+  export class InternalError { constructor(message: any); }
+  export class InvalidContentError { constructor(message: any); }
+  export class InvalidCredentialsError { constructor(message: any); }
+  export class InvalidHeaderError { constructor(message: any); }
+  export class InvalidVersionError { constructor(message: any); }
+  export class MissingParameterError { constructor(message: any); }
+  export class NotAuthorizedError { constructor(message: any); }
+  export class RequestExpiredError { constructor(message: any); }
+  export class RequestThrottledError { constructor(message: any); }
+  export class ResourceNotFoundError { constructor(message: any); }
+  export class WrongAcceptError { constructor(message: any); }
 
-    export function acceptParser(parser: any): RequestHadler;
-    export function authorizationParser(): RequestHadler;
-    export function dateParser(skew?: number): RequestHadler;
-    export function queryParser(options?: Object): RequestHadler;
-    export function urlEncodedBodyParser(options?: Object): RequestHadler[];
-    export function jsonp(): RequestHadler;
-    export function gzipResponse(options?: Object): RequestHadler;
-    export function bodyParser(options?: Object): RequestHadler[];
-    export function requestLogger(options?: Object): RequestHadler;
-    export function serveStatic(options?: Object): RequestHadler;
-    export function throttle(options?: ThrottleOptions): RequestHadler;
-    export function conditionalRequest(): RequestHadler[];
-    export function auditLogger(options?: Object): Function;
-    export function fullResponse(): RequestHadler;
-    export var defaultResponseHeaders : any;
+  export function acceptParser(parser: any): RequestHadler;
+  export function authorizationParser(): RequestHadler;
+  export function dateParser(skew?: number): RequestHadler;
+  export function queryParser(options?: Object): RequestHadler;
+  export function urlEncodedBodyParser(options?: Object): RequestHadler[];
+  export function jsonp(): RequestHadler;
+  export function gzipResponse(options?: Object): RequestHadler;
+  export function bodyParser(options?: Object): RequestHadler[];
+  export function requestLogger(options?: Object): RequestHadler;
+  export function serveStatic(options?: Object): RequestHadler;
+  export function throttle(options?: ThrottleOptions): RequestHadler;
+  export function conditionalRequest(): RequestHadler[];
+  export function auditLogger(options?: Object): Function;
+  export function fullResponse(): RequestHadler;
+  export var defaultResponseHeaders : any;
 }

From dd908b1f727b8880d9993efcb515b1f637ec6667 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=A1clav=20Oborn=C3=ADk?= <register.ufon@gmail.com>
Date: Sun, 2 Mar 2014 14:17:41 +0100
Subject: [PATCH 018/309] Removed 'on' method from Server - it is inherited
 now. Added body property to request definition

---
 restify/restify.d.ts | 75 ++++++++++++++++++++++----------------------
 1 file changed, 38 insertions(+), 37 deletions(-)

diff --git a/restify/restify.d.ts b/restify/restify.d.ts
index 57d00b67f..8f02f4b0b 100644
--- a/restify/restify.d.ts
+++ b/restify/restify.d.ts
@@ -31,6 +31,8 @@ declare module "restify" {
     secure: boolean;
     time: number;
     params: any;
+
+    body?: any; //available when bodyParser plugin is used
   }
 
   interface Response extends http.ServerResponse {
@@ -56,7 +58,6 @@ declare module "restify" {
     del: (route: any, routeCallBack: RequestHadler) => any;
     get: (route: any, routeCallBack: RequestHadler) => any;
     head: (route: any, routeCallBack: RequestHadler) => any;
-    on: (event: string, callback: Function) => any;
     name: string;
     version: string;
     log: Object;
@@ -127,43 +128,43 @@ declare module "restify" {
     (req: Request, res: Response, next: Function): any;
   }
 
-    export function createServer(options?: ServerOptions): Server;
+  export function createServer(options?: ServerOptions): Server;
 
-    export function createJsonClient(options?: ClientOptions): Client;
-    export function createStringClient(options?: ClientOptions): Client;
-    export function createClient(options?: ClientOptions): HttpClient;
+  export function createJsonClient(options?: ClientOptions): Client;
+  export function createStringClient(options?: ClientOptions): Client;
+  export function createClient(options?: ClientOptions): HttpClient;
 
-    export class ConflictError { constructor(message?: any); }
-    export class InvalidArguementError { constructor(message?: any); }
-    export class RestError { constructor(message?: any); }
-    export class BadDigestError { constructor(message: any); }
-    export class BadMethodError { constructor(message: any); }
-    export class BadRequestError { constructor(message: any); }
-    export class InternalError { constructor(message: any); }
-    export class InvalidContentError { constructor(message: any); }
-    export class InvalidCredentialsError { constructor(message: any); }
-    export class InvalidHeaderError { constructor(message: any); }
-    export class InvalidVersionError { constructor(message: any); }
-    export class MissingParameterError { constructor(message: any); }
-    export class NotAuthorizedError { constructor(message: any); }
-    export class RequestExpiredError { constructor(message: any); }
-    export class RequestThrottledError { constructor(message: any); }
-    export class ResourceNotFoundError { constructor(message: any); }
-    export class WrongAcceptError { constructor(message: any); }
+  export class ConflictError { constructor(message?: any); }
+  export class InvalidArguementError { constructor(message?: any); }
+  export class RestError { constructor(message?: any); }
+  export class BadDigestError { constructor(message: any); }
+  export class BadMethodError { constructor(message: any); }
+  export class BadRequestError { constructor(message: any); }
+  export class InternalError { constructor(message: any); }
+  export class InvalidContentError { constructor(message: any); }
+  export class InvalidCredentialsError { constructor(message: any); }
+  export class InvalidHeaderError { constructor(message: any); }
+  export class InvalidVersionError { constructor(message: any); }
+  export class MissingParameterError { constructor(message: any); }
+  export class NotAuthorizedError { constructor(message: any); }
+  export class RequestExpiredError { constructor(message: any); }
+  export class RequestThrottledError { constructor(message: any); }
+  export class ResourceNotFoundError { constructor(message: any); }
+  export class WrongAcceptError { constructor(message: any); }
 
-    export function acceptParser(parser: any): RequestHadler;
-    export function authorizationParser(): RequestHadler;
-    export function dateParser(skew?: number): RequestHadler;
-    export function queryParser(options?: Object): RequestHadler;
-    export function urlEncodedBodyParser(options?: Object): RequestHadler[];
-    export function jsonp(): RequestHadler;
-    export function gzipResponse(options?: Object): RequestHadler;
-    export function bodyParser(options?: Object): RequestHadler[];
-    export function requestLogger(options?: Object): RequestHadler;
-    export function serveStatic(options?: Object): RequestHadler;
-    export function throttle(options?: ThrottleOptions): RequestHadler;
-    export function conditionalRequest(): RequestHadler[];
-    export function auditLogger(options?: Object): Function;
-    export function fullResponse(): RequestHadler;
-    export var defaultResponseHeaders : any;
+  export function acceptParser(parser: any): RequestHadler;
+  export function authorizationParser(): RequestHadler;
+  export function dateParser(skew?: number): RequestHadler;
+  export function queryParser(options?: Object): RequestHadler;
+  export function urlEncodedBodyParser(options?: Object): RequestHadler[];
+  export function jsonp(): RequestHadler;
+  export function gzipResponse(options?: Object): RequestHadler;
+  export function bodyParser(options?: Object): RequestHadler[];
+  export function requestLogger(options?: Object): RequestHadler;
+  export function serveStatic(options?: Object): RequestHadler;
+  export function throttle(options?: ThrottleOptions): RequestHadler;
+  export function conditionalRequest(): RequestHadler[];
+  export function auditLogger(options?: Object): Function;
+  export function fullResponse(): RequestHadler;
+  export var defaultResponseHeaders : any;
 }

From c52554f9b9a0db21431d7f0001bf663966a82157 Mon Sep 17 00:00:00 2001
From: Greg Smith <smr.kyu@gmail.com>
Date: Sun, 2 Mar 2014 22:22:19 -0600
Subject: [PATCH 019/309] Phonegap declarations now compile with
 --noImplicitAny

---
 phonegap/phonegap.d.ts | 136 ++++++++++++++++++++++++++++-------------
 1 file changed, 95 insertions(+), 41 deletions(-)

diff --git a/phonegap/phonegap.d.ts b/phonegap/phonegap.d.ts
index 01935142e..37585887b 100644
--- a/phonegap/phonegap.d.ts
+++ b/phonegap/phonegap.d.ts
@@ -121,9 +121,9 @@ interface CaptureError {
 }
 
 interface Capture {
-    captureAudio(captureSuccess: (mediaFiles: MediaFile[]) => void , captureError: (error: CaptureError) =>void , options?: CaptureAudioOptions);
-    captureImage(captureSuccess: (mediaFiles: MediaFile[]) => void , captureError: (error: CaptureError) =>void , options?: CaptureImageOptions);
-    captureVideo(captureSuccess: (mediaFiles: MediaFile[]) => void , captureError: (error: CaptureError) =>void , options?: CaptureImageOptions);
+    captureAudio(captureSuccess: (mediaFiles: MediaFile[]) => void , captureError: (error: CaptureError) =>void , options?: CaptureAudioOptions): void;
+    captureImage(captureSuccess: (mediaFiles: MediaFile[]) => void , captureError: (error: CaptureError) =>void , options?: CaptureImageOptions): void;
+    captureVideo(captureSuccess: (mediaFiles: MediaFile[]) => void , captureError: (error: CaptureError) =>void , options?: CaptureImageOptions): void;
 }
 
 interface Connection {
@@ -204,9 +204,9 @@ interface Contact {
     categories: ContactField[];
     urls: ContactField[];
 
-    save(onSuccess?: (contacts: Contacts) => any, onError?: (contactError: ContactError) => any);
-    remove(onSuccess?: (contacts: Contacts) => any, onError?: (contactError: ContactError) => any);
-    clone(): Contact; 
+    save(onSuccess?: (contacts: Contacts) => void, onError?: (contactError: ContactError) => void): void;
+    remove(onSuccess?: (contacts: Contacts) => void, onError?: (contactError: ContactError) => void): void;
+    clone(): Contact;
 }
 
 interface ContactFindOptions {
@@ -289,10 +289,10 @@ interface FileWriter {
     onerror: Function;
     onwriteend: Function;
 
-    abort();
-    seek();
-    truncate();
-    write();
+    abort(): void;
+    seek(arg: number): void;
+    truncate(arg: number): void;
+    write(arg: any): void;
 }
 
 interface FileSystem {
@@ -310,29 +310,29 @@ interface FileSystemEntry {
     fullPath: string;
     filesystem: FileSystem;
 
-    getMetadata(onSuccess?: (arg) => any, onError?: (arg) => any);
-    setMetadata(onSuccess?: (arg) => any, onError?: (arg) => any, options?);
-    toURL();
-    remove(onSuccess?: (arg) => any, onError?: (arg) => any);
-    getParent(onSuccess?: (arg) => any, onError?: (arg) => any);
+    getMetadata(onSuccess?: (arg: Metadata) => void, onError?: (arg: FileError) => void): void;
+    setMetadata(onSuccess?: (arg: Metadata) => void, onError?: (arg: FileError) => void, options?: any): void;
+    toURL(): string;
+    remove(onSuccess?: () => void, onError?: (arg: FileError) => void): void;
+    getParent(onSuccess?: (arg: DirectoryEntry) => void, onError?: (arg: FileError) => void): void;
 }
 
 interface FileEntry extends FileSystemEntry {
-    moveTo(parentEntry: DirectoryEntry, file: string, onSuccess: (arg) => any, onError: (arg) => any);
-    copyTo(parentEntry: DirectoryEntry, file: string, onSuccess: (arg) => any, onError: (arg) => any);
-    createWriter(onSuccess?: (arg) => any, onError?: (arg) => any);
-    file(onSuccess?: (arg) => any, onError?: (arg) => any);
+    moveTo(parentEntry: DirectoryEntry, file: string, onSuccess: (arg: DirectoryEntry) => void, onError: (arg: FileError) => void): void;
+    copyTo(parentEntry: DirectoryEntry, file: string, onSuccess: (arg: DirectoryEntry) => void, onError: (arg: FileError) => void): void;
+    createWriter(onSuccess?: (arg: FileWriter) => void, onError?: (arg: FileError) => void): void;
+    file(onSuccess?: (arg: File) => void, onError?: (arg: FileError) => void): void;
 }
 
 interface DirectoryEntry extends FileSystemEntry {
-    createReader();
-    getDirectory();
-    getFile();
-    removeRecursively();
+    createReader(): DirectoryReader;
+    getDirectory(path: string, options: Flags, successCallback: (result: DirectoryEntry) => void, errorCallback: (error: FileError) => void): void;
+    getFile(path: string, options: Flags, successCallback: (result: FileEntry) => void, errorCallback: (error: FileError) => void): void;
+    removeRecursively(successCallback: () => void, errorCallback: (error: FileError) => void): void;
 }
 
 interface DirectoryReader {
-    readEntries(successCallback: (entries: FileSystemEntry) => void , errorCallback: (error: FileError) => void );
+    readEntries(successCallback: (entries: FileSystemEntry) => void, errorCallback: (error: FileError) => void): void;
 }
 
 interface FileTransfer {
@@ -365,7 +365,10 @@ interface FileUploadResult {
     response: string;
 }
 
-// TODO Flags
+interface Flags {
+    create: boolean;
+    exclusive: boolean;
+}
 
 /*
 interface LocalFileSystem {
@@ -432,19 +435,70 @@ declare var GlobalizationError: {
     PATTERN_ERROR: number;
 }
 
+interface GlobalizationDate {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+    millisecond: number;
+}
+
+interface GlobalizationDateOptions {
+    formatLength?: string;
+    selector?: string;
+}
+
+interface GlobalizationDatePattern {
+    pattern: string;
+    timezone: string;
+    utc_offset: number;
+    dst_offset: number;
+}
+
+interface GlobalizationDateNameOptions {
+    type?: string;
+    item?: string;
+}
+
+interface GlobalizationNumberOptions {
+    type?: string;
+}
+
+interface GlobalizationNumberPattern {
+    pattern: string;
+    symbol: string;
+    fraction: number;
+    rounding: number;
+    positive: string;
+    negative: string;
+    decimal: string;
+    grouping: string;
+}
+
+interface GlobalizationCurrencyPattern {
+    pattern: string;
+    code: string;
+    fraction: number;
+    rounding: number;
+    decimal: string;
+    grouping: string;
+}
+
 interface Globalization {
-    getPreferredLanguage(successCB, errorCB): void;
-    getLocaleName(successCB, errorCB): void;
-    dateToString(date, successCB, errorCB, options): void;
-    stringToDate(dateString, successCB, errorCB, options): void;
-    getDatePattern(successCB, errorCB, options): void;
-    getDateNames(successCB, errorCB, options): void;
-    isDayLightSavingsTime(date, successCB, errorCB): void;
-    getFirstDayOfWeek(successCB, errorCB): void;
-    numberToString(number, successCB, errorCB, options): void;
-    stringToNumber(string, successCB, errorCB, options): void;
-    getNumberPattern(successCB, errorCB, options): void;
-    getCurrencyPattern(currencyCode, successCB, errorCB): void;
+    getPreferredLanguage(successCallback: (properties: {value: string}) => void, errorCallback: (error: GlobalizationError) => void): void;
+    getLocaleName(successCallback: (properties: {value: string}) => void, errorCallback: (error: GlobalizationError) => void): void;
+    dateToString(date: Date, successCallback: (properties: {value: string}) => void, errorCallback: (error: GlobalizationError) => void, options?: GlobalizationDateOptions): void;
+    stringToDate(dateString: string, successCallback: (properties: GlobalizationDate) => void, errorCallback: (error: GlobalizationError) => void, options?: GlobalizationDateOptions): void;
+    getDatePattern(successCallback: (properties: GlobalizationDatePattern) => void, errorCallback: (error: GlobalizationError) => void, options?: GlobalizationDateOptions): void;
+    getDateNames(successCallback: (properties: {value: string[]}) => void, errorCallback: (error: GlobalizationError) => void, options?: GlobalizationDateNameOptions): void;
+    isDayLightSavingsTime(date: Date, successCallback: (properties: {dst: boolean}) => void, errorCallback: (error: GlobalizationError) => void): void;
+    getFirstDayOfWeek(successCallback: (properties: {value: number}) => void, errorCallback: (error: GlobalizationError) => void): void;
+    numberToString(number: number, successCallback: (properties: {value: string}) => void, errorCallback: (error: GlobalizationError) => void, options?: GlobalizationNumberOptions): void;
+    stringToNumber(string: string, successCallback: (properties: {value: number}) => void, errorCallback: (error: GlobalizationError) => void, options?: GlobalizationNumberOptions): void;
+    getNumberPattern(successCallback: (parameters: GlobalizationNumberPattern) => void, errorCallback: (error: GlobalizationError) => void, options?: GlobalizationNumberOptions): void;
+    getCurrencyPattern(currencyCode: string, successCallback: (parameters: GlobalizationCurrencyPattern) => void, errorCallback: (error: GlobalizationError) => void): void;
 }
 
 /*
@@ -457,7 +511,7 @@ interface InAppBrowser {
 */
 
 interface Media {
-    new (src: string, mediaSuccess: Function, mediaError?: (mediaError: MediaError) => any, mediaStatus?: Function);
+    new (src: string, mediaSuccess: Function, mediaError?: (mediaError: MediaError) => any, mediaStatus?: Function): Media;
     getCurrentPosition(mediaSuccess: Function, mediaError?: (mediaError: MediaError) => any): void;
     getDuration(): any;
     play(): void;
@@ -469,7 +523,7 @@ interface Media {
     stop(): void;
 }
 declare var Media: {
-    new(src: string, onSuccess: (arg) => any, onError: (arg) => any): Media;
+    new(src: string, onSuccess: (arg: any) => any, onError: (error: any) => any): Media;
 }
 
 interface Notification {
@@ -486,8 +540,8 @@ interface Splashscreen {
 }
 
 interface Database {
-    transaction(populateDB?: (tx: SQLTransaction) => any, errorCB?: (err) => any, successCB?: () => any);
-    changeVersion(var1: string, var2: string);
+    transaction(populateDB?: (tx: SQLTransaction) => any, errorCB?: (err: any) => any, successCB?: () => any): void;
+    changeVersion(var1: string, var2: string): void;
 }
 
 interface SQLResultSetRowList {

From 550943276c1719dfc793bcc4df98c5242a0b8935 Mon Sep 17 00:00:00 2001
From: Peter Gill <peter.gill@townsuite.com>
Date: Mon, 3 Mar 2014 10:32:22 -0330
Subject: [PATCH 020/309] Add definition of jquery.placeholder. 
 https://github.com/mathiasbynens/jquery-placeholder

---
 jquery.placeholder/jquery.placeholder-tests.ts |  4 ++++
 jquery.placeholder/jquery.placeholder.d.ts     | 13 +++++++++++++
 2 files changed, 17 insertions(+)
 create mode 100644 jquery.placeholder/jquery.placeholder-tests.ts
 create mode 100644 jquery.placeholder/jquery.placeholder.d.ts

diff --git a/jquery.placeholder/jquery.placeholder-tests.ts b/jquery.placeholder/jquery.placeholder-tests.ts
new file mode 100644
index 000000000..072c03721
--- /dev/null
+++ b/jquery.placeholder/jquery.placeholder-tests.ts
@@ -0,0 +1,4 @@
+/// <reference path="../jquery/jquery.d.ts"/>
+/// <reference path="jquery.placeholder.d.ts"/>
+
+$('input').placeholder();
diff --git a/jquery.placeholder/jquery.placeholder.d.ts b/jquery.placeholder/jquery.placeholder.d.ts
new file mode 100644
index 000000000..2b4d410a7
--- /dev/null
+++ b/jquery.placeholder/jquery.placeholder.d.ts
@@ -0,0 +1,13 @@
+// Type definitions for jquery.placeholder.js 2.0.7
+// Project: https://github.com/mathiasbynens/jquery-placeholder
+// Definitions by: Peter Gill <https://github.com/majorsilence>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../jquery/jquery.d.ts"/>
+
+interface JQuery {
+
+	placeholder();
+
+}
+

From 9667573da9b94d8541001a80eb83e1a247d1f1f8 Mon Sep 17 00:00:00 2001
From: John Kurlak <john@kurlak.com>
Date: Mon, 3 Mar 2014 09:57:36 -0800
Subject: [PATCH 021/309] Made 2nd param of toHaveAttr/toHaveProp optional

Made the second parameter of toHaveAttr() / toHaveProp() optional.
---
 jasmine-jquery/jasmine-jquery.d.ts | 218 ++++++++++++++---------------
 1 file changed, 109 insertions(+), 109 deletions(-)

diff --git a/jasmine-jquery/jasmine-jquery.d.ts b/jasmine-jquery/jasmine-jquery.d.ts
index 520445a23..1d3c30cda 100644
--- a/jasmine-jquery/jasmine-jquery.d.ts
+++ b/jasmine-jquery/jasmine-jquery.d.ts
@@ -3,142 +3,142 @@
 // Definitions by: Gregor Stamac <https://github.com/gstamac/>
 // DefinitelyTyped: https://github.com/borisyankov/DefinitelyTyped
 
-/// <reference path="../jasmine/jasmine.d.ts"/>
-/// <reference path="../jquery/jquery.d.ts"/>
-
-declare function sandbox(attributes?: any): string;
-
-declare function readFixtures(...uls: string[]): string;
-declare function preloadFixtures(...uls: string[]);
-declare function loadFixtures(...uls: string[]);
-declare function appendLoadFixtures(...uls: string[]);
-declare function setFixtures(html: string): string;
-declare function appendSetFixtures(html: string);
-
-declare function preloadStyleFixtures(...uls: string[]);
-declare function loadStyleFixtures(...uls: string[]);
-declare function appendLoadStyleFixtures(...uls: string[]);
-declare function setStyleFixtures(html: string);
-declare function appendSetStyleFixtures(html: string);
-
-declare function loadJSONFixtures(...uls: string[]): jasmine.JSONFixtures;
-declare function getJSONFixture(url: string): any;
+/// <reference path="../jasmine/jasmine.d.ts"/>
+/// <reference path="../jquery/jquery.d.ts"/>
+
+declare function sandbox(attributes?: any): string;
+
+declare function readFixtures(...uls: string[]): string;
+declare function preloadFixtures(...uls: string[]);
+declare function loadFixtures(...uls: string[]);
+declare function appendLoadFixtures(...uls: string[]);
+declare function setFixtures(html: string): string;
+declare function appendSetFixtures(html: string);
+
+declare function preloadStyleFixtures(...uls: string[]);
+declare function loadStyleFixtures(...uls: string[]);
+declare function appendLoadStyleFixtures(...uls: string[]);
+declare function setStyleFixtures(html: string);
+declare function appendSetStyleFixtures(html: string);
+
+declare function loadJSONFixtures(...uls: string[]): jasmine.JSONFixtures;
+declare function getJSONFixture(url: string): any;
+
+declare function spyOnEvent(selector: string, eventName: string): jasmine.JQueryEventSpy;
 
-declare function spyOnEvent(selector: string, eventName: string): jasmine.JQueryEventSpy;
-
 declare module jasmine {
-    function spiedEventsKey(selector: JQuery, eventName: string): string;
+    function spiedEventsKey(selector: JQuery, eventName: string): string;
 
-    function getFixtures(): Fixtures;
-    function getStyleFixtures(): StyleFixtures;
-    function getJSONFixtures(): JSONFixtures;
+    function getFixtures(): Fixtures;
+    function getStyleFixtures(): StyleFixtures;
+    function getJSONFixtures(): JSONFixtures;
 
     interface Fixtures {
         fixturesPath: string;
         containerId: string;
-        set(html: string): string;
-        appendSet(html: string);
-        preload(...uls: string[]);
-        load(...uls: string[]);
-        appendLoad(...uls: string[]);
-        read(...uls: string[]): string;
-        clearCache();
-        cleanUp();
-        sandbox(attributes?: any): string;
-        createContainer_(html: string);
-        addToContainer_(html: string);
-        getFixtureHtml_(url: string): string;
-        loadFixtureIntoCache_(relativeUrl: string);
-        makeFixtureUrl_(relativeUrl: string): string;
-        proxyCallTo_(methodName: string, passedArguments): any;
+        set(html: string): string;
+        appendSet(html: string);
+        preload(...uls: string[]);
+        load(...uls: string[]);
+        appendLoad(...uls: string[]);
+        read(...uls: string[]): string;
+        clearCache();
+        cleanUp();
+        sandbox(attributes?: any): string;
+        createContainer_(html: string);
+        addToContainer_(html: string);
+        getFixtureHtml_(url: string): string;
+        loadFixtureIntoCache_(relativeUrl: string);
+        makeFixtureUrl_(relativeUrl: string): string;
+        proxyCallTo_(methodName: string, passedArguments): any;
     }
 
     interface StyleFixtures {
         fixturesPath: string;
-        set(html: string): string;
-        appendSet(html: string);
-        preload(...uls: string[]);
-        load(...uls: string[]);
-        appendLoad(...uls: string[]);
-        read_(...uls: string[]): string;
-        clearCache();
-        cleanUp();
-        createStyle_(html: string);
-        getFixtureHtml_(url: string): string;
-        loadFixtureIntoCache_(relativeUrl: string);
-        makeFixtureUrl_(relativeUrl: string): string;
-        proxyCallTo_(methodName: string, passedArguments): any;
+        set(html: string): string;
+        appendSet(html: string);
+        preload(...uls: string[]);
+        load(...uls: string[]);
+        appendLoad(...uls: string[]);
+        read_(...uls: string[]): string;
+        clearCache();
+        cleanUp();
+        createStyle_(html: string);
+        getFixtureHtml_(url: string): string;
+        loadFixtureIntoCache_(relativeUrl: string);
+        makeFixtureUrl_(relativeUrl: string): string;
+        proxyCallTo_(methodName: string, passedArguments): any;
     }
 
     interface JSONFixtures {
         fixturesPath: string;
-        load(...uls: string[]);
-        read(...uls: string[]): string;
-        clearCache();
-        getFixtureData_(url: string): any;
-        loadFixtureIntoCache_(relativeUrl: string);
+        load(...uls: string[]);
+        read(...uls: string[]): string;
+        clearCache();
+        getFixtureData_(url: string): any;
+        loadFixtureIntoCache_(relativeUrl: string);
         proxyCallTo_(methodName: string, passedArguments): any;
     }
 
     interface Matchers {
         toHaveClass(className: string): boolean;
-        toHaveCss(css): boolean;
-        toBeVisible(): boolean;
-        toBeHidden(): boolean;
-        toBeSelected(): boolean;
-        toBeChecked(): boolean;
-        toBeEmpty(): boolean;
-        toExist(): boolean;
-        toHaveLength(length: number): boolean;
-        toHaveAttr(attributeName: string, expectedAttributeValue): boolean;
-        toHaveProp(propertyName: string, expectedPropertyValue): boolean;
-        toHaveId(id: string): boolean;
-        toHaveHtml(html: string): boolean;
-        //toContainHtml(html: string): boolean;
-        toHaveText(text: string): boolean;
-        //toContainText(text: string): boolean;
-        toHaveValue(value): boolean;
-        toHaveData(key, expectedValue): boolean;
-        toBe(selector: JQuery): boolean;
-        toContain(selector: JQuery): boolean;
-        toBeMatchedBy(selector: string): boolean;
-        toBeDisabled(): boolean;
-        toBeFocused(): boolean;
-        toHandle(event): boolean;
-        toHandleWith(eventName: string, eventHandler): boolean;
-
-        toHaveBeenTriggered(): boolean;
-        toHaveBeenTriggeredOn(selector: string): boolean;
-        toHaveBeenTriggeredOnAndWith(selector: string, ...args: any[]): boolean;
-        toHaveBeenPrevented(): boolean;
-        toHaveBeenPreventedOn(selector: string): boolean;
-        toHaveBeenStopped(): boolean;
-        toHaveBeenStoppedOn(selector: string): boolean;
+        toHaveCss(css): boolean;
+        toBeVisible(): boolean;
+        toBeHidden(): boolean;
+        toBeSelected(): boolean;
+        toBeChecked(): boolean;
+        toBeEmpty(): boolean;
+        toExist(): boolean;
+        toHaveLength(length: number): boolean;
+        toHaveAttr(attributeName: string, expectedAttributeValue?): boolean;
+        toHaveProp(propertyName: string, expectedPropertyValue?): boolean;
+        toHaveId(id: string): boolean;
+        toHaveHtml(html: string): boolean;
+        //toContainHtml(html: string): boolean;
+        toHaveText(text: string): boolean;
+        //toContainText(text: string): boolean;
+        toHaveValue(value): boolean;
+        toHaveData(key, expectedValue): boolean;
+        toBe(selector: JQuery): boolean;
+        toContain(selector: JQuery): boolean;
+        toBeMatchedBy(selector: string): boolean;
+        toBeDisabled(): boolean;
+        toBeFocused(): boolean;
+        toHandle(event): boolean;
+        toHandleWith(eventName: string, eventHandler): boolean;
+
+        toHaveBeenTriggered(): boolean;
+        toHaveBeenTriggeredOn(selector: string): boolean;
+        toHaveBeenTriggeredOnAndWith(selector: string, ...args: any[]): boolean;
+        toHaveBeenPrevented(): boolean;
+        toHaveBeenPreventedOn(selector: string): boolean;
+        toHaveBeenStopped(): boolean;
+        toHaveBeenStoppedOn(selector: string): boolean;
     }
 
     interface JQueryEventSpy {
-        selector: string;
-        eventName: string;
-        handler(eventObject: JQueryEventObject): any;
+        selector: string;
+        eventName: string;
+        handler(eventObject: JQueryEventObject): any;
         reset(): any;
     }
 
     interface JasmineJQuery {
-        browserTagCaseIndependentHtml(html: string): string;
-        elementToString(element: JQuery): string;
-        matchersClass: any;
-        events: JasmineJQueryEvents;
-    }
-
-    interface JasmineJQueryEvents {
-        spyOn(selector: string, eventName: string): JQueryEventSpy;
-        args(selector: string, eventName: string): any;
-        wasTriggered(selector: string, eventName: string): boolean;
-        wasTriggeredWith(selector: string, eventName: string, expectedArgs: any, env: jasmine.Env): boolean;
-        wasPrevented(selector: string, eventName: string): boolean;
-        wasStopped(selector: string, eventName: string): boolean;
-        cleanUp();
-    }
+        browserTagCaseIndependentHtml(html: string): string;
+        elementToString(element: JQuery): string;
+        matchersClass: any;
+        events: JasmineJQueryEvents;
+    }
+
+    interface JasmineJQueryEvents {
+        spyOn(selector: string, eventName: string): JQueryEventSpy;
+        args(selector: string, eventName: string): any;
+        wasTriggered(selector: string, eventName: string): boolean;
+        wasTriggeredWith(selector: string, eventName: string, expectedArgs: any, env: jasmine.Env): boolean;
+        wasPrevented(selector: string, eventName: string): boolean;
+        wasStopped(selector: string, eventName: string): boolean;
+        cleanUp();
+    }
 
     var JQuery: JasmineJQuery;
 }

From e1295fdd8bf866c5b25c9c5f46b69fda24e38d4e Mon Sep 17 00:00:00 2001
From: John Kurlak <john@kurlak.com>
Date: Mon, 3 Mar 2014 10:26:52 -0800
Subject: [PATCH 022/309] Added verification that optional parameters work

Added verification that optional parameters work for toHaveAttr() and toHaveProp().
---
 jasmine-jquery/jasmine-jquery-tests.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/jasmine-jquery/jasmine-jquery-tests.ts b/jasmine-jquery/jasmine-jquery-tests.ts
index 15877ed60..ef6d8cc79 100644
--- a/jasmine-jquery/jasmine-jquery-tests.ts
+++ b/jasmine-jquery/jasmine-jquery-tests.ts
@@ -16,7 +16,9 @@ describe("Jasmine jQuery extension", () => {
         expect($('<span></span>').addClass('js-something')).toBeMatchedBy('.js-something');
         expect($('<span></span>')).toExist();
         expect($('<div id="some-id"></div>')).toHaveAttr('id', 'some-id');
+        expect($('<input type="checkbox" checked="checked"/>')).toHaveAttr('type');
         expect($('<div id="some-id"></div>')).toHaveProp('id', 'some-id');
+        expect($('<input type="checkbox" checked="checked"/>')).toHaveProp('checked');
         expect($('')).toHaveBeenTriggered();
         expect($('')).toHaveBeenTriggeredOn('#some-id');
         expect($('')).toHaveBeenTriggeredOnAndWith('#some-id', 'eventParam');
@@ -132,4 +134,4 @@ describe("Jasmine jQuery extension", () => {
             expect(spyEvent).toHaveBeenStopped();
         });
     });
-})
+});

From e2d790938b6423428f10e66d9bced06c3a1e944b Mon Sep 17 00:00:00 2001
From: Johan Nilsson <jonh04@gmail.com>
Date: Mon, 3 Mar 2014 18:48:04 -0400
Subject: [PATCH 023/309] added getPosition();

---
 googlemaps.infobubble/google.maps.infobubble-tests.ts | 3 +++
 googlemaps.infobubble/google.maps.infobubble.d.ts     | 5 +++++
 2 files changed, 8 insertions(+)

diff --git a/googlemaps.infobubble/google.maps.infobubble-tests.ts b/googlemaps.infobubble/google.maps.infobubble-tests.ts
index 61f6b7ac5..7dcfa739b 100644
--- a/googlemaps.infobubble/google.maps.infobubble-tests.ts
+++ b/googlemaps.infobubble/google.maps.infobubble-tests.ts
@@ -26,8 +26,11 @@ function test_bubble() {
     var map: google.maps.Map;
     var marker: google.maps.Marker;
     var bubble: google.maps.infobubble.InfoBubble;
+    var position: google.maps.LatLng;
 
     bubble.open(map, marker);
     var isOpen = bubble.isOpen();
     bubble.close();
+    
+    position = bubble.getPosition();
 }
\ No newline at end of file
diff --git a/googlemaps.infobubble/google.maps.infobubble.d.ts b/googlemaps.infobubble/google.maps.infobubble.d.ts
index f65dd1114..2d88d8645 100644
--- a/googlemaps.infobubble/google.maps.infobubble.d.ts
+++ b/googlemaps.infobubble/google.maps.infobubble.d.ts
@@ -57,6 +57,11 @@ declare module google.maps.infobubble {
           * @marker The marker used for anchoring the infobubble to
           */
         open(map: google.maps.Map, marker: google.maps.Marker) : void;
+		
+		/**
+          * Returns the position of the InfoBubble
+          */
+        getPosition(): google.maps.LatLng; 
     }
 
     export interface InfoBubbleOptions {

From b7fda303fb276e3a5c8cd4709651beedf5cd46ce Mon Sep 17 00:00:00 2001
From: "T. Michael Keesey" <keesey@gmail.com>
Date: Mon, 3 Mar 2014 23:55:10 -0800
Subject: [PATCH 024/309] PhantomJS: Made compliant with --noImplicitAny and
 added more details to many of the declarations.

---
 phantomjs/phantomjs.d.ts | 243 +++++++++++++++++++++++----------------
 1 file changed, 143 insertions(+), 100 deletions(-)

diff --git a/phantomjs/phantomjs.d.ts b/phantomjs/phantomjs.d.ts
index b85e356a9..21b3b0fe4 100644
--- a/phantomjs/phantomjs.d.ts
+++ b/phantomjs/phantomjs.d.ts
@@ -1,6 +1,6 @@
 // Type definitions for PlantomJS v1.8.0 API
 // Project: https://github.com/ariya/phantomjs/wiki/API-Reference
-// Definitions by: Jed Hunsaker <https://github.com/jedhunsaker>
+// Definitions by: Jed Hunsaker <https://github.com/jedhunsaker> and Mike Keesey <https://github.com/keesey>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 interface Phantom {
@@ -11,33 +11,35 @@ interface Phantom {
 	cookiesEnabled: boolean;
 	libraryPath: string;
 	scriptName: string;  // DEPRECATED
-	version: any;
+	version: {
+		major: number;
+		minor: number;
+		patch: number;
+	};
 
 	// Functions
 	addCookie(cookie: Cookie): boolean;
-	clearCookies();
+	clearCookies(): void;
 	deleteCookie(cookieName: string): boolean;
-	exit(returnValue: any): boolean;
+	exit(returnValue?: any): boolean;
 	injectJs(filename: string): boolean;
 
 	// Callbacks
-	onError: Function;
+	onError: (msg: string, trace: string[]) => any;
 }
 
 interface System {
 	pid: number;
 	platform: string;
-	os: OS;
-	env: any;
+	os: {
+		architecture: string;
+		name: string;
+		version: string;
+	};
+	env: { [name: string]: string; };
 	args: string[];
 }
 
-interface OS {
-	architecture: string;
-	name: string;
-	version: string;
-}
-
 interface WebPage {
 	
 	// Properties
@@ -46,8 +48,8 @@ interface WebPage {
 	clipRect: ClipRect;
 	content: string;
 	cookies: Cookie[];
-	customHeaders: any;
-	event;
+	customHeaders: { [name: string]: string; };
+	event: any; // :TODO: elaborate this when documentation improves
 	focusedFrameName: string;
 	frameContent: string;
 	frameName: string;
@@ -55,13 +57,13 @@ interface WebPage {
 	frameTitle: string;
 	frameUrl: string;
 	framesCount: number;
-	framesName;
+	framesName: any; // :TODO: elaborate this when documentation improves
 	libraryPath: string;
 	navigationLocked: boolean;
 	offlineStoragePath: string;
 	offlineStorageQuota: number;
 	ownsPages: boolean;
-	pages;
+	pages: WebPage[];
 	pagesWindowName: string;
 	paperSize: PaperSize;
 	plainText: string;
@@ -77,76 +79,113 @@ interface WebPage {
 	addCookie(cookie: Cookie): boolean;
 	childFramesCount(): number;  // DEPRECATED
 	childFramesName(): string;  // DEPRECATED
-	clearCookies();
-	close();
+	clearCookies(): void;
+	close(): void;
 	currentFrameName(): string;  // DEPRECATED
 	deleteCookie(cookieName: string): boolean;
 	evaluate(fn: Function, ...args: any[]): any;
-	evaluateAsync(fn: Function);
-	evaluateJavascript(str: string);
-	getPage(windowName: string);
-	go(index: number);
-	goBack();
-	goForward();
-	includeJs(url: string, callback: Function);
+	evaluateAsync(fn: Function): void;
+	evaluateJavascript(str: string): any; // :TODO: elaborate this when documentation improves
+	getPage(windowName: string): WebPage;
+	go(index: number): void;
+	goBack(): void;
+	goForward(): void;
+	includeJs(url: string, callback: Function): void;
 	injectJs(filename: string): boolean;
-	open(url: string, callback: (status: string) => void);
-	openUrl(url: string, httpConf: any, settings: any);
-	release();  // DEPRECATED
-	reload();
-	render(filename: string);
-	renderBase64(format: any): string;
+	open(url: string, callback: (status: string) => any): void;
+	open(url: string, method: string, callback: (status: string) => any): void;
+	open(url: string, method: string, data: any, callback: (status: string) => any): void;
+	openUrl(url: string, httpConf: any, settings: any): void; // :TODO: elaborate this when documentation improves
+	release(): void;  // DEPRECATED
+	reload(): void;
+	render(filename: string): void;
+	renderBase64(format: string): string;
 	sendEvent(mouseEventType: string, mouseX?: number, mouseY?: number, button?: string);
-	sendEvent(keyboardEventType: string, keyOrKeys, aNull?, bNull?, modifier?);
-	setContent(content: string, url: string);
-	stop();
-	switchToFocusedFrame();
-	switchToFrame(frameName: string);
-	switchToFrame(framePosition);
-	switchToChildFrame(frameName: string);
-	switchToChildFrame(framePosition);
-	switchToMainFrame();  // DEPRECATED
-	switchToParentFrame();  // DEPRECATED
-	uploadFile(selector: string, filename: string);
+	sendEvent(keyboardEventType: string, keyOrKeys: any, aNull?: any, bNull?: any, modifier?: number);
+	setContent(content: string, url: string): void;
+	stop(): void;
+	switchToFocusedFrame(): void;
+	switchToFrame(frameName: string): void;
+	switchToFrame(framePosition: number): void;
+	switchToChildFrame(frameName: string): void;
+	switchToChildFrame(framePosition: number): void;
+	switchToMainFrame(): void;  // DEPRECATED
+	switchToParentFrame(): void;  // DEPRECATED
+	uploadFile(selector: string, filename: string): void;
 
 	// Callbacks
-	onAlert: Function;
+	onAlert: (msg: string) => any;
 	onCallback: Function;  // EXPERIMENTAL
-	onClosing: Function;
-	onConfirm: Function;
-	onConsoleMessage: Function;
-	onError: Function;
-	onFilePicker: Function;
-	onInitialized: Function;
-	onLoadFinished: Function;
-	onLoadStarted: Function;
-	onNavigationRequested: Function;
-	onPageCreated: Function;
-	onPrompt: Function;
-	onResourceRequested: Function;
-	onResourceReceived: Function;
-	onUrlChanged: Function;
+	onClosing: (closingPage: WebPage) => any;
+	onConfirm: (msg: string) => boolean;
+	onConsoleMessage: (msg: string, lineNum?: number, sourceId?: string) => any;
+	onError: (msg: string, trace: string[]) => any;
+	onFilePicker: (oldFile: string) => string;
+	onInitialized: () => any;
+	onLoadFinished: (status: string) => any;
+	onLoadStarted: () => any;
+	onNavigationRequested: (url: string, type: string, willNavigate: boolean, main: boolean) => any;
+	onPageCreated: (newPage: WebPage) => any;
+	onPrompt: (msg: string, defaultVal: string) => string;
+	onResourceError: (resourceError: ResourceError) => any;
+	onResourceReceived: (response: ResourceResponse) => any;
+	onResourceRequested: (requestData: ResourceRequest, networkRequest: NetworkRequest) => any;
+	onUrlChanged: (targetUrl: string) => any;
 
 	// Callback triggers
-	closing(page);
-	initialized();
-	javaScriptAlertSent(message: string);
-	javaScriptConsoleMessageSent(message: string);
-	loadFinished(status);
-	loadStarted();
-	navigationRequested(url: string, navigationType, navigationLocked, isMainFrame: boolean);
-	rawPageCreated(page);
-	resourceReceived(request);
-	resourceRequested(resource);
-	urlChanged(url: string);
+	closing(closingPage: WebPage): void;
+	initialized(): void;
+	javaScriptAlertSent(msg: string): void;
+	javaScriptConsoleMessageSent(msg: string, lineNum?: number, sourceId?: string): void;
+	loadFinished(status: string): void;
+	loadStarted(): void;
+	navigationRequested(url: string, type: string, willNavigate: boolean, main: boolean): void;
+	rawPageCreated(newPage: WebPage): void;
+	resourceReceived(response: ResourceResponse): void;
+	resourceRequested(requestData: ResourceRequest, networkRequest: NetworkRequest): void;
+	urlChanged(targetUrl: string);
+}
+
+interface ResourceError {
+	id: number;
+	url: string;
+	errorCode: string;
+	errorString: string;
+}
+
+interface ResourceResponse {
+	id: number;
+	url: string;
+	time: Date;
+	headers: { [name: string]: string; };
+	bodySize: number;
+	contentType?: string;
+	redirectURL?: string;
+	stage: string;
+	status: number;
+	statusText: string;
+}
+
+interface ResourceRequest {
+	id: number;
+	method: string;
+	ur: string;
+	time: Date;
+	headers: { [name: string]: string; };
+}
+
+interface NetworkRequest {
+	abort(): void;
+	changeUrl(url: string): void;
+	setHeader(name: string, value: string);
 }
 
 interface PaperSize {
-	width: string;
-	height: string;
+	width?: string;
+	height?: string;
 	border: string;
-	format: string;
-	orientation: string;
+	format?: string;
+	orientation?: string;
 }
 
 interface WebPageSettings {
@@ -154,9 +193,11 @@ interface WebPageSettings {
 	loadImages: boolean;
 	localToRemoteUrlAccessEnabled: boolean;
 	userAgent: string;
+	userName: string;
 	password: string;
 	XSSAuditingEnabled: boolean;
 	webSecurityEnabled: boolean;
+	resourceTimeout: number;
 }
 
 interface FileSystem {
@@ -181,59 +222,62 @@ interface FileSystem {
 	readLink(path: string): string;
 
 	// Directory Functions
-	changeWorkingDirectory(path: string);
-	makeDirectory(path: string);
-	makeTree(path: string);
-	removeDirectory(path: string);
-	removeTree(path: string);
-	copyTree(source: string, destination: string);
+	changeWorkingDirectory(path: string): void;
+	makeDirectory(path: string): void;
+	makeTree(path: string): void;
+	removeDirectory(path: string): void;
+	removeTree(path: string): void;
+	copyTree(source: string, destination: string): void;
 
 	// File Functions
 	open(path: string, mode: string): Stream;
+	open(path: string, options: { mode: string; charset?: string; }): Stream;
 	read(path: string): string;
-	write(path: string, content: string, mode: string);
+	write(path: string, content: string, mode: string): void;
 	size(path: string): number;
-	remove(path: string);
-	copy(source: string, destination: string);
-	move(source: string, destination: string);
-	touch(path: string);
+	remove(path: string): void;
+	copy(source: string, destination: string): void;
+	move(source: string, destination: string): void;
+	touch(path: string): void;
 }
 
 interface Stream {
+	atEnd(): boolean;
+	close(): void;
+	flush(): void;
 	read(): string;
 	readLine(): string;
-	write(data: string);
-	writeLine(data: string);
-	flush();
-	close();
+	seek(position: number): void;
+	write(data: string): void;
+	writeLine(data: string): void;
 }
 
 interface WebServer {
 	port: number;
-	listen(port: number, cb?:(request, response) => void): boolean;
-	listen(ipAddressPort: string, cb?:(request, response) => void): boolean;
-	close();
+	listen(port: number, cb?: (request: WebServerRequest, response: WebServerResponse) => void): boolean;
+	listen(ipAddressPort: string, cb?: (request: WebServerRequest, response: WebServerResponse) => void): boolean;
+	close(): void;
 }
 
-interface Request {
+interface WebServerRequest {
 	method: string;
 	url: string;
 	httpVersion: number;
-	headers: any;
+	headers: { [name: string]: string; };
 	post: string;
 	postRaw: string;
 }
 
-interface Response {
-	headers: any;
+interface WebServerResponse {
+	headers: { [name: string]: string; };
 	setHeader(name: string, value: string);
 	header(name: string): string;
 	statusCode: number;
 	setEncoding(encoding: string);
 	write(data: string);
-	writeHead(statusCode: number, headers?: any);
-	close();
-	closeGracefully();
+	writeHead(statusCode: number, headers?: { [name: string]: string; });
+	close(): void;
+	closeGracefully(): void;
 }
 
 interface TopLeft {
@@ -247,11 +291,10 @@ interface Size {
 }
 
 interface ClipRect extends TopLeft, Size {
-	width: number;
-	height: number;
 }
 
 interface Cookie {
 	name: string;
 	value: string;
+	domain?: string;
 }

From e2485aeffb26f3319de5901f2dca3710f08f1dc4 Mon Sep 17 00:00:00 2001
From: "T. Michael Keesey" <keesey@gmail.com>
Date: Tue, 4 Mar 2014 00:01:21 -0800
Subject: [PATCH 025/309] PhantomJS: Finished making compliant with
 --noImplicityAny. Added top-level declarations. Removed Phantom type in favor
 of an inline type.

---
 phantomjs/phantomjs.d.ts | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/phantomjs/phantomjs.d.ts b/phantomjs/phantomjs.d.ts
index 21b3b0fe4..bfea308d6 100644
--- a/phantomjs/phantomjs.d.ts
+++ b/phantomjs/phantomjs.d.ts
@@ -3,7 +3,9 @@
 // Definitions by: Jed Hunsaker <https://github.com/jedhunsaker> and Mike Keesey <https://github.com/keesey>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-interface Phantom {
+declare function require(module: string): any;
+
+declare var phantom: {
 
 	// Properties
 	args: string[];  // DEPRECATED
@@ -26,7 +28,7 @@ interface Phantom {
 
 	// Callbacks
 	onError: (msg: string, trace: string[]) => any;
-}
+};
 
 interface System {
 	pid: number;
@@ -100,8 +102,8 @@ interface WebPage {
 	reload(): void;
 	render(filename: string): void;
 	renderBase64(format: string): string;
-	sendEvent(mouseEventType: string, mouseX?: number, mouseY?: number, button?: string);
-	sendEvent(keyboardEventType: string, keyOrKeys: any, aNull?: any, bNull?: any, modifier?: number);
+	sendEvent(mouseEventType: string, mouseX?: number, mouseY?: number, button?: string): void;
+	sendEvent(keyboardEventType: string, keyOrKeys: any, aNull?: any, bNull?: any, modifier?: number): void;
 	setContent(content: string, url: string): void;
 	stop(): void;
 	switchToFocusedFrame(): void;
@@ -143,7 +145,7 @@ interface WebPage {
 	rawPageCreated(newPage: WebPage): void;
 	resourceReceived(response: ResourceResponse): void;
 	resourceRequested(requestData: ResourceRequest, networkRequest: NetworkRequest): void;
-	urlChanged(targetUrl: string);
+	urlChanged(targetUrl: string): void;
 }
 
 interface ResourceError {
@@ -177,7 +179,7 @@ interface ResourceRequest {
 interface NetworkRequest {
 	abort(): void;
 	changeUrl(url: string): void;
-	setHeader(name: string, value: string);
+	setHeader(name: string, value: string): void;
 }
 
 interface PaperSize {
@@ -270,12 +272,12 @@ interface WebServerRequest {
 
 interface WebServerResponse {
 	headers: { [name: string]: string; };
-	setHeader(name: string, value: string);
+	setHeader(name: string, value: string): void;
 	header(name: string): string;
 	statusCode: number;
-	setEncoding(encoding: string);
-	write(data: string);
-	writeHead(statusCode: number, headers?: { [name: string]: string; });
+	setEncoding(encoding: string): void;
+	write(data: string): void;
+	writeHead(statusCode: number, headers?: { [name: string]: string; }): void;
 	close(): void;
 	closeGracefully(): void;
 }

From c6b378704a61d07fa167db7d6419c4298412f934 Mon Sep 17 00:00:00 2001
From: "T. Michael Keesey" <keesey@gmail.com>
Date: Tue, 4 Mar 2014 19:22:07 -0800
Subject: [PATCH 026/309] Fixed typo and updated PhantomJS version.

---
 phantomjs/phantomjs.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/phantomjs/phantomjs.d.ts b/phantomjs/phantomjs.d.ts
index bfea308d6..0110cac17 100644
--- a/phantomjs/phantomjs.d.ts
+++ b/phantomjs/phantomjs.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for PlantomJS v1.8.0 API
+// Type definitions for PhantomJS v1.9.0 API
 // Project: https://github.com/ariya/phantomjs/wiki/API-Reference
 // Definitions by: Jed Hunsaker <https://github.com/jedhunsaker> and Mike Keesey <https://github.com/keesey>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

From db9c476fa5da19022e0d21e4d438a3dcdb62b568 Mon Sep 17 00:00:00 2001
From: "T. Michael Keesey" <keesey@gmail.com>
Date: Tue, 4 Mar 2014 19:25:40 -0800
Subject: [PATCH 027/309] Reinstated Phantom interface.

---
 phantomjs/phantomjs.d.ts | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/phantomjs/phantomjs.d.ts b/phantomjs/phantomjs.d.ts
index 0110cac17..58e202ac8 100644
--- a/phantomjs/phantomjs.d.ts
+++ b/phantomjs/phantomjs.d.ts
@@ -5,7 +5,9 @@
 
 declare function require(module: string): any;
 
-declare var phantom: {
+declare var phantom: Phantom;
+
+interface Phantom {
 
 	// Properties
 	args: string[];  // DEPRECATED
@@ -28,7 +30,7 @@ declare var phantom: {
 
 	// Callbacks
 	onError: (msg: string, trace: string[]) => any;
-};
+}
 
 interface System {
 	pid: number;

From 53f1a276d4ec8f2c0bda808eb2043bdf4ffa2b92 Mon Sep 17 00:00:00 2001
From: colindembovsky <colindembovsky@gmail.com>
Date: Wed, 5 Mar 2014 11:51:01 +0200
Subject: [PATCH 028/309] Update AmCharts.d.ts

Added constructor to AmCharts (for when you construct a chart with a theme)
Added ? to AddLegend optional divElement argument
---
 amcharts/AmCharts.d.ts | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/amcharts/AmCharts.d.ts b/amcharts/AmCharts.d.ts
index 9b29ef98f..97dd3a3ff 100644
--- a/amcharts/AmCharts.d.ts
+++ b/amcharts/AmCharts.d.ts
@@ -885,7 +885,9 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
 
     /** AmChart is a base class of all charts. It can not be instantiated explicitly. AmCoordinateChart, AmPieChart and AmMap extend AmChart class. */
     class AmChart {
-        /** Background color. You should set backgroundAlpha to >0 value in order background to be visible. We recommend setting background color directly on a chart's DIV instead of using this property. #FFFFFF */
+    	/** used when constructing a chart with a theme */
+    	constructor(theme: any);
+    	/** Background color. You should set backgroundAlpha to >0 value in order background to be visible. We recommend setting background color directly on a chart's DIV instead of using this property. #FFFFFF */
         backgroundColor: string;
         /** The chart creates AmBalloon class itself. If you want to customize balloon, get balloon instance using this property, and then change balloon's properties.  AmBalloon */
         balloon: AmBalloon;
@@ -943,7 +945,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
             @param legend
             @param legendDivId - Id of the legend div (optional).
         */
-        addLegend(legend: AmLegend, legendDivId: string);
+        addLegend(legend: AmLegend, legendDivId?: string);
         /** Adds a legend to the chart.
             By default, you don't need to create div for your legend, however if you want it to be positioned in some different way, you can create div anywhere you want and pass id or reference to your div as a second parameter.
             (NOTE: This method will not work on StockPanel.)
@@ -1437,7 +1439,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
             chart.write("chartdiv");
     */
     class AmSerialChart extends AmRectangularChart {
-        /** Read-only. Chart creates category axis itself. If you want to change some properties, you should get this axis from the chart and set properties to this object. */
+    	/** Read-only. Chart creates category axis itself. If you want to change some properties, you should get this axis from the chart and set properties to this object. */
         categoryAxis: CategoryAxis;
         /** Category field name tells the chart the name of the field in your dataProvider object which will be used for category axis values. */
         categoryField: string;

From 9f2f82ff5b381d523e46842b0761e250a1ddd01b Mon Sep 17 00:00:00 2001
From: Drew Noakes <git@drewnoakes.com>
Date: Wed, 5 Mar 2014 10:47:45 +0000
Subject: [PATCH 029/309] Add declarations for "Dock Spawn" library.

The library offers a Visual Studio-like drag/drop dock manager for
JavaScript.

http://dockspawn.com
https://github.com/coderespawn/dock-spawn

These declarations do not include some seemingly-private/internal
functions.

Authored by Drew Noakes <https://drewnoakes.com>
---
 dock-spawn/dock-spawn.d.ts | 180 +++++++++++++++++++++++++++++++++++++
 1 file changed, 180 insertions(+)
 create mode 100644 dock-spawn/dock-spawn.d.ts

diff --git a/dock-spawn/dock-spawn.d.ts b/dock-spawn/dock-spawn.d.ts
new file mode 100644
index 000000000..0c9d8fb4d
--- /dev/null
+++ b/dock-spawn/dock-spawn.d.ts
@@ -0,0 +1,180 @@
+// Type definitions for Dock Spawn
+// Project: http://dockspawn.com
+//          https://github.com/coderespawn/dock-spawn
+// Definitions by: Drew Noakes <https://drewnoakes.com>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped/dock-spawn
+
+declare module dockspawn
+{
+    /**
+     * Dock manager manages all the dock panels in a hierarchy, similar to Visual Studio.
+     * It owns an HTMLDivElement inside which all panels are docked.
+     * Initially the document manager takes up the central space and acts as the root node.
+     */
+    class DockManager
+    {
+        context: DockManagerContext;
+
+        constructor(element: HTMLDivElement);
+
+        initialize(): void;
+
+        rebuildLayout(node: DockNode): void;
+
+        invalidate(): void;
+
+        resize(width: number, height: number): void;
+
+        /**
+         * Reset the dock model. This happens when state is loaded from JSON.
+         */
+        setModel(model: DockModel): void;
+
+        setRootNode(node: DockNode): void;
+
+
+        /** Dock the [dialog] to the left of the [referenceNode] node */
+
+        dockDialogLeft(referenceNode: DockNode, dialog: Dialog): DockNode;
+        /** Dock the [dialog] to the right of the [referenceNode] node */
+        dockDialogRight(referenceNode: DockNode, dialog: Dialog): DockNode;
+        /** Dock the [dialog] above the [referenceNode] node */
+        dockDialogUp(referenceNode: DockNode, dialog: Dialog): DockNode;
+        /** Dock the [dialog] below the [referenceNode] node */
+        dockDialogDown(referenceNode: DockNode, dialog: Dialog): DockNode;
+        /** Dock the [dialog] as a tab inside the [referenceNode] node */
+        dockDialogFill(referenceNode: DockNode, container: PanelContainer): DockNode;
+
+        /** Dock the [container] to the left of the [referenceNode] node */
+        dockLeft(referenceNode: DockNode, container: PanelContainer, ratio: number): DockNode;
+        /** Dock the [container] to the right of the [referenceNode] node */
+        dockRight(referenceNode: DockNode, container: PanelContainer, ratio: number): DockNode;
+        /** Dock the [container] above the [referenceNode] node */
+        dockUp(referenceNode: DockNode, container: PanelContainer, ratio: number): DockNode;
+        /** Dock the [container] below the [referenceNode] node */
+        dockDown(referenceNode: DockNode, container: PanelContainer, ratio: number): DockNode;
+        /** Dock the [container] as a tab inside the [referenceNode] node */
+        dockFill(referenceNode: DockNode, container: PanelContainer): DockNode;
+
+        suspendLayout(): void;
+
+        resumeLayout(): void;
+
+        saveState(): string;
+        loadState(state: string): void;
+    }
+
+    class DockManagerContext
+    {
+        dockManager: DockManager;
+        model: DockModel;
+        documentManagerView: DocumentManagerContainer;
+
+        constructor(dockManager: DockManager);
+    }
+
+    class DockModel
+    {
+        rootNode: DockNode;
+        documentManagerNode: DockNode;
+    }
+
+    class DockNode
+    {
+        constructor(container: PanelContainer);
+
+        detachFromParent(): void;
+    }
+
+    /**
+     * Tab Host control contains tabs known as TabPages.
+     * The tab strip can be aligned in different orientations
+     */
+    class TabHost
+    {
+        tabStripDirection: TabStripDirection;
+        displayCloseButton: boolean;
+        pages: TabPage[];
+        hostElement: HTMLDivElement;
+        tabListElement: HTMLDivElement;
+        separatorElement: HTMLDivElement;
+        contentElement: HTMLDivElement;
+
+        constructor(tabStripDirection?: TabStripDirection, displayCloseButton?: boolean)
+
+        setActiveTab(container: PanelContainer): void;
+
+        /** Set the selected TabPage. */
+        onTabPageSelected(page: TabPage): void;
+
+        resize(width: number, height: number): void;
+    }
+
+    class TabPage
+    {
+        constructor(host: TabHost, container: PanelContainer);
+    }
+
+    enum TabStripDirection
+    {
+        DIRECTION_TOP = 0,
+        DIRECTION_BOTTOM = 1,
+        DIRECTION_LEFT = 2,
+        DIRECTION_RIGHT = 3
+    }
+
+    class FillDockContainer
+    {
+        tabOrientation: TabStripDirection;
+        element: HTMLDivElement;
+        tabHost: TabHost;
+        dockManager: DockManager;
+        name: string;
+        containerType: string;
+        minimumAllowedChildNodes: number;
+
+        constructor(dockManager: DockManager, tabStripDirection?: TabStripDirection)
+    }
+
+    /**
+     * The document manager is then central area of the dock layout hierarchy.
+     * This is where more important panels are placed (e.g. the text editor in an IDE,
+     * 3D view in a modelling package etc
+     */
+    class DocumentManagerContainer extends FillDockContainer
+    {
+        selectedTab: TabPage;
+
+        constructor(dockManager: DockManager);
+
+        saveState(state: string): void;
+    }
+
+    class PanelContainer
+    {
+        width: number;
+        height: number;
+
+        constructor(element: HTMLElement, dockManager: DockManager, title?: string);
+
+        setTitle(title: string): void;
+        setTitleIcon(iconName: string): void;
+    }
+
+    class Dialog
+    {
+        static fromElement(id: string, dockManager: DockManager): Dialog;
+
+        constructor(panel: PanelContainer, dockManager: DockManager);
+
+        setPosition(x: number, y: number): void;
+
+        resize(width: number, height: number): void;
+
+        setTitle(title: string): void;
+
+        setTitleIcon(iconName: string): void;
+
+        bringToFront(): void;
+    }
+}

From 4b572e1b66ef7aed1a52f2b8f29eb2c5bbfff592 Mon Sep 17 00:00:00 2001
From: Drew Noakes <git@drewnoakes.com>
Date: Wed, 5 Mar 2014 10:48:14 +0000
Subject: [PATCH 030/309] Add tests for "dock-spawn" library.

---
 dock-spawn/dock-spawn-tests.ts | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 dock-spawn/dock-spawn-tests.ts

diff --git a/dock-spawn/dock-spawn-tests.ts b/dock-spawn/dock-spawn-tests.ts
new file mode 100644
index 000000000..7bda821de
--- /dev/null
+++ b/dock-spawn/dock-spawn-tests.ts
@@ -0,0 +1,22 @@
+/// <reference path="dock-spawn.d.ts" />
+
+var dockManagerDiv = document.createElement('div'),
+    panelDiv1 = document.createElement('div'),
+    panelDiv2 = document.createElement('div'),
+    panelDiv3 = document.createElement('div');
+
+document.body.appendChild(dockManagerDiv);
+
+var dockManager = new dockspawn.DockManager(dockManagerDiv);
+dockManager.initialize();
+
+var panelContainer1 = new dockspawn.PanelContainer(panelDiv1, dockManager),
+    panelContainer2 = new dockspawn.PanelContainer(panelDiv2, dockManager),
+    panelContainer3 = new dockspawn.PanelContainer(panelDiv3, dockManager);
+
+var documentNode = dockManager.context.model.documentManagerNode;
+
+var panelNode1 = dockManager.dockLeft(documentNode, panelContainer1, 0.33),
+    panelNode2 = dockManager.dockRight(documentNode, panelContainer2, 0.33),
+    panelNode3 = dockManager.dockFill(documentNode, panelContainer3);
+

From a87bf2bc3f88492e6238446069f6166074f048ef Mon Sep 17 00:00:00 2001
From: Drew Noakes <git@drewnoakes.com>
Date: Wed, 5 Mar 2014 11:17:54 +0000
Subject: [PATCH 031/309] Updated README with new library.

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 29c94b804..e4051138c 100755
--- a/README.md
+++ b/README.md
@@ -62,6 +62,7 @@ List of Definitions
 * [d3.js](http://d3js.org/) (from TypeScript samples)
 * [dhtmlxGantt](http://dhtmlx.com/docs/products/dhtmlxGantt) (by [Maksim Kozhukh](http://github.com/mkozhukh))
 * [dhtmlxScheduler](http://dhtmlx.com/docs/products/dhtmlxScheduler) (by [Maksim Kozhukh](http://github.com/mkozhukh))
+* [Dock Spawn](http://dockspawn.com) (by [Drew Noakes](https://drewnoakes.com))
 * [docCookies](https://developer.mozilla.org/en-US/docs/Web/API/document.cookie) (by [Jon Egerton](https://github.com/jonegerton))
 * [domo](http://domo-js.com/) (by [Steve Fenton](https://github.com/Steve-Fenton))
 * [doT](https://github.com/olado/doT) (by [ZombieHunter](https://github.com/ZombieHunter))

From e0dd3ed06d5be5972a3d80c8a61ab1421f5a2e08 Mon Sep 17 00:00:00 2001
From: slozier <stephane.lozier@gmail.com>
Date: Wed, 5 Mar 2014 19:26:32 -0500
Subject: [PATCH 032/309] Update jqueryui.d.ts

---
 jqueryui/jqueryui.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/jqueryui/jqueryui.d.ts b/jqueryui/jqueryui.d.ts
index 41cc3214d..52d7d6d6a 100644
--- a/jqueryui/jqueryui.d.ts
+++ b/jqueryui/jqueryui.d.ts
@@ -976,6 +976,7 @@ interface JQuery {
     sortable(methodName: 'disable'): void;
     sortable(methodName: 'enable'): void;
     sortable(methodName: 'widget'): JQuery;
+    sortable(methodName: 'toArray'): string[];
     sortable(methodName: string): JQuery;
     sortable(options: JQueryUI.SortableOptions): JQuery;
     sortable(optionLiteral: string, optionName: string): any;

From 2b8902f4d50fba5c08a20e528da79ce2c74c4af8 Mon Sep 17 00:00:00 2001
From: Pascale Audet <audetpascale@gmail.com>
Date: Wed, 5 Mar 2014 21:17:38 -0500
Subject: [PATCH 033/309] Add registerPlugin function.

More details: http://developer.longtailvideo.com/trac/browser/sdks/jw6-plugin-sdk/docs/plugins-js.html
---
 jwplayer/jwplayer.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/jwplayer/jwplayer.d.ts b/jwplayer/jwplayer.d.ts
index be4ab4fd3..05e76051b 100644
--- a/jwplayer/jwplayer.d.ts
+++ b/jwplayer/jwplayer.d.ts
@@ -54,6 +54,7 @@ interface JWPlayer {
 	pause(): void;
 	play(): void;
 	playlistItem(index: number): void;
+	registerPlugin(id: string, target: string, jsPlugin: () => void, swfURL: string): void;
 	remove(): void;
 	removeButton(id: string): void;
 	resize(width: number, height: number): void;

From 0539b49abb1007016219572a569fb593a9ff17f8 Mon Sep 17 00:00:00 2001
From: memetolsen <memetolsen@gmail.com>
Date: Thu, 6 Mar 2014 09:39:14 +0100
Subject: [PATCH 034/309] Added x and y getters on Element.

---
 svgjs/svgjs.d.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/svgjs/svgjs.d.ts b/svgjs/svgjs.d.ts
index 5ff8303ff..44f32d9b1 100644
--- a/svgjs/svgjs.d.ts
+++ b/svgjs/svgjs.d.ts
@@ -88,6 +88,8 @@ declare module svgjs {
         move(x:number, y:number, anchor?:boolean):Element;
         x(x:number, anchor?:boolean):Element;
         y(y:number, anchor?:boolean):Element;
+        x(): number;
+        y(): number;
         
         center(x:number, y:number, anchor?:boolean):Element;
         cx(x:number, anchor?:boolean):Element;
@@ -267,4 +269,4 @@ declare module svgjs {
         e?: number;
         f?: number;
     }
-}
\ No newline at end of file
+}

From ddd35edea87cf21b28647ca3bb015c0af8a9898b Mon Sep 17 00:00:00 2001
From: Blake Niemyjski <bniemyjski@gmail.com>
Date: Thu, 6 Mar 2014 09:21:20 -0700
Subject: [PATCH 035/309] Changed SetDefaults to config.

https://github.com/zeroclipboard/zeroclipboard/blob/master/docs/instructions.md#deprecations
---
 zeroclipboard/zeroclipboard.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/zeroclipboard/zeroclipboard.d.ts b/zeroclipboard/zeroclipboard.d.ts
index 847593df8..f4799fc92 100644
--- a/zeroclipboard/zeroclipboard.d.ts
+++ b/zeroclipboard/zeroclipboard.d.ts
@@ -27,7 +27,7 @@ declare class ZeroClipboard {
     receiveEvent(eventName: string, args: any): void;
     glue(elements: any): void;
     unglue(elements: any): void;
-    static setDefaults(options: ZeroClipboardOptions): void;
+    static config(options: ZeroClipboardOptions): void;
     static destroy(): void;
     static detectFlashSupport(): boolean;
     static dispatch(eventName: string, args: any): void;

From 53d4658638e60a9275382acc939728a338b4dd7f Mon Sep 17 00:00:00 2001
From: Pascale Audet <audetpascale@gmail.com>
Date: Thu, 6 Mar 2014 13:59:32 -0500
Subject: [PATCH 036/309] Add getPlaylistIndex()

More details: http://www.longtailvideo.com/support/jw-player/28851/javascript-api-reference/
---
 jwplayer/jwplayer.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/jwplayer/jwplayer.d.ts b/jwplayer/jwplayer.d.ts
index be4ab4fd3..92377b309 100644
--- a/jwplayer/jwplayer.d.ts
+++ b/jwplayer/jwplayer.d.ts
@@ -17,6 +17,7 @@ interface JWPlayer {
 	getFullscreen(): boolean;
 	getMute(): boolean;
 	getPlaylist(): any[];
+	getPlaylistIndex(): number;
 	getPlaylistItem(index: number): any;
 	getPosition(): number;
 	getQualityLevels(): any[];

From 9ae21ba16ffcd55efc45d3c7db6b98d41b491645 Mon Sep 17 00:00:00 2001
From: MissFishie <MissFishie@users.noreply.github.com>
Date: Thu, 6 Mar 2014 17:17:03 -0800
Subject: [PATCH 037/309] Fix incorrect return type for PieLayout methods

PieLayout methods should return type PieLayout so that chaining is possible after one of these methods are called.  This is consistent with all other types defined in this file.
---
 d3/d3.d.ts | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/d3/d3.d.ts b/d3/d3.d.ts
index 4bce47e2b..8435e9fe4 100644
--- a/d3/d3.d.ts
+++ b/d3/d3.d.ts
@@ -1148,17 +1148,17 @@ declare module D3 {
             };
             startAngle: {
                 (): number;
-                (angle: number): D3.Svg.Arc;
-                (angle: () => number): D3.Svg.Arc;
-                (angle: (d : any) => number): D3.Svg.Arc;
-                (angle: (d : any, i: number) => number): D3.Svg.Arc;
+                (angle: number): PieLayout;
+                (angle: () => number): PieLayout;
+                (angle: (d : any) => number): PieLayout;
+                (angle: (d : any, i: number) => number): PieLayout;
             };
             endAngle: {
                 (): number;
-                (angle: number): D3.Svg.Arc;
-                (angle: () => number): D3.Svg.Arc;
-                (angle: (d : any) => number): D3.Svg.Arc;
-                (angle: (d : any, i: number) => number): D3.Svg.Arc;
+                (angle: number): PieLayout;
+                (angle: () => number): PieLayout;
+                (angle: (d : any) => number): PieLayout
+                (angle: (d : any, i: number) => number): PieLayout;
             };
         }
 

From 87cd95fd92bf2adb426271938ede6fe42b8df4f4 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Fri, 7 Mar 2014 14:07:28 +0400
Subject: [PATCH 038/309] promises-a-plus: added initial defintions rx.js:
 modified IPromise in Async module to match Promises/A+

---
 promises-a-plus/promises-a-plus-tests.ts | 41 ++++++++++++++++++++++++
 promises-a-plus/promises-a-plus.d.ts     | 16 +++++++++
 rx.js/rx.async.d.ts                      |  6 ++--
 3 files changed, 60 insertions(+), 3 deletions(-)
 create mode 100644 promises-a-plus/promises-a-plus-tests.ts
 create mode 100644 promises-a-plus/promises-a-plus.d.ts

diff --git a/promises-a-plus/promises-a-plus-tests.ts b/promises-a-plus/promises-a-plus-tests.ts
new file mode 100644
index 000000000..5b10b1b6e
--- /dev/null
+++ b/promises-a-plus/promises-a-plus-tests.ts
@@ -0,0 +1,41 @@
+/// <reference path="promises-a-plus.d.ts"/>
+/// <reference path="../rx.js/rx.async.d.ts"/>
+
+var thenNum: PromisesAPlus.Thenable<number>; 
+var thenStr: PromisesAPlus.Thenable<string>; 
+var thenBool: PromisesAPlus.Thenable<boolean>; 
+
+var impl: PromisesAPlus.PromiseImpl;
+
+declare class PromiseImpl<R> {
+	constructor(resolver: (resolvePromise: (value: R) => void, rejectPromise: (reason: any) => void) => void);
+
+	then<U>(onFulfill: (value: R) => PromiseImpl<U>, onReject: (error: any) => PromiseImpl<U>): PromiseImpl<U>;
+	then<U>(onFulfill: (value: R) => PromiseImpl<U>, onReject?: (error: any) => U): PromiseImpl<U>;
+	then<U>(onFulfill: (value: R) => U, onReject: (error: any) => PromiseImpl<U>): PromiseImpl<U>;
+	then<U>(onFulfill?: (value: R) => U, onReject?: (error: any) => U): PromiseImpl<U>;
+}
+
+function testCompatibleWithPromiseImpl() {
+	var pNum: PromiseImpl<number> = thenNum;
+
+	thenNum = pNum;
+
+	impl = PromiseImpl;
+}
+
+function testCompatibleWithRxJS() {
+	// from spec to Rx
+	var rxThenNum: Rx.IPromise<number> = thenNum;
+	var rxThenStr: Rx.IPromise<string> = thenStr;
+
+	// from Rx to spec
+	thenNum = rxThenNum;
+	thenStr = rxThenStr;
+
+	var obsNum: Rx.Observable<number>;
+
+	thenNum = obsNum.toPromise<PromisesAPlus.Thenable<number>>(impl);
+	thenNum = obsNum.toPromise(impl);
+	obsNum.toPromise(PromiseImpl);
+}
diff --git a/promises-a-plus/promises-a-plus.d.ts b/promises-a-plus/promises-a-plus.d.ts
new file mode 100644
index 000000000..7a3bee776
--- /dev/null
+++ b/promises-a-plus/promises-a-plus.d.ts
@@ -0,0 +1,16 @@
+declare module PromisesAPlus {
+	interface PromiseCtor {
+		<T>(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): Thenable<T>;
+	}
+
+	interface PromiseImpl {
+		new <T>(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): Thenable<T>;
+	}
+
+	interface Thenable<R> {
+		then<U>(onFulfill: (value: R) => Thenable<U>, onReject: (error: any) => Thenable<U>): Thenable<U>;
+		then<U>(onFulfill: (value: R) => Thenable<U>, onReject?: (error: any) => U): Thenable<U>;
+		then<U>(onFulfill: (value: R) => U, onReject: (error: any) => Thenable<U>): Thenable<U>;
+		then<U>(onFulfill?: (value: R) => U, onReject?: (error: any) => U): Thenable<U>;
+	}
+}
diff --git a/rx.js/rx.async.d.ts b/rx.js/rx.async.d.ts
index cdd93b9a8..7238acafb 100644
--- a/rx.js/rx.async.d.ts
+++ b/rx.js/rx.async.d.ts
@@ -104,9 +104,9 @@ declare module Rx {
 	 * Promise A+
 	 */
 	export interface IPromise<T> {
-		then<R>(onFulfilled?: (value: T) => IPromise<R>, onRejected?: (reason: any) => IPromise<R>): IPromise<R>;
-		then<R>(onFulfilled?: (value: T) => IPromise<R>, onRejected?: (reason: any) => R): IPromise<R>;
-		then<R>(onFulfilled?: (value: T) => R, onRejected?: (reason: any) => IPromise<R>): IPromise<R>;
+		then<R>(onFulfilled: (value: T) => IPromise<R>, onRejected: (reason: any) => IPromise<R>): IPromise<R>;
+		then<R>(onFulfilled: (value: T) => IPromise<R>, onRejected?: (reason: any) => R): IPromise<R>;
+		then<R>(onFulfilled: (value: T) => R, onRejected: (reason: any) => IPromise<R>): IPromise<R>;
 		then<R>(onFulfilled?: (value: T) => R, onRejected?: (reason: any) => R): IPromise<R>;
 	}
 }

From 7a521a2f56ed37449882cfb0414a7f714565717a Mon Sep 17 00:00:00 2001
From: Santi Albo <santialbo@gmail.com>
Date: Fri, 7 Mar 2014 13:57:09 +0000
Subject: [PATCH 039/309] Fix typo on restify type definition

---
 restify/restify.d.ts | 42 +++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/restify/restify.d.ts b/restify/restify.d.ts
index 8f02f4b0b..415a047e9 100644
--- a/restify/restify.d.ts
+++ b/restify/restify.d.ts
@@ -52,12 +52,12 @@ declare module "restify" {
 
   interface Server extends http.Server {
     use: (... handler: any[]) => any;
-    post: (route: any, routeCallBack: RequestHadler) => any;
-    patch: (route: any, routeCallBack: RequestHadler) => any;
-    put: (route: any, routeCallBack: RequestHadler) => any;
-    del: (route: any, routeCallBack: RequestHadler) => any;
-    get: (route: any, routeCallBack: RequestHadler) => any;
-    head: (route: any, routeCallBack: RequestHadler) => any;
+    post: (route: any, routeCallBack: RequestHandler) => any;
+    patch: (route: any, routeCallBack: RequestHandler) => any;
+    put: (route: any, routeCallBack: RequestHandler) => any;
+    del: (route: any, routeCallBack: RequestHandler) => any;
+    get: (route: any, routeCallBack: RequestHandler) => any;
+    head: (route: any, routeCallBack: RequestHandler) => any;
     name: string;
     version: string;
     log: Object;
@@ -66,7 +66,7 @@ declare module "restify" {
     address: () => addressInterface;
     listen: (... args: any[]) => any;
     close: (... args: any[]) => any;
-    pre: (routeCallBack: RequestHadler) => any;
+    pre: (routeCallBack: RequestHandler) => any;
 
   }
 
@@ -124,7 +124,7 @@ declare module "restify" {
     overrides?: Object;
   }
 
-  interface RequestHadler {
+  interface RequestHandler {
     (req: Request, res: Response, next: Function): any;
   }
 
@@ -152,19 +152,19 @@ declare module "restify" {
   export class ResourceNotFoundError { constructor(message: any); }
   export class WrongAcceptError { constructor(message: any); }
 
-  export function acceptParser(parser: any): RequestHadler;
-  export function authorizationParser(): RequestHadler;
-  export function dateParser(skew?: number): RequestHadler;
-  export function queryParser(options?: Object): RequestHadler;
-  export function urlEncodedBodyParser(options?: Object): RequestHadler[];
-  export function jsonp(): RequestHadler;
-  export function gzipResponse(options?: Object): RequestHadler;
-  export function bodyParser(options?: Object): RequestHadler[];
-  export function requestLogger(options?: Object): RequestHadler;
-  export function serveStatic(options?: Object): RequestHadler;
-  export function throttle(options?: ThrottleOptions): RequestHadler;
-  export function conditionalRequest(): RequestHadler[];
+  export function acceptParser(parser: any): RequestHandler;
+  export function authorizationParser(): RequestHandler;
+  export function dateParser(skew?: number): RequestHandler;
+  export function queryParser(options?: Object): RequestHandler;
+  export function urlEncodedBodyParser(options?: Object): RequestHandler[];
+  export function jsonp(): RequestHandler;
+  export function gzipResponse(options?: Object): RequestHandler;
+  export function bodyParser(options?: Object): RequestHandler[];
+  export function requestLogger(options?: Object): RequestHandler;
+  export function serveStatic(options?: Object): RequestHandler;
+  export function throttle(options?: ThrottleOptions): RequestHandler;
+  export function conditionalRequest(): RequestHandler[];
   export function auditLogger(options?: Object): Function;
-  export function fullResponse(): RequestHadler;
+  export function fullResponse(): RequestHandler;
   export var defaultResponseHeaders : any;
 }

From 8804d6de0cfde417885338cbd42a907c1722b27f Mon Sep 17 00:00:00 2001
From: Peter Gill <peter.gill@townsuite.com>
Date: Fri, 7 Mar 2014 11:51:54 -0330
Subject: [PATCH 040/309] Add return type.

---
 jquery.placeholder/jquery.placeholder.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/jquery.placeholder/jquery.placeholder.d.ts b/jquery.placeholder/jquery.placeholder.d.ts
index 2b4d410a7..b9af72494 100644
--- a/jquery.placeholder/jquery.placeholder.d.ts
+++ b/jquery.placeholder/jquery.placeholder.d.ts
@@ -7,7 +7,7 @@
 
 interface JQuery {
 
-	placeholder();
+	placeholder() : void;
 
 }
 

From a6964c6bf2d5a17443028b5796603c2f859b2702 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Fri, 7 Mar 2014 18:48:32 +0100
Subject: [PATCH 041/309] small fixes to Lazy.js

---
 lazy.js/lazy.js-tests.ts | 5 +++--
 lazy.js/lazy.js.d.ts     | 6 +++---
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/lazy.js/lazy.js-tests.ts b/lazy.js/lazy.js-tests.ts
index 59331377c..7689bcaf7 100644
--- a/lazy.js/lazy.js-tests.ts
+++ b/lazy.js/lazy.js-tests.ts
@@ -27,6 +27,7 @@ var fooObjectSeq: LazyJS.ObjectLikeSequence<Foo>;
 var anyObjectSeq: LazyJS.ObjectLikeSequence<any>;
 var fooAsyncSeq: LazyJS.AsyncSequence<Foo>;
 
+var strSequence: LazyJS.Sequence<string>;
 var stringSeq: LazyJS.StringLikeSequence;
 
 var obj: Object;
@@ -124,7 +125,7 @@ foo = fooSequence.last();
 fooSequence = fooSequence.last(num);
 
 fooSequence = fooSequence.lastIndexOf(foo);
-fooSequence = fooSequence.map(fnMapCallback);
+barSequence = fooSequence.map(fnMapCallback);
 foo = fooSequence.max();
 foo = fooSequence.max(fnNumberCallback);
 foo = fooSequence.min();
@@ -175,7 +176,7 @@ fooObjectSeq = fooObjectSeq.defaults(obj);
 fooSequence = fooObjectSeq.functions();
 fooObjectSeq = fooObjectSeq.get(str);
 fooObjectSeq = fooObjectSeq.invert();
-stringSeq = fooObjectSeq.keys();
+strSequence = fooObjectSeq.keys();
 fooObjectSeq = fooObjectSeq.omit(strArr);
 fooSequence = fooObjectSeq.pairs();
 fooObjectSeq = fooObjectSeq.pick(strArr);
diff --git a/lazy.js/lazy.js.d.ts b/lazy.js/lazy.js.d.ts
index 53de92ae3..ca19aed98 100644
--- a/lazy.js/lazy.js.d.ts
+++ b/lazy.js/lazy.js.d.ts
@@ -6,8 +6,8 @@
 declare module LazyJS {
 
 	interface LazyStatic {
-		(value: string):StringLikeSequence;
 
+		(value: string):StringLikeSequence;
 		<T>(value: T[]):ArrayLikeSequence<T>;
 		(value: any[]):ArrayLikeSequence<any>;
 		<T>(value: Object):ObjectLikeSequence<T>;
@@ -141,7 +141,7 @@ declare module LazyJS {
 		invoke(methodName: string): Sequence<T>;
 		isEmpty(): boolean;
 		join(delimiter?: string): string;
-		map<U>(mapFn: MapCallback<T, U>): Sequence<T>;
+		map<U>(mapFn: MapCallback<T, U>): Sequence<U>;
 
 		max(valueFn?: NumberCallback<T>): T;
 		min(valueFn?: NumberCallback<T>): T;
@@ -200,7 +200,7 @@ declare module LazyJS {
 		functions(): Sequence<T>;
 		get(property: string): ObjectLikeSequence<T>;
 		invert(): ObjectLikeSequence<T>;
-		keys(): StringLikeSequence;
+		keys(): Sequence<string>;
 		omit(properties: string[]): ObjectLikeSequence<T>;
 		pairs(): Sequence<T>;
 		pick(properties: string[]): ObjectLikeSequence<T>;

From c1b45ba7c41d17245f5125806a1e8705b7f21818 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Fri, 7 Mar 2014 19:54:09 +0100
Subject: [PATCH 042/309] Fixed tests for microsoft-live-connect

---
 ...ft-live-connect.ts => microsoft-live-connect-tests.ts} | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
 rename microsoft-live-connect/{microsoft-live-connect.ts => microsoft-live-connect-tests.ts} (99%)

diff --git a/microsoft-live-connect/microsoft-live-connect.ts b/microsoft-live-connect/microsoft-live-connect-tests.ts
similarity index 99%
rename from microsoft-live-connect/microsoft-live-connect.ts
rename to microsoft-live-connect/microsoft-live-connect-tests.ts
index 98fcf5a3b..e6c1e2ad0 100644
--- a/microsoft-live-connect/microsoft-live-connect.ts
+++ b/microsoft-live-connect/microsoft-live-connect-tests.ts
@@ -310,7 +310,7 @@ skyDriveProps = {
 WL.ui(skyDriveProps);
 
 function onDownloadFileCompleted(response: Microsoft.Live.IFilePickerResult) {
-    var msg = "", folder, file;
+    var msg = "", folder: number, file: number;
     // For each folder selected...
     if (response.data.folders.length > 0) {
         for (folder = 0; folder < response.data.folders.length; folder++) {
@@ -536,7 +536,7 @@ var errorObj: Microsoft.Live.IError = {
     }
 };
 
-var event: Microsoft.Live.IEvent = {
+var eventI: Microsoft.Live.IEvent = {
     "id": "event.611afb17fa9448f28cdb8277e8ffeb77.e9f015000d0249ce847c5306a25d7d75",
     "name": "Global Project Risk Management Meeting",
     "description": "Generate and assess risks for the project",
@@ -854,7 +854,7 @@ var videoCollection: Microsoft.Live.IObjectCollection<Microsoft.Live.IVideo> = {
  * already exercised above.
  */
 
-function log(message) {
+function log(message: string) {
     var child = document.createTextNode(message);
     var parent = document.getElementById('JsOutputDiv') || document.body;
     parent.appendChild(child);
@@ -974,7 +974,7 @@ function showUserContactInfo() {
     );
 }
 
-function enablePurchase(response) {
+function enablePurchase() {
     var date = new Date();
     var year = date.getFullYear();
 

From 1f92231282b582700cbdd2763ae56df690a279b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=A1clav=20Oborn=C3=ADk?= <register.ufon@gmail.com>
Date: Fri, 7 Mar 2014 22:43:01 +0100
Subject: [PATCH 043/309] Request.query is any

---
 restify/restify.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/restify/restify.d.ts b/restify/restify.d.ts
index 415a047e9..40bc8b4a3 100644
--- a/restify/restify.d.ts
+++ b/restify/restify.d.ts
@@ -27,7 +27,7 @@ declare module "restify" {
     log: Object;
     id: string;
     path: () => string;
-    query: string;
+    query: any;
     secure: boolean;
     time: number;
     params: any;

From 43fdc7cb6a3f0795e9e81d08993f41bad8508abe Mon Sep 17 00:00:00 2001
From: Greg Smith <smr.kyu@gmail.com>
Date: Fri, 7 Mar 2014 17:48:31 -0600
Subject: [PATCH 044/309] Fixed d3 definitions for d3.geom.voronoi

---
 d3/d3-tests.ts |  5 ++++-
 d3/d3.d.ts     | 56 +++++++++++++++++++++++++++++++++++++++++++++-----
 2 files changed, 55 insertions(+), 6 deletions(-)

diff --git a/d3/d3-tests.ts b/d3/d3-tests.ts
index 02623aa9f..362f31ea0 100644
--- a/d3/d3-tests.ts
+++ b/d3/d3-tests.ts
@@ -1168,6 +1168,9 @@ function voroniTesselation() {
         return [Math.random() * width, Math.random() * height];
     } );
 
+    var voronoi = d3.geom.voronoi()
+        .clipExtent([[0, 0], [width, height]]);
+
     var svg = d3.select("body").append("svg")
         .attr("width", width)
         .attr("height", height)
@@ -1185,7 +1188,7 @@ function voroniTesselation() {
     redraw();
     
     function redraw() {
-        path = path.data(d3.geom.voronoi(vertices).map(function (d) { return "M" + d.join("L") + "Z"; } ), String);
+        path = path.data(voronoi(vertices).map(function (d) { return "M" + d.join("L") + "Z"; } ), String);
         path.exit().remove();
         path.enter().append("path").attr("class", function (d, i) { return "q" + (i % 9) + "-9"; } ).attr("d", String);
         path.order();
diff --git a/d3/d3.d.ts b/d3/d3.d.ts
index 8435e9fe4..9f6965cfa 100644
--- a/d3/d3.d.ts
+++ b/d3/d3.d.ts
@@ -3211,10 +3211,11 @@ declare module D3 {
     // Geometry
     export module Geom {
         export interface Geom {
+            voronoi(): Voronoi;
             /**
             * compute the Voronoi diagram for the specified points.
             */
-            voronoi: Voronoi
+            voronoi(vertices?: Array<Vertice>): Array<Polygon>;
             /**
             * compute the Delaunay triangulation for the specified points.
             */
@@ -3296,14 +3297,59 @@ declare module D3 {
         }
 
         export interface Voronoi {
+            /**
+            * compute the Voronoi diagram for the specified points.
+            */
             (vertices?: Array<Vertice>): Array<Polygon>;
             x: {
-                (): (d: any) => any;
-                (accesor: (d: any) => any): any;
+                /**
+                * Get the x-coordinate accessor.
+                */
+                (): (data: any, index ?: number) => number;
+                /**
+                * Set the x-coordinate accessor.
+                *
+                * @param accessor The new accessor function
+                */
+                (accessor: (data: any) => number): Voronoi;
+                (accessor: (data: any, index: number) => number): Voronoi;
+                /**
+                * Set the x-coordinate to a constant.
+                *
+                * @param cnst The new constant value.
+                */
+                (cnst: number): Voronoi;
             }
             y: {
-                (): (d: any) => any;
-                (accesor: (d: any) => any): any;
+                /**
+                * Get the y-coordinate accessor.
+                */
+                (): (data: any, index ?: number) => number;
+                /**
+                * Set the y-coordinate accessor.
+                *
+                * @param accessor The new accessor function.
+                */
+                (accessor: (data: any) => number): Voronoi;
+                (accessor: (data: any, index: number) => number): Voronoi;
+                /**
+                * Set the y-coordinate to a constant.
+                *
+                * @param cnst The new constant value.
+                */
+                (cnst: number): Voronoi;
+            }
+            clipExtent: {
+                /**
+                * Get the clip extent.
+                */
+                (): Array<Array<number>>;
+                /**
+                * Set the clip extent.
+                *
+                * @param extent The new clip extent.
+                */
+                (extent: Array<Array<number>>): Voronoi;
             }
         }
 

From c70eba32372488d89506fe8cfbac2427d509af87 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Sat, 8 Mar 2014 01:06:08 +0100
Subject: [PATCH 045/309] fixed async flaw in test runner

silly flow problem could bypass concurrency limits
---
 _infrastructure/tests/runner.js | 19 +++++++++----------
 _infrastructure/tests/runner.ts | 13 +++++--------
 2 files changed, 14 insertions(+), 18 deletions(-)

diff --git a/_infrastructure/tests/runner.js b/_infrastructure/tests/runner.js
index 649569923..9d6830f67 100644
--- a/_infrastructure/tests/runner.js
+++ b/_infrastructure/tests/runner.js
@@ -1035,9 +1035,6 @@ var DT;
 
             // add a closure to queue
             this.queue.push(function () {
-                // when activate, add test to active list
-                _this.active.push(test);
-
                 // run it
                 var p = test.run();
                 p.then(defer.resolve.bind(defer), defer.reject.bind(defer));
@@ -1048,6 +1045,9 @@ var DT;
                     }
                     _this.step();
                 });
+
+                // return it
+                return test;
             });
             this.step();
 
@@ -1056,13 +1056,9 @@ var DT;
         };
 
         TestQueue.prototype.step = function () {
-            var _this = this;
-            // setTimeout to make it flush
-            setTimeout(function () {
-                while (_this.queue.length > 0 && _this.active.length < _this.concurrent) {
-                    _this.queue.pop().call(null);
-                }
-            }, 1);
+            while (this.queue.length > 0 && this.active.length < this.concurrent) {
+                this.active.push(this.queue.pop().call(null));
+            }
         };
         return TestQueue;
     })();
@@ -1314,4 +1310,7 @@ var DT;
         process.exit(2);
     });
 })(DT || (DT = {}));
+//grunt-start
+/// <reference path="../runner.ts" />
+//grunt-end
 //# sourceMappingURL=runner.js.map
diff --git a/_infrastructure/tests/runner.ts b/_infrastructure/tests/runner.ts
index 6e71d621a..ad3a77909 100644
--- a/_infrastructure/tests/runner.ts
+++ b/_infrastructure/tests/runner.ts
@@ -75,8 +75,6 @@ module DT {
 			var defer = Promise.defer();
 			// add a closure to queue
 			this.queue.push(() => {
-				// when activate, add test to active list
-				this.active.push(test);
 				// run it
 				var p = test.run();
 				p.then(defer.resolve.bind(defer), defer.reject.bind(defer));
@@ -87,6 +85,8 @@ module DT {
 					}
 					this.step();
 				});
+				// return it
+				return test;
 			});
 			this.step();
 			// defer it
@@ -94,12 +94,9 @@ module DT {
 		}
 
 		private step(): void {
-			// setTimeout to make it flush
-			setTimeout(() => {
-				while (this.queue.length > 0 && this.active.length < this.concurrent) {
-					this.queue.pop().call(null);
-				}
-			}, 1);
+			while (this.queue.length > 0 && this.active.length < this.concurrent) {
+				this.active.push(this.queue.pop().call(null));
+			}
 		}
 	}
 

From 0119825e4a5c6a0fc470b8b5d7b59fa688569930 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Sat, 8 Mar 2014 01:00:38 +0100
Subject: [PATCH 046/309] allow magic branch to run full test

---
 _infrastructure/tests/runner.js | 4 +++-
 _infrastructure/tests/runner.ts | 4 +++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/_infrastructure/tests/runner.js b/_infrastructure/tests/runner.js
index 9d6830f67..81416ca01 100644
--- a/_infrastructure/tests/runner.js
+++ b/_infrastructure/tests/runner.js
@@ -1293,10 +1293,12 @@ var DT;
         process.exit(0);
     }
 
+    var testFull = process.env['TRAVIS_BRANCH'] ? /\w\/full$/.test(process.env['TRAVIS_BRANCH']) : false;
+
     new TestRunner(dtPath, {
         concurrent: argv['single-thread'] ? 1 : Math.max(cpuCores, 2),
         tscVersion: argv['tsc-version'],
-        testChanges: argv['test-changes'],
+        testChanges: testFull ? false : argv['test-changes'],
         skipTests: argv['skip-tests'],
         printFiles: argv['print-files'],
         printRefMap: argv['print-refmap'],
diff --git a/_infrastructure/tests/runner.ts b/_infrastructure/tests/runner.ts
index ad3a77909..5d4f42815 100644
--- a/_infrastructure/tests/runner.ts
+++ b/_infrastructure/tests/runner.ts
@@ -336,10 +336,12 @@ module DT {
 		process.exit(0);
 	}
 
+	var testFull = process.env['TRAVIS_BRANCH'] ? /\w\/full$/.test(process.env['TRAVIS_BRANCH']) : false;
+
 	new TestRunner(dtPath, {
 		concurrent: argv['single-thread'] ? 1 : Math.max(cpuCores, 2),
 		tscVersion: argv['tsc-version'],
-		testChanges: argv['test-changes'],
+		testChanges: testFull ? false : argv['test-changes'], // allow magic branch
 		skipTests: argv['skip-tests'],
 		printFiles: argv['print-files'],
 		printRefMap: argv['print-refmap'],

From 751c92514bf9b284f1ffa7b2559f748d04e73ef3 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Sat, 8 Mar 2014 01:00:02 +0100
Subject: [PATCH 047/309] added --sourcemap to compile bat

---
 _infrastructure/tests/compile-runner.bat | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/_infrastructure/tests/compile-runner.bat b/_infrastructure/tests/compile-runner.bat
index e54803ec8..49f737c5d 100644
--- a/_infrastructure/tests/compile-runner.bat
+++ b/_infrastructure/tests/compile-runner.bat
@@ -1 +1 @@
-tsc runner.ts --target ES5 --out runner.js --module commonjs
\ No newline at end of file
+tsc runner.ts --target ES5 --out runner.js --module commonjs --sourcemap

From 967dae3a6798f597d93dc9ff404d2dd75b1bb89d Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Sat, 8 Mar 2014 01:15:20 +0100
Subject: [PATCH 048/309] changed runner Syntax pass to only compile
 declarations

---
 _infrastructure/tests/runner.js           | 2 +-
 _infrastructure/tests/src/suite/syntax.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/_infrastructure/tests/runner.js b/_infrastructure/tests/runner.js
index 81416ca01..9a3647abd 100644
--- a/_infrastructure/tests/runner.js
+++ b/_infrastructure/tests/runner.js
@@ -850,7 +850,7 @@ var DT;
 
     var Promise = require('bluebird');
 
-    var endDts = /\w\.ts$/i;
+    var endDts = /\w\.d\.ts$/i;
 
     /////////////////////////////////
     // .d.ts syntax inspection
diff --git a/_infrastructure/tests/src/suite/syntax.ts b/_infrastructure/tests/src/suite/syntax.ts
index 9211c3fde..915fd18d0 100644
--- a/_infrastructure/tests/src/suite/syntax.ts
+++ b/_infrastructure/tests/src/suite/syntax.ts
@@ -6,7 +6,7 @@ module DT {
 
 	var Promise: typeof Promise = require('bluebird');
 
-	var endDts = /\w\.ts$/i;
+	var endDts = /\w\.d\.ts$/i;
 
 	/////////////////////////////////
 	// .d.ts syntax inspection

From 8db2a16ea70364b616001b6411c205c69c114763 Mon Sep 17 00:00:00 2001
From: ofirgeller <ofirgeller22@gmail.com>
Date: Sat, 8 Mar 2014 08:07:22 +0200
Subject: [PATCH 049/309] added  row def and more strong typing for callbacks
 and tamplates

---
 ng-grid/ng-grid.d.ts | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/ng-grid/ng-grid.d.ts b/ng-grid/ng-grid.d.ts
index 48eec367a..baf920b00 100644
--- a/ng-grid/ng-grid.d.ts
+++ b/ng-grid/ng-grid.d.ts
@@ -14,10 +14,10 @@ declare module ngGrid {
     export interface GridOptions {
 
         /** Define an aggregate template to customize the rows when grouped. See github wiki for more details. */
-        aggregateTemplate?: any;
+        aggregateTemplate?: string;
 
         /** Callback for when you want to validate something after selection. */
-        afterSelectionChange?: Function;
+        afterSelectionChange?: (rowItem?, event?) => void ;
 
         /** Callback if you want to inspect something before selection,
         return false if you want to cancel the selection. return true otherwise. 
@@ -25,13 +25,13 @@ declare module ngGrid {
         use rowItem.changeSelection(event) method after returning false initially. 
         Note: when shift+ Selecting multiple items in the grid this will only get called
         once and the rowItem will be an array of items that are queued to be selected. */
-        beforeSelectionChange?: Function;
+        beforeSelectionChange?: (rowItem?, event?) => boolean ;
 
         /** checkbox templates. */
-        checkboxCellTemplate?: any;
+        checkboxCellTemplate?: string;
 
         /** checkbox templates. */
-        checkboxHeaderTemplate?: any;
+        checkboxHeaderTemplate?: string;
 
         /** definitions of columns as an array [], if not defined columns are auto-generated. See github wiki for more details. */
         columnDefs?: ColumnDef[];
@@ -91,7 +91,7 @@ declare module ngGrid {
         headerRowHeight?: number;
 
         /** Define a header row template for further customization. See github wiki for more details. */
-        headerRowTemplate?: any;
+        headerRowTemplate?: string;
 
         /** Enables the use of jquery UI reaggable/droppable plugin. requires jqueryUI to work if enabled. 
         Useful if you want drag + drop but your users insist on crappy browsers. */
@@ -105,7 +105,7 @@ declare module ngGrid {
 
         /** Maintains the column widths while resizing. 
         Defaults to true when using *'s or undefined widths. Can be ovverriden by setting to false. */
-        maintainColumnRatios?: any;
+        maintainColumnRatios?: boolean;
 
         /** Set this to false if you only want one item selected at a time */
         multiSelect?: boolean;
@@ -123,7 +123,7 @@ declare module ngGrid {
         rowHeight?: number;
 
         /** Define a row template to customize output. See github wiki for more details. */
-        rowTemplate?: any;
+        rowTemplate?: string;
 
         /** all of the items selected in the grid. In single select mode there will only be one item in the array. */
         selectedItems?: any[];
@@ -170,7 +170,12 @@ declare module ngGrid {
         enableHighlighting?: boolean;
     }
 
-    export interface ColumnDef {
+    export interface rowDef {
+        field?: string;
+        width?: any;  //**this can be a string containing a relatively, absolute size units or a number: '30%','54px',45 /*
+        displayName?: string;
+        cellTemplate?: string;
+        enableCellEdit?: boolean;
     }
 
     export interface FilterOptions {

From 003a596c77d5fc99a717accac1b21185f9066e5b Mon Sep 17 00:00:00 2001
From: ofirgeller <ofirgeller22@gmail.com>
Date: Sat, 8 Mar 2014 08:12:15 +0200
Subject: [PATCH 050/309] fixed naming

---
 ng-grid/ng-grid.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ng-grid/ng-grid.d.ts b/ng-grid/ng-grid.d.ts
index baf920b00..9fd0155e4 100644
--- a/ng-grid/ng-grid.d.ts
+++ b/ng-grid/ng-grid.d.ts
@@ -170,7 +170,7 @@ declare module ngGrid {
         enableHighlighting?: boolean;
     }
 
-    export interface rowDef {
+    export interface columnDef {
         field?: string;
         width?: any;  //**this can be a string containing a relatively, absolute size units or a number: '30%','54px',45 /*
         displayName?: string;

From ed33f07cbc5be07c0662b54adc1a452b94233a27 Mon Sep 17 00:00:00 2001
From: ofirgeller <ofirgeller22@gmail.com>
Date: Sat, 8 Mar 2014 08:16:54 +0200
Subject: [PATCH 051/309] added the prefix I to interfaces.

---
 ng-grid/ng-grid.d.ts | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/ng-grid/ng-grid.d.ts b/ng-grid/ng-grid.d.ts
index 9fd0155e4..3522e94aa 100644
--- a/ng-grid/ng-grid.d.ts
+++ b/ng-grid/ng-grid.d.ts
@@ -11,7 +11,7 @@ declare class ngGridReorderable {
 
 declare module ngGrid {
 
-    export interface GridOptions {
+    export interface IGridOptions {
 
         /** Define an aggregate template to customize the rows when grouped. See github wiki for more details. */
         aggregateTemplate?: string;
@@ -34,7 +34,7 @@ declare module ngGrid {
         checkboxHeaderTemplate?: string;
 
         /** definitions of columns as an array [], if not defined columns are auto-generated. See github wiki for more details. */
-        columnDefs?: ColumnDef[];
+        columnDefs?: IColumnDef[];
 
         /** Data being displayed in the grid. Each item in the array is mapped to a row being displayed. */
         data?: any[];
@@ -79,7 +79,7 @@ declare module ngGrid {
         filterText: The text bound to the built-in search box. 
         useExternalFilter: Bypass internal filtering if you want to roll your own filtering mechanism but want to use builtin search box.
         */
-        filterOptions?: FilterOptions;
+        filterOptions?: IFilterOptions;
 
         /** Defining the height of the footer in pixels. */
         footerRowHeight?: number;
@@ -111,7 +111,7 @@ declare module ngGrid {
         multiSelect?: boolean;
 
         /**  pagingOptions - */
-        pagingOptions?: PagingOptions;
+        pagingOptions?: IPagingOptions;
 
         /** Array of plugin functions to register in ng-grid */
         pinSelectionCheckbox?: boolean;
@@ -170,7 +170,7 @@ declare module ngGrid {
         enableHighlighting?: boolean;
     }
 
-    export interface columnDef {
+    export interface IColumnDef {
         field?: string;
         width?: any;  //**this can be a string containing a relatively, absolute size units or a number: '30%','54px',45 /*
         displayName?: string;
@@ -178,12 +178,12 @@ declare module ngGrid {
         enableCellEdit?: boolean;
     }
 
-    export interface FilterOptions {
+    export interface IFilterOptions {
         filterText?: string;
         useExternalFilter?: boolean;
     }
 
-    export interface PagingOptions {
+    export interface IPagingOptions {
         /**  pageSizes: list of available page sizes.  */
         pageSizes?: number[];
         /** pageSize: currently selected page size.  */

From 2cd889f4d1887019f28f98ee017ba6e8178f1a14 Mon Sep 17 00:00:00 2001
From: ofirgeller <ofirgeller22@gmail.com>
Date: Sat, 8 Mar 2014 14:33:09 +0200
Subject: [PATCH 052/309] explicit <any>

the event can be more specific. will check later
---
 ng-grid/ng-grid.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ng-grid/ng-grid.d.ts b/ng-grid/ng-grid.d.ts
index 3522e94aa..f081b362c 100644
--- a/ng-grid/ng-grid.d.ts
+++ b/ng-grid/ng-grid.d.ts
@@ -17,7 +17,7 @@ declare module ngGrid {
         aggregateTemplate?: string;
 
         /** Callback for when you want to validate something after selection. */
-        afterSelectionChange?: (rowItem?, event?) => void ;
+        afterSelectionChange?: (rowItem?: any, event?: any) => void ;
 
         /** Callback if you want to inspect something before selection,
         return false if you want to cancel the selection. return true otherwise. 
@@ -25,7 +25,7 @@ declare module ngGrid {
         use rowItem.changeSelection(event) method after returning false initially. 
         Note: when shift+ Selecting multiple items in the grid this will only get called
         once and the rowItem will be an array of items that are queued to be selected. */
-        beforeSelectionChange?: (rowItem?, event?) => boolean ;
+        beforeSelectionChange?: (rowItem?: any, event?: any) => boolean ;
 
         /** checkbox templates. */
         checkboxCellTemplate?: string;

From 7807578ff297d7cc4d0bbdbd2ef11812bcb9b4c2 Mon Sep 17 00:00:00 2001
From: ofirgeller <ofirgeller22@gmail.com>
Date: Sat, 8 Mar 2014 14:33:53 +0200
Subject: [PATCH 053/309] rename to match the I afix

---
 ng-grid/ng-grid-tests.ts | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/ng-grid/ng-grid-tests.ts b/ng-grid/ng-grid-tests.ts
index 5f4ab6ce5..0ad173651 100644
--- a/ng-grid/ng-grid-tests.ts
+++ b/ng-grid/ng-grid-tests.ts
@@ -1,27 +1,27 @@
 /// <reference path="ng-grid.d.ts" />
 
-var options1: ngGrid.GridOptions = {
+var options1: ngGrid.IGridOptions = {
     data: [{ 'Name': 'Bob' }, { 'Name': 'Jane' }]
 };
 
-var options2: ngGrid.GridOptions = {
+var options2: ngGrid.IGridOptions = {
     afterSelectionChange: () => { },
     beforeSelectionChange: () => { },
     dataUpdated: () => { }
 };
 
-var options3: ngGrid.GridOptions = {
+var options3: ngGrid.IGridOptions = {
     columnDefs: [
         { field: 'name', displayName: 'Name' },
         { field: 'age', displayName: 'Age' }
     ]
 };
 
-var options4: ngGrid.GridOptions = {
+var options4: ngGrid.IGridOptions = {
     pagingOptions: {
         pageSizes: [1, 2, 3, 4],
         pageSize: 2,
         totalServerItems: 100,
         currentPage: 1
     }
-};
\ No newline at end of file
+};

From 1d2781cde32a2df47610998cab188c7c46c62b0c Mon Sep 17 00:00:00 2001
From: ofirgeller <ofirgeller22@gmail.com>
Date: Sat, 8 Mar 2014 14:37:58 +0200
Subject: [PATCH 054/309] return true so the select takes place

---
 ng-grid/ng-grid-tests.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ng-grid/ng-grid-tests.ts b/ng-grid/ng-grid-tests.ts
index 0ad173651..53763b1a5 100644
--- a/ng-grid/ng-grid-tests.ts
+++ b/ng-grid/ng-grid-tests.ts
@@ -6,7 +6,7 @@ var options1: ngGrid.IGridOptions = {
 
 var options2: ngGrid.IGridOptions = {
     afterSelectionChange: () => { },
-    beforeSelectionChange: () => { },
+    beforeSelectionChange: () => {return true; },
     dataUpdated: () => { }
 };
 

From 51b93b972ba593c34602d848c992c7ec82d6ce5e Mon Sep 17 00:00:00 2001
From: satoru kimura <s_kimura@sa.il24.net>
Date: Sat, 8 Mar 2014 22:55:04 +0900
Subject: [PATCH 055/309] added classes that has not been documented, and
 deleted classes that does not exist in the source code. modified definition
 for Loader related class along the source code. fixed some mistakes.

---
 threejs/three-tests.ts |  45 --------
 threejs/three.d.ts     | 245 ++++++++++++++++++++++++++++++++---------
 2 files changed, 190 insertions(+), 100 deletions(-)

diff --git a/threejs/three-tests.ts b/threejs/three-tests.ts
index afb4b2300..8207933bc 100644
--- a/threejs/three-tests.ts
+++ b/threejs/three-tests.ts
@@ -13896,51 +13896,6 @@ declare var ballPosition: THREE.Vector3;
             new THREE.MeshBasicMaterial( { color: 0xffffff, wireframe: true, transparent: true, opacity: 0.1 } )
         ];
 
-
-        // tetrahedron
-
-        var points = [
-            new THREE.Vector3( 100, 0, 0 ),
-            new THREE.Vector3( 0, 100, 0 ),
-            new THREE.Vector3( 0, 0, 100 ),
-            new THREE.Vector3( 0, 0, 0 )
-        ];
-
-        object = THREE.SceneUtils.createMultiMaterialObject( new THREE.ConvexGeometry( points ), materials );
-        object.position.set( 0, 0, 0 );
-        scene.add( object );
-
-        // cube
-
-        var points = [
-            new THREE.Vector3( 50, 50, 50 ),
-            new THREE.Vector3( 50, 50, -50 ),
-            new THREE.Vector3( -50, 50, -50 ),
-            new THREE.Vector3( -50, 50, 50 ),
-            new THREE.Vector3( 50, -50, 50 ),
-            new THREE.Vector3( 50, -50, -50 ),
-            new THREE.Vector3( -50, -50, -50 ),
-            new THREE.Vector3( -50, -50, 50 ),
-        ];
-
-        object = THREE.SceneUtils.createMultiMaterialObject( new THREE.ConvexGeometry( points ), materials );
-        object.position.set( -200, 0, -200 );
-        scene.add( object );
-
-        // random convex
-
-        points = [];
-        for ( var i = 0; i < 30; i ++ ) {
-
-            points.push( randomPointInSphere( 50 ) );
-
-        }
-
-        object = THREE.SceneUtils.createMultiMaterialObject( new THREE.ConvexGeometry( points ), materials );
-        object.position.set( -200, 0, 200 );
-        scene.add( object );
-
-
         object = new THREE.AxisHelper( 50 );
         object.position.set( 200, 0, -200 );
         scene.add( object );
diff --git a/threejs/three.d.ts b/threejs/three.d.ts
index b76430f92..c39ff721e 100644
--- a/threejs/three.d.ts
+++ b/threejs/three.d.ts
@@ -171,6 +171,7 @@ declare module THREE {
          * @param vector point to look at
          */
         lookAt(vector: Vector3): void;
+        clone(camera?: Camera): Camera;
     }
 
     /**
@@ -227,6 +228,8 @@ declare module THREE {
          * Updates the camera projection matrix. Must be called after change of parameters.
          */
         updateProjectionMatrix(): void;
+
+        clone(): OrthographicCamera;
     }
 
     /**
@@ -318,6 +321,7 @@ declare module THREE {
          * Updates the camera projection matrix. Must be called after change of parameters.
          */
         updateProjectionMatrix(): void;
+        clone(): PerspectiveCamera;
     }
 
     // Core ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -383,6 +387,8 @@ declare module THREE {
         morphTargets: any[];
         hasTangents: boolean;
 
+        addAttribute(name: string, type: Function, numItems: number, itemSize: number): any;
+
         /**
          * Bakes matrix transform directly into vertex coordinates.
          */
@@ -419,6 +425,8 @@ declare module THREE {
         dispose(): void;
 
         normalizeNormals(): void;
+
+        clone(): BufferGeometry;
     }
 
     /**
@@ -914,6 +922,13 @@ declare module THREE {
         computeLineDistances(): void;
     }
 
+    export class Geometry2 extends BufferGeometry {
+        vertices: Float32Array;
+        normals: Float32Array;
+        uvs: Float32Array;
+
+    }
+
     /**
      * Base class for scene graph objects
      */
@@ -1108,11 +1123,6 @@ declare module THREE {
 
         clone(object?: Object3D, recursive?: boolean): Object3D;
 
-        /**
-         * Creates a new clone of this object and all descendants.
-         */
-        clone(object?: Object3D): Object3D;
-
         /**
          * Searches through the object's children and returns the first with a matching name, optionally recursive.
          * @param name  String to match to the children's Object3d.name property.
@@ -1198,6 +1208,8 @@ declare module THREE {
     export class Light extends Object3D {
         constructor(hex?: number);
         color: Color;
+
+        clone(light?: Light): Light;
     }
 
     /**
@@ -1215,6 +1227,8 @@ declare module THREE {
          * @param hex Numeric value of the RGB component of the color.
          */
         constructor(hex?: number);
+
+        clone(): AmbientLight;
     }
 
     export class AreaLight extends Light{
@@ -1405,6 +1419,8 @@ declare module THREE {
          * Default — null.
          */
         shadowMatrix: Matrix4;
+
+        clone(): DirectionalLight;
     }
 
     export class HemisphereLight extends Light {
@@ -1413,6 +1429,8 @@ declare module THREE {
         position: Vector3;
         groundColor: Color;
         intensity: number;
+
+        clone(): HemisphereLight;
     }
 
     /**
@@ -1443,6 +1461,8 @@ declare module THREE {
          * Default — 0.0.
          */
         distance: number;
+
+        clone(): PointLight;
     }
 
     /**
@@ -1563,6 +1583,8 @@ declare module THREE {
         shadowMapSize: Vector2;
         shadowCamera: Camera;
         shadowMap: RenderTarget;
+
+        clone(): SpotLight;
     }
 
     // Loaders //////////////////////////////////////////////////////////////////////////////////
@@ -1630,19 +1652,36 @@ declare module THREE {
         addStatusElement(): HTMLElement;
     }
 
+    export class BufferGeometryLoader {
+        constructor(manager?: LoadingManager);
+
+        load(url: string, onLoad: (bufferGeometry: BufferGeometry) => void): void;
+        setCrossOrigin(crossOrigin: string): void;
+        parse(json: any): BufferGeometry;
+        
+    }
+
+    export class Geometry2Loader {
+        constructor(manager?: LoadingManager);
+
+        load(url: string, onLoad: (geometry2: Geometry2) => void): void;
+        setCrossOrigin(crossOrigin: string): void;
+        parse(json: any): Geometry2;
+    }
+
     /**
      * A loader for loading an image.
      * Unlike other loaders, this one emits events instead of using predefined callbacks. So if you're interested in getting notified when things happen, you need to add listeners to the object.
      */
-    export class ImageLoader extends EventDispatcher {
-        constructor();
+    export class ImageLoader {
+        constructor(manager?: LoadingManager);
         crossOrigin: string;
 
         /**
          * Begin loading from url
          * @param url
          */
-        load(url: string, onLoad?: (event: any) => void, onProgress?: (event: any) => void, onError?: (event: any) => void): HTMLImageElement;
+        load(url: string, onLoad?: (image: HTMLImageElement) => void, onProgress?: (event: any) => void, onError?: (event: any) => void): HTMLImageElement;
         setCrossOrigin(crossOrigin: string): void;
     }
 
@@ -1669,7 +1708,7 @@ declare module THREE {
      * Handles and keeps track of loaded and pending data.
      */
     export class LoadingManager {
-        constructor(onLoad?: (event: any) => void, onProgress?: (event: any) => void, onError?: (event: any) => void);
+        constructor(onLoad?: () => void, onProgress?: (url: string, loaded: number, total: number) => void, onError?: () => void);
 
         /**
          * Will be called when load starts.
@@ -1687,13 +1726,32 @@ declare module THREE {
          * Will be called when each element in the scene completes loading.
          * The default is a function with empty body.
          */
-        onError: (event: () => void) => void;
+        onError: () => void;
 
         itemStart(url: string): void;
         itemEnd(url: string): void;
 
     }
 
+    export class MaterialLoader extends EventDispatcher {
+        constructor(manager?: LoadingManager);
+
+        load(url: string, onLoad: (material: Material) => void): void;
+        setCrossOrigin(crossOrigin: string): void;
+        parse(json: any): Material;
+    }
+    
+    export class ObjectLoader extends EventDispatcher {
+        constructor(manager?: LoadingManager);
+
+        load(url: string, onLoad: (object: Object3D) => void): void;
+        setCrossOrigin(crossOrigin: string): void;
+        parse<T extends Object3D>(json: any): T;
+        parseGeometries(json: any): any[]; // Array of BufferGeometry or Geometry or Geometry2.
+        parseMaterials(json: any): Material[]; // Array of Classes that inherits from Matrial.
+        parseObject<T extends Object3D>(data: any, geometries: any[], materials: Material[]): T;
+    }
+
     interface SceneLoaderResult{
         scene: Scene;
         geometries: {[id:string]:Geometry;};
@@ -1739,7 +1797,6 @@ declare module THREE {
          */
         onLoadComplete: () => void;
 
-
         /**
          * Will be called when load completes.
          * The default is a function with empty body.
@@ -1751,17 +1808,18 @@ declare module THREE {
          * The default is a function with empty body.
          */
         callbackProgress: (progress: SceneLoaderProgress, result: SceneLoaderResult) => void;
-        hierarchyHandlerMap: any;
-        geometryHandlerMap: any;
+        hierarchyHandlers: any;
+        geometryHandlers: any;
 
         /**
          * @param url
          * @param callbackFinished This function will be called with the loaded model as an instance of scene when the load is completed.
          */
-        load(url: string, callbackFinished: (scene: Scene) => void ): void;
-        addHierarchyHandler(typeID: string, loaderClass: Object): void;
+        load(url: string, onLoad: (result: SceneLoaderResult) => void): void;
+        setCrossOrigin(crossOrigin: string): void;
+        addHierarchyHandler(typeID: string, loaderClass: any): void;
         parse(json: any, callbackFinished: (result: SceneLoaderResult) => void, url: string): void;
-        addGeometryHandler(typeID: string, loaderClass: Object): void;
+        addGeometryHandler(typeID: string, loaderClass: any): void;
     }
 
     /**
@@ -1769,14 +1827,28 @@ declare module THREE {
      * Unlike other loaders, this one emits events instead of using predefined callbacks. So if you're interested in getting notified when things happen, you need to add listeners to the object.
      */
     export class TextureLoader extends EventDispatcher {
-        constructor();
+        constructor(manager?: LoadingManager);
         crossOrigin: string;
         /**
          * Begin loading from url
          *
          * @param url
          */
-        load(url: string): void;
+        load(url: string, onLoad: (texture: Texture) => void): void;
+        setCrossOrigin(crossOrigin: string): void;
+    }
+
+    export class XHRLoader extends EventDispatcher {
+        constructor(manager?: LoadingManager);
+        crossOrigin: string;
+        /**
+         * Begin loading from url
+         *
+         * @param url
+         */
+        constructor(onLoad?: (responseText: string) => void, onProgress?: (event: any) => void, onError?: (event: any) => void);
+        load(onLoad?: (responseText: string) => void, onProgress?: (event: any) => void, onError?: (event: any) => void): void;
+        setCrossOrigin(crossOrigin: string): void;
     }
 
     // Materials //////////////////////////////////////////////////////////////////////////////////
@@ -1881,7 +1953,7 @@ declare module THREE {
          */
         needsUpdate: boolean;
 
-        clone(): Material;
+        clone(material?:Material): Material;
 
         dispose(): void;
         setValues(values: Object): void;
@@ -2325,12 +2397,10 @@ declare module THREE {
      * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/math/Color.js">src/math/Color.js</a>
      */
     export class Color {
-        constructor(hex?: string);
-
-        /**
-         * @param hex initial color in hexadecimal
-         */
-        constructor(hex?: number);
+        constructor(color?: Color);
+        constructor(color?: string);
+        constructor(color?: number);
+        constructor(r: number, g: number, b: number);
 
         /**
          * Red channel value between 0 and 1. Default is 1.
@@ -2347,6 +2417,10 @@ declare module THREE {
          */
         b: number;
 
+        set(color: Color): Color;
+        set(color: number): Color;
+        set(color: string): Color;
+
         /**
          * Copies given color.
          * @param color Color to copy.
@@ -2433,9 +2507,6 @@ declare module THREE {
          * Clones this color.
          */
         clone(): Color;
-
-        set(value: number): void;
-        set(value: string): void;
     }
 
     export class Euler {
@@ -3851,6 +3922,8 @@ declare module THREE {
         render(scene: Scene, camera: Camera): void;
         clear(): void;
         setClearColor(color: Color, opacity?: number): void;
+        setClearColor(color: string, opacity?: number): void;
+        setClearColor(color: number, opacity?: number): void;
         setFaceCulling(): void;
         supportsVertexTextures(): void;
         setSize(width: number, height: number, updateStyle?: boolean): void;
@@ -4068,7 +4141,7 @@ declare module THREE {
         /**
          * Resizes the output canvas to (width, height), and also sets the viewport to fit that size, starting in (0, 0).
          */
-        setSize(width: number, height: number): void;
+        setSize(width: number, height: number, updateStyle?: boolean): void;
 
         /**
          * Sets the viewport to render from (x, y) to (x + width, y + height).
@@ -4088,7 +4161,9 @@ declare module THREE {
         /**
          * Sets the clear color, using color for the color and alpha for the opacity.
          */
-        setClearColor(color: Color, alpha: number): void;
+        setClearColor(color: Color, alpha?: number): void;
+        setClearColor(color: string, alpha?: number): void;
+        setClearColor(color: number, alpha?: number): void;
 
         /**
          * Returns a THREE.Color instance with the current clear color.
@@ -4249,7 +4324,7 @@ declare module THREE {
         id: number;
     }
 
-    export class RenderableParticle {
+    export class RenderableSprite {
         constructor();
 
         scale: Vector2;
@@ -4663,22 +4738,18 @@ declare module THREE {
         addToUpdate(animation: Animation): void;
     };
 
-    export class AnimationMorphTarget {
-        constructor(root: Bone, data: any);
-        
-        root: Bone;
-        data: Object;
-        hierarchy: KeyFrames[];
-        currentTime: number;
-        timeScale: number;
-        isPlaying: boolean;
-        isPaused: boolean;
-        loop: boolean;
-        influence: number;
+    export class MorphAnimation {
+        constructor(mesh: Mesh);
 
-        play(loop?: boolean, startTimeMS?: number): void;
+        mesh: Mesh;
+        frames: number;
+        currentTime: number;
+        duration: number;
+        loop: boolean;
+        isPlaying: boolean;
+
+        play(): void;
         pause(): void;
-        stop(): void;
         update(deltaTimeMS: number): void;
     }
 
@@ -4963,15 +5034,6 @@ declare module THREE {
 
 
     // Extras / Geomerties /////////////////////////////////////////////////////////////////////
-
-    export class CircleGeometry extends Geometry {
-        constructor(radius?: number, segments?: number, thetaStart?: number, thetaLength?: number);
-    }
-
-    export class ConvexGeometry extends Geometry {
-        constructor(vertices: Vector3[]);
-    }
-
     /**
      * CubeGeometry is the quadrilateral primitive geometry class. It is typically used for creating a cube or irregular quadrilateral of the dimensions provided within the (optional) 'width', 'height', & 'depth' constructor arguments.
      */
@@ -4987,6 +5049,22 @@ declare module THREE {
         constructor(width: number, height: number, depth: number, widthSegments?: number, heightSegments?: number, depthSegments?: number);
     }
 
+    export class BoxGeometry2 extends Geometry2 {
+        /**
+         * @param width — Width of the sides on the X axis.
+         * @param height — Height of the sides on the Y axis.
+         * @param depth — Depth of the sides on the Z axis.
+         * @param widthSegments — Number of segmented faces along the width of the sides.
+         * @param heightSegments — Number of segmented faces along the height of the sides.
+         * @param depthSegments — Number of segmented faces along the depth of the sides.
+         */
+        constructor(width: number, height: number, depth: number, widthSegments?: number, heightSegments?: number, depthSegments?: number);
+    }
+
+    export class CircleGeometry extends Geometry {
+        constructor(radius?: number, segments?: number, thetaStart?: number, thetaLength?: number);
+    }
+
     export class CubeGeometry extends BoxGeometry {
     }
 
@@ -5030,6 +5108,10 @@ declare module THREE {
         constructor(width: number, height: number, widthSegments?: number, heightSegments?: number);
     }
 
+    export class PlaneGeometry2 extends Geometry2 {
+        constructor(width: number, height: number, widthSegments?: number, heightSegments?: number);
+    }
+
     export class PolyhedronGeometry extends Geometry {
         constructor(vertices: Vector3[], faces: Face[], radius?: number, detail?: number);
     }
@@ -5128,10 +5210,20 @@ declare module THREE {
         constructor(object: Object3D, hex: number);
 
         object: Object3D;
-        box: Box3;
+        vertices: Vector3[];
 
         update(): void;
     }
+
+    export class BoxHelper extends Line {
+        constructor(object: Object3D);
+
+        object: Object3D;
+        box: Box3;
+
+        update(object?: Object3D): void;
+    }
+
     export class CameraHelper extends Line {
         constructor(camera: Camera);
 
@@ -5151,6 +5243,23 @@ declare module THREE {
         update(): void;
     }
 
+    export class EdgesHelper extends Line {
+        constructor(object: Object3D, hex?: number);
+
+        matrixAutoUpdate: boolean;
+        matrixWorld: Matrix4;
+    }
+
+    export class FaceNormalsHelper extends Line {
+        constructor(object: Object3D, size?: number, hex?: number, linewidth?: number);
+
+        size: number;
+        matrixAutoUpdate: boolean;
+        normalMatrix: Matrix3;
+
+        update(object?: Object3D): void;
+    }
+
     export class GridHelper extends Line {
         constructor(size: number, step: number);
 
@@ -5184,6 +5293,32 @@ declare module THREE {
         update(): void;
     }
 
+    export class VertexNormalsHelper extends Line {
+        constructor(object: Object3D, size?: number, hex?: number, linewidth?: number);
+
+        size: number;
+        matrixAutoUpdate: boolean;
+        normalMatrix: Matrix3;
+
+        update(object?: Object3D): void;
+    }
+
+    export class VertexTangentsHelper extends Line {
+        constructor(object: Object3D, size?: number, hex?: number, linewidth?: number);
+
+        size: number;
+        matrixAutoUpdate: boolean;
+
+        update(object?: Object3D): void;
+    }
+
+    export class WireframeHelper extends Line {
+        constructor(object: Object3D, hex?: number);
+
+        matrixAutoUpdate: boolean;
+        matrixWorld: Matrix4;
+    }
+
     // Extras / Objects /////////////////////////////////////////////////////////////////////
 
     export class ImmediateRenderObject extends Object3D {

From ac22449387f3b4caeba7593e096137a55fa8ed81 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=A1clav=20Oborn=C3=ADk?= <register.ufon@gmail.com>
Date: Sat, 8 Mar 2014 15:38:17 +0100
Subject: [PATCH 056/309] added 'next' interface, route binding methods can
 have multiple request handlers and accepts arrays of handlers

---
 restify/restify.d.ts | 43 ++++++++++++++++++++++++++++++++++++-------
 1 file changed, 36 insertions(+), 7 deletions(-)

diff --git a/restify/restify.d.ts b/restify/restify.d.ts
index 40bc8b4a3..7a01a4c61 100644
--- a/restify/restify.d.ts
+++ b/restify/restify.d.ts
@@ -52,12 +52,37 @@ declare module "restify" {
 
   interface Server extends http.Server {
     use: (... handler: any[]) => any;
-    post: (route: any, routeCallBack: RequestHandler) => any;
-    patch: (route: any, routeCallBack: RequestHandler) => any;
-    put: (route: any, routeCallBack: RequestHandler) => any;
-    del: (route: any, routeCallBack: RequestHandler) => any;
-    get: (route: any, routeCallBack: RequestHandler) => any;
-    head: (route: any, routeCallBack: RequestHandler) => any;
+
+    post(route: any, routeCallBack: RequestHandler, ...routeCallBacks: RequestHandler[]): any;
+    post(route: any, routeCallBack: RequestHandler[], ...routeCallBacks: RequestHandler[]): any;
+    post(route: any, routeCallBack: RequestHandler, ...routeCallBacks: RequestHandler[][]): any;
+    post(route: any, routeCallBack: RequestHandler[], ...routeCallBacks: RequestHandler[][]): any;
+
+    patch(route: any, routeCallBack: RequestHandler, ...routeCallBacks: RequestHandler[]): any;
+    patch(route: any, routeCallBack: RequestHandler[], ...routeCallBacks: RequestHandler[]): any;
+    patch(route: any, routeCallBack: RequestHandler, ...routeCallBacks: RequestHandler[][]): any;
+    patch(route: any, routeCallBack: RequestHandler[], ...routeCallBacks: RequestHandler[][]): any;
+
+    put(route: any, routeCallBack: RequestHandler, ...routeCallBacks: RequestHandler[]): any;
+    put(route: any, routeCallBack: RequestHandler[], ...routeCallBacks: RequestHandler[]): any;
+    put(route: any, routeCallBack: RequestHandler, ...routeCallBacks: RequestHandler[][]): any;
+    put(route: any, routeCallBack: RequestHandler[], ...routeCallBacks: RequestHandler[][]): any;
+
+    del(route: any, routeCallBack: RequestHandler, ...routeCallBacks: RequestHandler[]): any;
+    del(route: any, routeCallBack: RequestHandler[], ...routeCallBacks: RequestHandler[]): any;
+    del(route: any, routeCallBack: RequestHandler, ...routeCallBacks: RequestHandler[][]): any;
+    del(route: any, routeCallBack: RequestHandler[], ...routeCallBacks: RequestHandler[][]): any;
+
+    get(route: any, routeCallBack: RequestHandler, ...routeCallBacks: RequestHandler[]): any;
+    get(route: any, routeCallBack: RequestHandler[], ...routeCallBacks: RequestHandler[]): any;
+    get(route: any, routeCallBack: RequestHandler, ...routeCallBacks: RequestHandler[][]): any;
+    get(route: any, routeCallBack: RequestHandler[], ...routeCallBacks: RequestHandler[][]): any;
+
+    head(route: any, routeCallBack: RequestHandler, ...routeCallBacks: RequestHandler[]): any;
+    head(route: any, routeCallBack: RequestHandler[], ...routeCallBacks: RequestHandler[]): any;
+    head(route: any, routeCallBack: RequestHandler, ...routeCallBacks: RequestHandler[][]): any;
+    head(route: any, routeCallBack: RequestHandler[], ...routeCallBacks: RequestHandler[][]): any;
+
     name: string;
     version: string;
     log: Object;
@@ -124,8 +149,12 @@ declare module "restify" {
     overrides?: Object;
   }
 
+  interface next {
+    (err?: any): any;
+  }
+
   interface RequestHandler {
-    (req: Request, res: Response, next: Function): any;
+    (req: Request, res: Response, next: next): any;
   }
 
   export function createServer(options?: ServerOptions): Server;

From 5eaf82aa6a8ecba0a9da289036bacc1c32bb92f0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=A1clav=20Oborn=C3=ADk?= <register.ufon@gmail.com>
Date: Sat, 8 Mar 2014 15:50:08 +0100
Subject: [PATCH 057/309] method Server.use can accept arrays of
 RequestHandlers

---
 restify/restify.d.ts | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/restify/restify.d.ts b/restify/restify.d.ts
index 7a01a4c61..ca047e17d 100644
--- a/restify/restify.d.ts
+++ b/restify/restify.d.ts
@@ -51,7 +51,10 @@ declare module "restify" {
   }
 
   interface Server extends http.Server {
-    use: (... handler: any[]) => any;
+    use(handler: RequestHandler, ...handlers: RequestHandler[]): any;
+    use(handler: RequestHandler[], ...handlers: RequestHandler[]): any;
+    use(handler: RequestHandler, ...handlers: RequestHandler[][]): any;
+    use(handler: RequestHandler[], ...handlers: RequestHandler[][]): any;
 
     post(route: any, routeCallBack: RequestHandler, ...routeCallBacks: RequestHandler[]): any;
     post(route: any, routeCallBack: RequestHandler[], ...routeCallBacks: RequestHandler[]): any;
@@ -89,9 +92,9 @@ declare module "restify" {
     acceptable: string[];
     url: string;
     address: () => addressInterface;
-    listen: (... args: any[]) => any;
-    close: (... args: any[]) => any;
-    pre: (routeCallBack: RequestHandler) => any;
+    listen(... args: any[]): any;
+    close(... args: any[]): any;
+    pre(routeCallBack: RequestHandler): any;
 
   }
 

From 5e338fd078925201041ed0fa75a461e630412330 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Thu, 20 Feb 2014 00:39:06 +0100
Subject: [PATCH 058/309] first pass at making bluebird promise definitions
 generic

! not ready to merge !

definitions and tests should have all the methods, but:
 * some missing overloads
 * some problematic members
 * some members or tests commented out
---
 bluebird/bluebird.d.ts | 1062 +++++++++++++++++++++++-----------------
 1 file changed, 612 insertions(+), 450 deletions(-)

diff --git a/bluebird/bluebird.d.ts b/bluebird/bluebird.d.ts
index 5db21d63e..ba5c60ded 100644
--- a/bluebird/bluebird.d.ts
+++ b/bluebird/bluebird.d.ts
@@ -1,499 +1,661 @@
 // Type definitions for bluebird 1.0.0
 // Project: https://github.com/petkaantonov/bluebird
 // Definitions by: Bart van der Schoor <https://github.com/Bartvds>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-// Note: these are preliminary non-generic typings using `any`: the generic versions are ready but need (tsc >= v1.0.0) due to issues in the compiler
-// - https://github.com/borisyankov/DefinitelyTyped/issues/1563
-// - https://github.com/borisyankov/DefinitelyTyped/tree/def/bluebird/bluebird
+// ES6 model with generics overload was sourced and trans-multiplied from es6-promises.d.ts
+// By: Campredon <https://github.com/fdecampredon/>
+// By: Igorbek <https://github.com/Igorbek/>
 
-declare class Promise {
-	/**
-	 * Create a new promise. The passed in function will receive functions `resolve` and `reject` as its arguments which can be called to seal the fate of the created promise.
-	 */
-	constructor(resolver: (resolve: (value: any) => void, reject: (reason: any) => any) => void);
-	/**
-	 * Promises/A+ `.then()` with progress handler. Returns a new promise chained from this promise. The new promise will be rejected or resolved dedefer on the passed `fulfilledHandler`, `rejectedHandler` and the state of this promise.
-	 */
-	then(fulfilledHandler?: (value: any) => any, rejectedHandler?: (reason: any) => any, progressHandler?: (note: any) => any):Promise;
+// Note: replicate changes to all overloads in both definition and test file
+// Note: keep both static and instance members inline (so similar)
 
-	/**
-	 * This is a catch-all exception handler, shortcut for calling `.then(null, handler)` on this promise. Any exception happening in a `.then`-chain will propagate to nearest `.catch` handler.
-	 *
-	 * Alias `.caught();` for compatibility with earlier ECMAScript version.
-	 */
-	catch(handler: (reason: any) => any):Promise;
-	caught(handler: (reason: any) => any):Promise;
+//TODO fix all TODO annotations in the file
 
-	/**
-	 * This extends `.catch` to work more like catch-clauses in languages like Java or C#. Instead of manually checking `instanceof` or `.name === "SomeError"`, you may specify a number of error constructors which are eligible for this catch handler. The catch handler that is first met that has eligible constructors specified, is the one that will be called.
-	 *
-	 * This method also supports predicate-based filters. If you pass a predicate function instead of an error constructor, the predicate will receive the error as an argument. The return result of the predicate will be used determine whether the error handler should be called.
-	 *
-	 * Alias `.caught();` for compatibility with earlier ECMAScript version.
-	 */
-		//TODO expand this complex overload (weird)
-	catch(predicate: (reason: any) => boolean, handler: (reason: any) => any): Promise;
-	caught(predicate: (reason: any) => boolean, handler: (reason: any) => any): Promise;
+//TODO support to have no return statement in handlers to get a Promise<void> (more overloads?)
 
-	catch(ErrorClass: Function, handler: (reason: any) => any): Promise;
-	caught(ErrorClass: Function, handler: (reason: any) => any): Promise;
-
-	/**
-	 * Like `.catch` but instead of catching all types of exceptions, it only catches those that don't originate from thrown errors but rather from explicit rejections.
-	 */
-	error(rejectedHandler: (reason: any) => any): Promise;
-
-	/**
-	 * Pass a handler that will be called regardless of this promise's fate. Returns a new promise chained from this promise. There are special semantics for `.finally()` in that the final value cannot be modified from the handler.
-	 *
-	 * Alias `.lastly();` for compatibility with earlier ECMAScript version.
-	 */
-	finally(handler: (value: any) => any): Promise;
-	lastly(handler: (value: any) => any): Promise;
-
-	/**
-	 * Create a promise that follows this promise, but is bound to the given `thisArg` value. A bound promise will call its handlers with the bound value set to `this`. Additionally promises derived from a bound promise will also be bound promises with the same `thisArg` binding as the original promise.
-	 */
-	bind(thisArg: any): Promise;
-
-	/**
-	 * Like `.then()`, but any unhandled rejection that ends up here will be thrown as an error.
-	 */
-	done(fulfilledHandler?: (value: any) => any, rejectedHandler?: (reason: any) => any, progressHandler?: (note: any) => any): Promise;
-
-	/**
-	 * Shorthand for `.then(null, null, handler);`. Attach a progress handler that will be called if this promise is progressed. Returns a new promise chained from this promise.
-	 */
-	progressed(handler: (note: any) => any): Promise;
-
-	/**
-	 * Same as calling `Promise.delay(this, ms)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-	 */
-	delay(ms: number): Promise;
-
-	/**
-	 * Returns a promise that will be fulfilled with this promise's fulfillment value or rejection reason. However, if this promise is not fulfilled or rejected within `ms` milliseconds, the returned promise is rejected with a `Promise.TimeoutError` instance.
-	 *
-	 * You may specify a custom error message with the `message` parameter.
-	 */
-
-	timeout(ms: number, message?: string): Promise;
-
-	/**
-	 * Register a node-style callback on this promise. When this promise is is either fulfilled or rejected, the node callback will be called back with the node.js convention where error reason is the first argument and success value is the second argument. The error argument will be `null` in case of success.
-	 * Returns back this promise instead of creating a new one. If the `callback` argument is not a function, this method does not do anything.
-	 */
-	nodeify(callback?: Function): Promise;
-
-	/**
-	 * Marks this promise as cancellable. Promises by default are not cancellable after v0.11 and must be marked as such for `.cancel()` to have any effect. Marking a promise as cancellable is infectious and you don't need to remark any descendant promise.
-	 */
-	cancellable(): Promise;
-
-	/**
-	 * Cancel this promise. The cancellation will propagate to farthest cancellable ancestor promise which is still pending.
-	 *
-	 * That ancestor will then be rejected with a `CancellationError` (get a reference from `Promise.CancellationError`) object as the rejection reason.
-	 *
-	 * In a promise rejection handler you may check for a cancellation by seeing if the reason object has `.name === "Cancel"`.
-	 *
-	 * Promises are by default not cancellable. Use `.cancellable()` to mark a promise as cancellable.
-	 */
-	cancel(): Promise;
-
-	/**
-	 * Like `.then()`, but cancellation of the the returned promise or any of its descendant will not propagate cancellation to this promise or this promise's ancestors.
-	 */
-	fork(fulfilledHandler?: (value: any) => any, rejectedHandler?: (reason: any) => any, progressHandler?: (note: any) => any): Promise;
-
-	/**
-	 * Create an uncancellable promise based on this promise.
-	 */
-	uncancellable(): Promise;
-
-	/**
-	 * See if this promise can be cancelled.
-	 */
-	isCancellable(): boolean;
-
-	/**
-	 * See if this `promise` has been fulfilled.
-	 */
-	isFulfilled(): boolean;
-
-	/**
-	 * See if this `promise` has been rejected.
-	 */
-	isRejected(): boolean;
-
-	/**
-	 * See if this `promise` is still defer.
-	 */
-	isPending(): boolean;
-
-	/**
-	 * See if this `promise` is resolved -> either fulfilled or rejected.
-	 */
-	isResolved(): boolean;
-
-	/**
-	 * Synchronously inspect the state of this `promise`. The `Promise.Inspection` will represent the state of the promise as snapshotted at the time of calling `.inspect()`.
-	 */
-	inspect(): Promise.Inspection;
-
-	/**
-	 * This is a convenience method for doing:
-	 *
-	 * <code>
-	 * promise.then(function(obj){
-	 *     return obj[propertyName].call(obj, arg...);
-	 * });
-	 * </code>
-	 */
-	call(propertyName: string, ...args: any[]): Promise;
-
-	/**
-	 * This is a convenience method for doing:
-	 *
-	 * <code>
-	 * promise.then(function(obj){
-	 *     return obj[propertyName];
-	 * });
-	 * </code>
-	 */
-	get(propertyName: string): Promise;
-
-	/**
-	 * Convenience method for:
-	 *
-	 * <code>
-	 * .then(function() {
-	 *    return value;
-	 * });
-	 * </code>
-	 *
-	 * in the case where `value` doesn't change its value. That means `value` is bound at the time of calling `.return()`
-	 *
-	 * Alias `.thenReturn();` for compatibility with earlier ECMAScript version.
-	 */
-	return(value: any): Promise;
-	thenReturn(): Promise;
-
-	/**
-	 * Convenience method for:
-	 *
-	 * <code>
-	 * .then(function() {
-	 *    throw reason;
-	 * });
-	 * </code>
-	 * Same limitations apply as with `.return()`.
-	 *
-	 * Alias `.thenThrow();` for compatibility with earlier ECMAScript version.
-	 */
-	throw(reason: any): Promise;
-	thenThrow(): Promise;
-
-	/**
-	 * Convert to String.
-	 */
-	toString(): string;
-
-	/**
-	 * This is implicitly called by `JSON.stringify` when serializing the object. Returns a serialized representation of the `Promise`.
-	 */
-	toJSON(): Object;
-
-	/**
-	 * Same as calling `Promise.all(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-	 */
-	all(): Promise;
-
-	/**
-	 * Same as calling `Promise.props(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-	 */
-	props(): Promise;
-
-	/**
-	 * Same as calling `Promise.settle(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-	 */
-	settle(): Promise;
-
-	/**
-	 * Same as calling `Promise.any(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-	 */
-	any(): Promise;
-
-	/**
-	 * Same as calling `Promise.race(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-	 */
-	some(count: number): Promise;
-
-	/**
-	 * Same as calling `Promise.some(thisPromise, count)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-	 */
-	race(): Promise;
-
-	/**
-	 * Like calling `.then`, but the fulfillment value or rejection reason is assumed to be an array, which is flattened to the formal parameters of the handlers.
-	 */
-	spread(fulfilledHandler?: (value: any) => any, rejectedHandler?: (reason: any) => any): Promise;
-
-	/**
-	 * Same as calling `Promise.map(thisPromise, mapper)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-	 */
-	map(mapper: (item: any, index: number, arrayLength: number) => any): Promise;
-
-	/**
-	 * Same as calling `Promise.reduce(thisPromise, Function reducer, initialValue)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-	 */
-	reduce(reducer: (total: number, current: any, index: number, arrayLength: number) => any, initialValue?: any): Promise;
-
-	/**
-	 * Same as calling ``Promise.filter(thisPromise, filterer)``. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-	 */
-	filter(filterer: (item: any, index: number, arrayLength: number) => any): Promise;
+interface Thenable<R> {
+    then<U>(onFulfilled:(value:R) => Thenable<U>, onRejected:(error:any) => Thenable<U>): Thenable<U>;
+    then<U>(onFulfilled:(value:R) => Thenable<U>, onRejected?:(error:any) => U): Thenable<U>;
+    then<U>(onFulfilled:(value:R) => U, onRejected:(error:any) => Thenable<U>): Thenable<U>;
+    then<U>(onFulfilled?:(value:R) => U, onRejected?:(error:any) => U): Thenable<U>;
 }
 
+interface ArrayLike {
+    length:number;
+}
+
+declare class Promise<R> implements Thenable<R> {
+    /**
+     * Create a new promise. The passed in function will receive functions `resolve` and `reject` as its arguments which can be called to seal the fate of the created promise.
+     */
+    constructor(callback:(resolve:(result:R) => void, reject:(error:any) => void) => void);
+    constructor(callback:(resolve:(thenable:Thenable<R>) => void, reject:(error:any) => void) => void);
+
+    /**
+     * Promises/A+ `.then()` with progress handler. Returns a new promise chained from this promise. The new promise will be rejected or resolved dedefer on the passed `fulfilledHandler`, `rejectedHandler` and the state of this promise.
+     */
+    then<U>(onFulfill:(value:R) => Thenable<U>, onReject:(error:any) => Thenable<U>, onProgress?:(note:any) => any):Promise<U>;
+    then<U>(onFulfill:(value:R) => Thenable<U>, onReject?:(error:any) => U, onProgress?:(note:any) => any):Promise<U>;
+    then<U>(onFulfill:(value:R) => U, onReject:(error:any) => Thenable<U>, onProgress?:(note:any) => any):Promise<U>;
+    then<U>(onFulfill?:(value:R) => U, onReject?:(error:any) => U, onProgress?:(note:any) => any):Promise<U>;
+
+    /**
+     * This is a catch-all exception handler, shortcut for calling `.then(null, handler)` on this promise. Any exception happening in a `.then`-chain will propagate to nearest `.catch` handler.
+     *
+     * Alias `.caught();` for compatibility with earlier ECMAScript version.
+     */
+    catch<U>(onReject?:(error:any) => Thenable<U>):Promise<U>;
+    caught<U>(onReject?:(error:any) => Thenable<U>):Promise<U>;
+
+    catch<U>(onReject?:(error:any) => U):Promise<U>;
+    caught<U>(onReject?:(error:any) => U):Promise<U>;
+
+    /**
+     * This extends `.catch` to work more like catch-clauses in languages like Java or C#. Instead of manually checking `instanceof` or `.name === "SomeError"`, you may specify a number of error constructors which are eligible for this catch handler. The catch handler that is first met that has eligible constructors specified, is the one that will be called.
+     *
+     * This method also supports predicate-based filters. If you pass a predicate function instead of an error constructor, the predicate will receive the error as an argument. The return result of the predicate will be used determine whether the error handler should be called.
+     *
+     * Alias `.caught();` for compatibility with earlier ECMAScript version.
+     */
+    catch<U>(predicate:(error:any) => boolean, onReject:(error:any) => Thenable<U>):Promise<U>;
+    caught<U>(predicate:(error:any) => boolean, onReject:(error:any) => Thenable<U>):Promise<U>;
+
+    catch<U>(predicate:(error:any) => boolean, onReject:(error:any) => U):Promise<U>;
+    caught<U>(predicate:(error:any) => boolean, onReject:(error:any) => U):Promise<U>;
+
+    catch<U>(ErrorClass:Function, onReject:(error:any) => Thenable<U>):Promise<U>;
+    caught<U>(ErrorClass:Function, onReject:(error:any) => Thenable<U>):Promise<U>;
+
+    catch<U>(ErrorClass:Function, onReject:(error:any) => U):Promise<U>;
+    caught<U>(ErrorClass:Function, onReject:(error:any) => U):Promise<U>;
+
+    /**
+     * Like `.catch` but instead of catching all types of exceptions, it only catches those that don't originate from thrown errors but rather from explicit rejections.
+     */
+    error<U>(onReject:(reason:any) => Thenable<U>):Promise<U>;
+    error<U>(onReject:(reason:any) => U):Promise<U>;
+
+    /**
+     * Pass a handler that will be called regardless of this promise's fate. Returns a new promise chained from this promise. There are special semantics for `.finally()` in that the final value cannot be modified from the handler.
+     *
+     * Alias `.lastly();` for compatibility with earlier ECMAScript version.
+     */
+    finally(handler:(value:R) => Thenable<R>):Promise<R>;
+    finally(handler:(value:R) => R):Promise<R>;
+
+    lastly(handler:(value:R) => Thenable<R>):Promise<R>;
+    lastly(handler:(value:R) => R):Promise<R>;
+
+    /**
+     * Create a promise that follows this promise, but is bound to the given `thisArg` value. A bound promise will call its handlers with the bound value set to `this`. Additionally promises derived from a bound promise will also be bound promises with the same `thisArg` binding as the original promise.
+     */
+    bind(thisArg:any):Promise<R>;
+
+    /**
+     * Like `.then()`, but any unhandled rejection that ends up here will be thrown as an error.
+     */
+    done<U>(onFulfilled:(value:R) => Thenable<U>, onRejected:(error:any) => Thenable<U>, onProgress?:(note:any) => any):Promise<U>;
+    done<U>(onFulfilled:(value:R) => Thenable<U>, onRejected?:(error:any) => U, onProgress?:(note:any) => any):Promise<U>;
+    done<U>(onFulfilled:(value:R) => U, onRejected:(error:any) => Thenable<U>, onProgress?:(note:any) => any):Promise<U>;
+    done<U>(onFulfilled?:(value:R) => U, onRejected?:(error:any) => U, onProgress?:(note:any) => any):Promise<U>;
+
+    /**
+     * Shorthand for `.then(null, null, handler);`. Attach a progress handler that will be called if this promise is progressed. Returns a new promise chained from this promise.
+     */
+    progressed(handler:(note:any) => any):Promise<R>;
+
+    /**
+     * Same as calling `Promise.delay(this, ms)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    delay(ms:number):Promise<R>;
+
+    /**
+     * Returns a promise that will be fulfilled with this promise's fulfillment value or rejection reason. However, if this promise is not fulfilled or rejected within `ms` milliseconds, the returned promise is rejected with a `Promise.TimeoutError` instance.
+     *
+     * You may specify a custom error message with the `message` parameter.
+     */
+    timeout(ms:number, message?:string):Promise<R>;
+
+    /**
+     * Register a node-style callback on this promise. When this promise is is either fulfilled or rejected, the node callback will be called back with the node.js convention where error reason is the first argument and success value is the second argument. The error argument will be `null` in case of success.
+     * Returns back this promise instead of creating a new one. If the `callback` argument is not a function, this method does not do anything.
+     */
+    nodeify(callback:(err:any, value?:R) => void):Promise<R>;
+    nodeify(...sink:any[]):void;
+
+    /**
+     * Marks this promise as cancellable. Promises by default are not cancellable after v0.11 and must be marked as such for `.cancel()` to have any effect. Marking a promise as cancellable is infectious and you don't need to remark any descendant promise.
+     */
+    cancellable():Promise<R>;
+
+    /**
+     * Cancel this promise. The cancellation will propagate to farthest cancellable ancestor promise which is still pending.
+     *
+     * That ancestor will then be rejected with a `CancellationError` (get a reference from `Promise.CancellationError`) object as the rejection reason.
+     *
+     * In a promise rejection handler you may check for a cancellation by seeing if the reason object has `.name === "Cancel"`.
+     *
+     * Promises are by default not cancellable. Use `.cancellable()` to mark a promise as cancellable.
+     */
+    //TODO what to do with this?
+    cancel<U>():Promise<U>;
+
+    /**
+     * Like `.then()`, but cancellation of the the returned promise or any of its descendant will not propagate cancellation to this promise or this promise's ancestors.
+     */
+    fork<U>(onFulfilled:(value:R) => Thenable<U>, onRejected:(error:any) => Thenable<U>, onProgress?:(note:any) => any):Promise<U>;
+    fork<U>(onFulfilled:(value:R) => Thenable<U>, onRejected?:(error:any) => U, onProgress?:(note:any) => any):Promise<U>;
+    fork<U>(onFulfilled:(value:R) => U, onRejected:(error:any) => Thenable<U>, onProgress?:(note:any) => any):Promise<U>;
+    fork<U>(onFulfilled?:(value:R) => U, onRejected?:(error:any) => U, onProgress?:(note:any) => any):Promise<U>;
+
+    /**
+     * Create an uncancellable promise based on this promise.
+     */
+    uncancellable():Promise<R>;
+
+    /**
+     * See if this promise can be cancelled.
+     */
+    isCancellable():boolean;
+
+    /**
+     * See if this `promise` has been fulfilled.
+     */
+    isFulfilled():boolean;
+
+    /**
+     * See if this `promise` has been rejected.
+     */
+    isRejected():boolean;
+
+    /**
+     * See if this `promise` is still defer.
+     */
+    isPending():boolean;
+
+    /**
+     * See if this `promise` is resolved -> either fulfilled or rejected.
+     */
+    isResolved():boolean;
+
+    /**
+     * Synchronously inspect the state of this `promise`. The `PromiseInspection` will represent the state of the promise as snapshotted at the time of calling `.inspect()`.
+     */
+    inspect():PromiseInspection<R>;
+
+    /**
+     * This is a convenience method for doing:
+     *
+     * <code>
+     * promise.then(function(obj){
+    *     return obj[propertyName].call(obj, arg...);
+    * });
+     * </code>
+     */
+    call(propertyName:string, ...args:any[]):Promise<any>;
+
+    /**
+     * This is a convenience method for doing:
+     *
+     * <code>
+     * promise.then(function(obj){
+    *     return obj[propertyName];
+    * });
+     * </code>
+     */
+    //TODO find way to fix get()
+    // get<U>(propertyName:string):Promise<U>;
+
+    /**
+     * Convenience method for:
+     *
+     * <code>
+     * .then(function() {
+    *    return value;
+    * });
+     * </code>
+     *
+     * in the case where `value` doesn't change its value. That means `value` is bound at the time of calling `.return()`
+     *
+     * Alias `.thenReturn();` for compatibility with earlier ECMAScript version.
+     */
+    return<U>(value?:U):Promise<U>;
+    thenReturn<U>(value?:U):Promise<U>;
+
+    /**
+     * Convenience method for:
+     *
+     * <code>
+     * .then(function() {
+    *    throw reason;
+    * });
+     * </code>
+     * Same limitations apply as with `.return()`.
+     *
+     * Alias `.thenThrow();` for compatibility with earlier ECMAScript version.
+     */
+    throw(reason:any):Promise<R>;
+    thenThrow(reason:any):Promise<R>;
+
+    /**
+     * Convert to String.
+     */
+    toString():string;
+
+    /**
+     * This is implicitly called by `JSON.stringify` when serializing the object. Returns a serialized representation of the `Promise`.
+     */
+    toJSON():Object;
+
+    /**
+     * Like calling `.then`, but the fulfillment value or rejection reason is assumed to be an array, which is flattened to the formal parameters of the handlers.
+     */
+    //TODO how to model instance.spread()?
+    // like Q?
+    //spread<U>(onFulfilled: Function, onRejected: Function): Promise<U>;
+    /*
+    spread<U, W>(onFulfill:(...values:W[]) => Thenable<U>, onReject?:(reason:any) => Thenable<U>):Promise<U>;
+    spread<U, W>(onFulfill:(...values:W[]) => Thenable<U>, onReject?:(reason:any) => U):Promise<U>;
+    spread<U, W>(onFulfill:(...values:W[]) => U, onReject?:(reason:any) => Thenable<U>):Promise<U>;
+    spread<U, W>(onFulfill:(...values:W[]) => U, onReject?:(reason:any) => U):Promise<U>;
+    */
+    /**
+     * Same as calling `Promise.all(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    //TODO how to model instance.all()?
+    all<U>():Promise<U[]>;
+
+    /**
+     * Same as calling `Promise.props(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    //TODO how to model instance.props()?
+    props():Promise<Object>;
+
+    /**
+     * Same as calling `Promise.settle(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    //TODO how to model instance.settle()?
+    settle<U>():Promise<PromiseInspection<U>[]>;
+
+    /**
+     * Same as calling `Promise.any(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    //TODO how to model instance.any()?
+    any<U>():Promise<U>;
+
+    /**
+     * Same as calling `Promise.some(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    //TODO how to model instance.some()?
+    some<U>(count:number):Promise<U[]>;
+
+    /**
+     * Same as calling `Promise.race(thisPromise, count)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    //TODO how to model instance.race()?
+    race<U>():Promise<U>;
+
+    /**
+     * Same as calling `Promise.map(thisPromise, mapper)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    //TODO how to model instance.map()?
+    map<U>(mapper:(item:R, index:number, arrayLength:number) => Thenable<U>):Promise<U>;
+    map<U>(mapper:(item:R, index:number, arrayLength:number) => U):Promise<U>;
+
+    /**
+     * Same as calling `Promise.reduce(thisPromise, Function reducer, initialValue)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    //TODO how to model instance.reduce()?
+    reduce<U>(reducer:(total:number, current:R, index:number, arrayLength:number) => Thenable<U>, initialValue?:any):Promise<U>;
+    reduce<U>(reducer:(total:number, current:R, index:number, arrayLength:number) => U, initialValue?:any):Promise<U>;
+
+    /**
+     * Same as calling ``Promise.filter(thisPromise, filterer)``. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    //TODO how to model instance.filter()?
+    filter<U>(filterer:(item:R, index:number, arrayLength:number) => Thenable<U>):Promise<U>;
+    filter<U>(filterer:(item:R, index:number, arrayLength:number) => U):Promise<U>;
+}
+
+interface PromiseResolver<R> {
+    /**
+     * Resolve the underlying promise with `value` as the resolution value. If `value` is a thenable or a promise, the underlying promise will assume its state.
+     */
+    resolve(value:R):void;
+
+    /**
+     * Reject the underlying promise with `reason` as the rejection reason.
+     */
+    reject(reason:any):void;
+
+    /**
+     * Progress the underlying promise with `value` as the progression value.
+     */
+    progress(value:any):void;
+
+    /**
+     * Gives you a callback representation of the `PromiseResolver`. Note that this is not a method but a property. The callback accepts error object in first argument and success values on the 2nd parameter and the rest, I.E. node js conventions.
+     *
+     * If the the callback is called with multiple success values, the resolver fullfills its promise with an array of the values.
+     */
+    //TODO specify resolver callback
+    callback:Function;
+}
+
+interface PromiseInspection<R> {
+    /**
+     * See if the underlying promise was fulfilled at the creation time of this inspection object.
+     */
+    isFulfilled():boolean;
+
+    /**
+     * See if the underlying promise was rejected at the creation time of this inspection object.
+     */
+    isRejected():boolean;
+
+    /**
+     * See if the underlying promise was defer at the creation time of this inspection object.
+     */
+    isPending():boolean;
+
+    /**
+     * Get the fulfillment value of the underlying promise. Throws if the promise wasn't fulfilled at the creation time of this inspection object.
+     *
+     * throws `TypeError`
+     */
+    value():R;
+
+    /**
+     * Get the rejection reason for the underlying promise. Throws if the promise wasn't rejected at the creation time of this inspection object.
+     *
+     * throws `TypeError`
+     */
+    error():any;
+}
 declare module Promise {
+    /**
+     * Start the chain of promises with `Promise.try`. Any synchronous exceptions will be turned into rejections on the returned promise.
+     *
+     * Note about second argument: if it's specifically a true array, its values become respective arguments for the function call. Otherwise it is passed as is as the first argument for the function call.
+     *
+     * Alias for `attempt();` for compatibility with earlier ECMAScript version.
+     */
+    //TODO find way to enable try() without tsc borking
+    // see also: https://typescript.codeplex.com/workitem/2194
+    /*
+    function try<R>(fn:() => Thenable<R>, args?:any[], ctx?:any):Promise<R>;
+    function try<R>(fn:() => R, args?:any[], ctx?:any):Promise<R>;
+    // custom array-like
+    function try<R>(fn:() => Thenable<R>, args?:ArrayLike, ctx?:any):Promise<R>;
+    function try<R>(fn:() => R, args?:ArrayLike, ctx?:any):Promise<R>;
+    */
 
-	interface Resolver {
-		/**
-		 * Resolve the underlying promise with `value` as the resolution value. If `value` is a thenable or a promise, the underlying promise will assume its state.
-		 */
-		resolve(value: any): void;
+    function attempt<R>(fn:() => Thenable<R>, args?:any[], ctx?:any):Promise<R>;
+    function attempt<R>(fn:() => R, args?:any[], ctx?:any):Promise<R>;
+    // custom array-like
+    function attempt<R>(fn:() => Thenable<R>, args?:ArrayLike, ctx?:any):Promise<R>;
+    function attempt<R>(fn:() => R, args?:ArrayLike, ctx?:any):Promise<R>;
 
-		/**
-		 * Reject the underlying promise with `reason` as the rejection reason.
-		 */
-		reject(reason: any): void;
+    /**
+     * Returns a new function that wraps the given function `fn`. The new function will always return a promise that is fulfilled with the original functions return values or rejected with thrown exceptions from the original function.
+     * This method is convenient when a function can sometimes return synchronously or throw synchronously.
+     */
+    function method(fn:Function):Function;
 
-		/**
-		 * Progress the underlying promise with `value` as the progression value.
-		 */
-		progress(value: any): void;
+    /**
+     * Create a promise that is resolved with the given `value`. If `value` is a thenable or promise, the returned promise will assume its state.
+     */
+    function resolve<R>(value:Thenable<R>):Promise<R>;
+    function resolve<R>(value:R):Promise<R>;
 
-		/**
-		 * Gives you a callback representation of the `Promise.Resolver`. Note that this is not a method but a property. The callback accepts error object in first argument and success values on the 2nd parameter and the rest, I.E. node js conventions.
-		 *
-		 * If the the callback is called with multiple success values, the resolver fullfills its promise with an array of the values.
-		 */
-		callback:Function;
-	}
+    /**
+     * Create a promise that is rejected with the given `reason`.
+     */
+    function reject(reason:any):Promise<void>;
 
-	interface Inspection {
-		/**
-		 * See if the underlying promise was fulfilled at the creation time of this inspection object.
-		 */
-		isFulfilled(): boolean;
+    /**
+     * Create a promise with undecided fate and return a `PromiseResolver` to control it. See resolution?:Promise(#promise-resolution).
+     */
+    function defer<R>():PromiseResolver<R>;
 
-		/**
-		 * See if the underlying promise was rejected at the creation time of this inspection object.
-		 */
-		isRejected(): boolean;
+    /**
+     * Cast the given `value` to a trusted promise. If `value` is already a trusted `Promise`, it is returned as is. If `value` is not a thenable, a fulfilled is:Promise returned with `value` as its fulfillment value. If `value` is a thenable (Promise-like object, like those returned by jQuery's `$.ajax`), returns a trusted that:Promise assimilates the state of the thenable.
+     */
+    function cast<R>(value:Thenable<R>):Promise<R>;
+    function cast<R>(value:R):Promise<R>;
 
-		/**
-		 * See if the underlying promise was defer at the creation time of this inspection object.
-		 */
-		isPending(): boolean;
+    /**
+     * Sugar for `Promise.resolve(undefined).bind(thisArg);`. See `.bind()`.
+     */
+    function bind(thisArg:any):Promise<void>;
 
-		/**
-		 * Get the fulfillment value of the underlying promise. Throws if the promise wasn't fulfilled at the creation time of this inspection object.
-		 *
-		 * throws `TypeError`
-		 */
-		value(): any;
+    /**
+     * See if `value` is a trusted Promise.
+     */
+    function is(value:any):boolean;
 
-		/**
-		 * Get the rejection reason for the underlying promise. Throws if the promise wasn't rejected at the creation time of this inspection object.
-		 *
-		 * throws `TypeError`
-		 */
-		error(): any;
-	}
+    /**
+     * Call this right after the library is loaded to enabled long stack traces. Long stack traces cannot be disabled after being enabled, and cannot be enabled after promises have alread been created. Long stack traces imply a substantial performance penalty, around 4-5x for throughput and 0.5x for latency.
+     */
+    function longStackTraces():void;
 
-	/**
-	 * Start the chain of promises with `Promise.try`. Any synchronous exceptions will be turned into rejections on the returned promise.
-	 *
-	 * Note about second argument: if it's specifically a true array, its values become respective arguments for the function call. Otherwise it is passed as is as the first argument for the function call.
-	 *
-	 * Alias for `attempt();` for compatibility with earlier ECMAScript version.
-	 */
-		// function try(fn: () => any, args?: any[], ctx?: any): Promise;
+    /**
+     * Returns a promise that will be fulfilled with `value` (or `undefined`) after given `ms` milliseconds. If `value` is a promise, the delay will start counting down when it is fulfilled and the returned promise will be fulfilled with the fulfillment value of the `value` promise.
+     */
+    //TODO enable more overloads
+    function delay<R>(value:Thenable<R>, ms:number):Promise<R>;
+    // function delay<R>(value:R, ms:number):Promise<R>;
+    function delay(ms:number):Promise<void>;
 
-	function attempt(fn: () => any, args?: any[], ctx?: any): Promise;
+    /**
+     * Returns a function that will wrap the given `nodeFunction`. Instead of taking a callback, the returned function will return a promise whose fate is decided by the callback behavior of the given node function. The node function should conform to node.js convention of accepting a callback as last argument and calling that callback with error as the first argument and success value on the second argument.
+     *
+     * If the `nodeFunction` calls its callback with multiple success values, the fulfillment value will be an array of them.
+     *
+     * If you pass a `receiver`, the `nodeFunction` will be called as a method on the `receiver`.
+     */
+    //TODO how to model promisify?
+    function promisify(nodeFunction:Function, receiver?:any):Function;
 
-	/**
-	 * Returns a new function that wraps the given function `fn`. The new function will always return a promise that is fulfilled with the original functions return values or rejected with thrown exceptions from the original function.
-	 * This method is convenient when a function can sometimes return synchronously or throw synchronously.
-	 */
-	function method(fn: Function): Function;
+    /**
+     * Promisifies the entire object by going through the object's properties and creating an async equivalent of each function on the object and its prototype chain. The promisified method name will be the original method name postfixed with `Async`. Returns the input object.
+     *
+     * Note that the original methods on the object are not overwritten but new methods are created with the `Async`-postfix. For example, if you `promisifyAll()` the node.js `fs` object use `fs.statAsync()` to call the promisified `stat` method.
+     */
+    //TODO how to model promisifyAll?
+    function promisifyAll(target:Object):Object;
 
-	/**
-	 * Create a promise that is resolved with the given `value`. If `value` is a thenable or promise, the returned promise will assume its state.
-	 */
-	function resolve(value: any): Promise;
+    /**
+     * Returns a function that can use `yield` to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch.
+     */
+    //TODO fix coroutine GeneratorFunction
+    function coroutine<R>(generatorFunction:Function):Function;
 
-	/**
-	 * Create a promise that is rejected with the given `reason`.
-	 */
-	function reject(reason: any): Promise;
+    /**
+     * Spawn a coroutine which may yield promises to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch.
+     */
+    //TODO fix spawn GeneratorFunction
+    function spawn<R>(generatorFunction:Function):Promise<R>;
 
-	/**
-	 * Create a promise with undecided fate and return a `Promise.Resolver` to control it. See resolution?:Promise(#promise-resolution).
-	 */
-	function defer(): Promise.Resolver;
+    /**
+     * This is relevant to browser environments with no module loader.
+     *
+     * Release control of the `Promise` namespace to whatever it was before this library was loaded. Returns a reference to the library namespace so you can attach it to something else.
+     */
+    function noConflict():typeof Promise;
 
-	/**
-	 * Cast the given `value` to a trusted promise. If `value` is already a trusted `Promise`, it is returned as is. If `value` is not a thenable, a fulfilled is:Promise returned with `value` as its fulfillment value. If `value` is a thenable (Promise-like object, like those returned by jQuery's `$.ajax`), returns a trusted that:Promise assimilates the state of the thenable.
-	 */
-	function cast(value: any): Promise;
+    /**
+     * Add `handler` as the handler to call when there is a possibly unhandled rejection. The default handler logs the error stack to stderr or `console.error` in browsers.
+     *
+     * Passing no value or a non-function will have the effect of removing any kind of handling for possibly unhandled rejections.
+     */
+    function onPossiblyUnhandledRejection(handler:(reason:any) => any):void;
 
-	/**
-	 * Sugar for `Promise.resolve(undefined).bind(thisArg);`. See `.bind()`.
-	 */
-	function bind(thisArg: any): Promise;
+    /**
+     * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are fulfilled. The promise's fulfillment value is an array with fulfillment values at respective positions to the original array. If any promise in the array rejects, the returned promise is rejected with the rejection reason.
+     */
+    //TODO enable more overloads
+    // promise of array with promises of value
+    // function all<R>(values:Thenable<Thenable<R>[]>):Promise<R[]>;
+    // promise of array with values
+    // function all<R>(values:Thenable<R[]>):Promise<R[]>;
+    // array with promises of value
+    function all<R>(values:Thenable<R>[]):Promise<R[]>;
+    // array with values
+    function all<R>(values:R[]):Promise<R[]>;
 
-	/**
-	 * See if `value` is a trusted Promise.
-	 */
-	function is(value: any): boolean;
+    /**
+     * Like ``Promise.all`` but for object properties instead of array items. Returns a promise that is fulfilled when all the properties of the object are fulfilled. The promise's fulfillment value is an object with fulfillment values at respective keys to the original object. If any promise in the object rejects, the returned promise is rejected with the rejection reason.
+     *
+     * If `object` is a trusted `Promise`, then it will be treated as a promise for object rather than for its properties. All other objects are treated for their properties as is returned by `Object.keys` - the object's own enumerable properties.
+     *
+     * *The original object is not modified.*
+     */
+    // trusted promise for object
+    function props(object:Promise<Object>):Promise<Object>;
+    // object
+    function props(object:Object):Promise<Object>;
 
-	/**
-	 * Call this right after the library is loaded to enabled long stack traces. Long stack traces cannot be disabled after being enabled, and cannot be enabled after promises have alread been created. Long stack traces imply a substantial performance penalty, around 4-5x for throughput and 0.5x for latency.
-	 */
-	function longStackTraces(): void;
+    /**
+     * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are either fulfilled or rejected. The fulfillment value is an array of ``PromiseInspection`` instances at respective positions in relation to the input array.
+     *
+     * *original:The array is not modified. The input array sparsity is retained in the resulting array.*
+     */
+    //TODO enable more overloads
+    // promise of array with promises of value
+    // function settle<R>(values:Thenable<Thenable<R>[]>):Promise<PromiseInspection<R>[]>;
+    // promise of array with values
+    // function settle<R>(values:Thenable<R[]>):Promise<PromiseInspection<R>[]>;
+    // array with promises of value
+    function settle<R>(values:Thenable<R>[]):Promise<PromiseInspection<R>[]>;
+    // array with values
+    function settle<R>(values:R[]):Promise<PromiseInspection<R>[]>;
 
-	/**
-	 * Returns a promise that will be fulfilled with `value` (or `undefined`) after given `ms` milliseconds. If `value` is a promise, the delay will start counting down when it is fulfilled and the returned promise will be fulfilled with the fulfillment value of the `value` promise.
-	 */
-	function delay(value: Promise, ms: number): Promise;
+    /**
+     * Like `Promise.some()`, with 1 as `count`. However, if the promise fulfills, the fulfillment value is not an array of 1 but the value directly.
+     */
+    //TODO enable more overloads
+    // promise of array with promises of value
+    // function any<R>(values:Thenable<Thenable<R>[]>):Promise<R>;
+    // promise of array with values
+    // function any<R>(values:Thenable<R[]>):Promise<R>;
+    // array with promises of value
+    function any<R>(values:Thenable<R>[]):Promise<R>;
+    // array with values
+    function any<R>(values:R[]):Promise<R>;
 
-	function delay(value: any, ms: number): Promise;
+    /**
+     * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled or rejected as soon as a promise in the array is fulfilled or rejected with the respective rejection reason or fulfillment value.
+     *
+     * **Note** If you pass empty array or a sparse array with no values, or a promise/thenable for such, it will be forever pending.
+     */
+    //TODO enable more overloads
+    // promise of array with promises of value
+    // function race<R>(values:Thenable<Thenable<R>[]>):Promise<R>;
+    // promise of array with values
+    // function race<R>(values:Thenable<R[]>):Promise<R>;
+    // array with promises of value
+    function race<R>(values:Thenable<R>[]):Promise<R>;    
+    // array with values
+    function race<R>(values:R[]):Promise<R>;
 
-	function delay(ms: number): Promise;
+    /**
+     * Initiate a competetive race between multiple promises or values (values will become immediately fulfilled promises). When `count` amount of promises have been fulfilled, the returned promise is fulfilled with an array that contains the fulfillment values of the winners in order of resolution.
+     *
+     * If too many promises are rejected so that the promise can never become fulfilled, it will be immediately rejected with an array of rejection reasons in the order they were thrown in.
+     *
+     * *The original array is not modified.*
+     */
+    //TODO enable more overloads
+    // promise of array with promises of value
+    // function some<R>(values:Thenable<Thenable<R>[]>, count:number):Promise<R>;
+    // promise of array with values
+    // function some<R>(values:Thenable<R[]>, count:number):Promise<R[]>;
+    // array with promises of value
+    function some<R>(values:Thenable<R>[], count:number):Promise<R[]>;
+    // array with values
+    function some<R>(values:R[], count:number):Promise<R[]>;
 
-	/**
-	 * Returns a function that will wrap the given `nodeFunction`. Instead of taking a callback, the returned function will return a promise whose fate is decided by the callback behavior of the given node function. The node function should conform to node.js convention of accepting a callback as last argument and calling that callback with error as the first argument and success value on the second argument.
-	 *
-	 * If the `nodeFunction` calls its callback with multiple success values, the fulfillment value will be an array of them.
-	 *
-	 * If you pass a `receiver`, the `nodeFunction` will be called as a method on the `receiver`.
-	 */
-	function promisify(nodeFunction: Function, receiver?: any): Function;
+    /**
+     * Like `Promise.all()` but instead of having to pass an array, the array is generated from the passed variadic arguments.
+     */
+    //TODO not quite like Promise.all() or does it miss something?
+    // variadic array with promises of value
+    function join<R>(...values:Thenable<R>[]):Promise<R[]>;
+    // variadic array with values
+    function join<R>(...values:R[]):Promise<R[]>;
 
-	/**
-	 * This overload has been **deprecated**. The overload will continue working for now. The recommended method for promisifying multiple methods at once is ``Promise.promisifyAll(Object target)``
-	 */
-	function promisify(target: Object): Object;
+    /**
+     * Map an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `mapper` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
+     *
+     * If the `mapper` function returns promises or thenables, the returned promise will wait for all the mapped results to be resolved as well.
+     *
+     * *The original array is not modified.*
+     */
+    //TODO enable more overloads
+    // promise of array with promises of value
+    // function map<R, U>(values:Thenable<Thenable<R>[]>, mapper:(item:R, index:number, arrayLength:number) => Thenable<U>):Promise<U[]>;
+    // function map<R, U>(values:Thenable<Thenable<R>[]>, mapper:(item:R, index:number, arrayLength:number) => U):Promise<U[]>;
 
-	/**
-	 * Promisifies the entire object by going through the object's properties and creating an async equivalent of each function on the object and its prototype chain. The promisified method name will be the original method name postfixed with `Async`. Returns the input object.
-	 *
-	 * Note that the original methods on the object are not overwritten but new methods are created with the `Async`-postfix. For example, if you `promisifyAll()` the node.js `fs` object use `fs.statAsync()` to call the promisified `stat` method.
-	 */
-	function promisifyAll(target: Object): Object;
+    // promise of array with values
+    // function map<R, U>(values:Thenable<R[]>, mapper:(item:R, index:number, arrayLength:number) => Thenable<U>):Promise<U[]>;
+    // function map<R, U>(values:Thenable<R[]>, mapper:(item:R, index:number, arrayLength:number) => U):Promise<U[]>;
 
-	/**
-	 * Returns a function that can use `yield` to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch.
-	 */
-	function coroutine(generatorFunction: Function): Function;
+    // array with promises of value
+    function map<R, U>(values:Thenable<R>[], mapper:(item:R, index:number, arrayLength:number) => Thenable<U>):Promise<U[]>;
+    function map<R, U>(values:Thenable<R>[], mapper:(item:R, index:number, arrayLength:number) => U):Promise<U[]>;
 
-	/**
-	 * Spawn a coroutine which may yield promises to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch.
-	 */
-	function spawn(generatorFunction: Function): Promise;
+    // array with values
+    function map<R, U>(values:R[], mapper:(item:R, index:number, arrayLength:number) => Thenable<U>):Promise<U[]>;
+    function map<R, U>(values:R[], mapper:(item:R, index:number, arrayLength:number) => U):Promise<U[]>;
 
-	/**
-	 * This is relevant to browser environments with no module loader.
-	 *
-	 * Release control of the `Promise` namespace to whatever it was before this library was loaded. Returns a reference to the library namespace so you can attach it to something else.
-	 */
-	function noConflict(): Object;
+    /**
+     * Reduce an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `reducer` function with the signature `(total, current, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
+     *
+     * If the reducer function returns a promise or a thenable, the result for the promise is awaited for before continuing with next iteration.
+     *
+     * *The original array is not modified. If no `intialValue` is given and the array doesn't contain at least 2 items, the callback will not be called and `undefined` is returned. If `initialValue` is given and the array doesn't have at least 1 item, `initialValue` is returned.*
+     */
+    //TODO enable more overloads
+    // promise of array with promises of value
+    // function reduce<R, U>(values:Thenable<Thenable<R>[]>, reducer:(total:U, current:R, index:number, arrayLength:number) => Thenable<U>, initialValue?:U):Promise<U>;
+    // function reduce<R, U>(values:Thenable<Thenable<R>[]>, reducer:(total:U, current:R, index:number, arrayLength:number) => U, initialValue?:U):Promise<U>;
 
-	/**
-	 * Add `handler` as the handler to call when there is a possibly unhandled rejection. The default handler logs the error stack to stderr or `console.error` in browsers.
-	 *
-	 * Passing no value or a non-function will have the effect of removing any kind of handling for possibly unhandled rejections.
-	 */
-	function onPossiblyUnhandledRejection(handler: (reason: any) => any): void;
+    // promise of array with values
+    // function reduce<R, U>(values:Thenable<R[]>, reducer:(total:U, current:R, index:number, arrayLength:number) => Thenable<U>, initialValue?:U):Promise<U>;
+    // function reduce<R, U>(values:Thenable<R[]>, reducer:(total:U, current:R, index:number, arrayLength:number) => U, initialValue?:U):Promise<U>;
 
-	/**
-	 * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are fulfilled. The promise's fulfillment value is an array with fulfillment values at respective positions to the original array. If any promise in the array rejects, the returned promise is rejected with the rejection reason.
-	 */
-	function all(values: any[]): Promise;
+    // array with promises of value
+    function reduce<R, U>(values:Thenable<R>[], reducer:(total:U, current:R, index:number, arrayLength:number) => Thenable<U>, initialValue?:U):Promise<U>;
+    function reduce<R, U>(values:Thenable<R>[], reducer:(total:U, current:R, index:number, arrayLength:number) => U, initialValue?:U):Promise<U>;
 
-	/**
-	 * Like ``Promise.all`` but for object properties instead of array items. Returns a promise that is fulfilled when all the properties of the object are fulfilled. The promise's fulfillment value is an object with fulfillment values at respective keys to the original object. If any promise in the object rejects, the returned promise is rejected with the rejection reason.
-	 *
-	 * If `object` is a trusted `Promise`, then it will be treated as a promise for object rather than for its properties. All other objects are treated for their properties as is returned by `Object.keys` - the object's own enumerable properties.
-	 *
-	 * *The original object is not modified.*
-	 */
-	function props(object: Promise): Promise;
+    // array with values
+    function reduce<R, U>(values:R[], reducer:(total:U, current:R, index:number, arrayLength:number) => Thenable<U>, initialValue?:U):Promise<U>;
+    function reduce<R, U>(values:R[], reducer:(total:U, current:R, index:number, arrayLength:number) => U, initialValue?:U):Promise<U>;
 
-	function props(object: Object): Promise;
+    /**
+     * Filter an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `filterer` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
+     *
+     * The return values from the filtered functions are coerced to booleans, with the exception of promises and thenables which are awaited for their eventual result.
+     *
+     * *The original array is not modified.
+     */
+    //TODO enable more overloads
+    // promise of array with promises of value
+    // function filter<R>(values:Thenable<Thenable<R>[]>, filterer:(item:R, index:number, arrayLength:number) => Thenable<boolean>):Promise<R[]>;
+    // function filter<R>(values:Thenable<Thenable<R>[]>, filterer:(item:R, index:number, arrayLength:number) => boolean):Promise<R[]>;
 
-	/**
-	 * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are either fulfilled or rejected. The fulfillment value is an array of ``Promise.Inspection`` instances at respective positions in relation to the input array.
-	 *
-	 * *original:The array is not modified. The input array sparsity is retained in the resulting array.*
-	 */
-	function settle(values: any[]): Promise;
+    // promise of array with values
+    // function filter<R>(values:Thenable<R[]>, filterer:(item:R, index:number, arrayLength:number) => Thenable<boolean>):Promise<R[]>;
+    // function filter<R>(values:Thenable<R[]>, filterer:(item:R, index:number, arrayLength:number) => boolean):Promise<R[]>;
 
-	/**
-	 * Like `Promise.some()`, with 1 as `count`. However, if the promise fulfills, the fulfillment value is not an array of 1 but the value directly.
-	 */
-	function any(values: any[]): Promise;
+    // array with promises of value
+    function filter<R>(values:Thenable<R>[], filterer:(item:R, index:number, arrayLength:number) => Thenable<boolean>):Promise<R[]>;
+    function filter<R>(values:Thenable<R>[], filterer:(item:R, index:number, arrayLength:number) => boolean):Promise<R[]>;
 
-	/**
-	 * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled or rejected as soon as a promise in the array is fulfilled or rejected with the respective rejection reason or fulfillment value.
-	 *
-	 * **Note** If you pass empty array or a sparse array with no values, or a promise/thenable for such, it will be forever pending.
-	 */
-	function race(values: any[]): Promise;
-
-	/**
-	 * Initiate a competetive race between multiple promises or values (values will become immediately fulfilled promises). When `count` amount of promises have been fulfilled, the returned promise is fulfilled with an array that contains the fulfillment values of the winners in order of resolution.
-	 *
-	 * If too many promises are rejected so that the promise can never become fulfilled, it will be immediately rejected with an array of rejection reasons in the order they were thrown in.
-	 *
-	 * *The original array is not modified.*
-	 */
-	function some(values: any[], count: number): Promise;
-
-	/**
-	 * Like `Promise.all()` but instead of having to pass an array, the array is generated from the passed variadic arguments.
-	 */
-	function join(...values: any[]): Promise;
-
-	/**
-	 * Map an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `mapper` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
-	 *
-	 * If the `mapper` function returns promises or thenables, the returned promise will wait for all the mapped results to be resolved as well.
-	 *
-	 * *The original array is not modified.*
-	 */
-	function map(values: any[], mapper: (item: any, index: number, arrayLength: number) => any): Promise;
-
-	/**
-	 * Reduce an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `reducer` function with the signature `(total, current, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
-	 *
-	 * If the reducer function returns a promise or a thenable, the result for the promise is awaited for before continuing with next iteration.
-	 *
-	 * *The original array is not modified. If no `intialValue` is given and the array doesn't contain at least 2 items, the callback will not be called and `undefined` is returned. If `initialValue` is given and the array doesn't have at least 1 item, `initialValue` is returned.*
-	 */
-	function reduce(values: any[], reducer: (total: number, current: any, index: number, arrayLength: number) => any, initialValue?: any): Promise;
-
-	/**
-	 * Filter an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `filterer` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
-	 *
-	 * The return values from the filtered functions are coerced to booleans, with the exception of promises and thenables which are awaited for their eventual result.
-	 *
-	 * *The original array is not modified.
-	 */
-	function filter(values: any[], filterer: (item: any, index?: number, arrayLength?: number) => any): Promise;
+    // array with values
+    function filter<R>(values:R[], filterer:(item:R, index:number, arrayLength:number) => Thenable<boolean>):Promise<R[]>;
+    function filter<R>(values:R[], filterer:(item:R, index:number, arrayLength:number) => boolean):Promise<R[]>;
 }
 
 declare module 'bluebird' {

From 64a7c7e391c7d77197f14f23470c478c5539400a Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 25 Feb 2014 02:09:07 +0100
Subject: [PATCH 059/309] Second pass at bluebird generics for TS > v0.9.7
 (v1.0.0)

Rebased on recent infrastructure
---
 bluebird/bluebird-tests.ts |  975 ++++++++++++++++++++++-------
 bluebird/bluebird.d.ts     | 1208 ++++++++++++++++++------------------
 2 files changed, 1361 insertions(+), 822 deletions(-)

diff --git a/bluebird/bluebird-tests.ts b/bluebird/bluebird-tests.ts
index 14528b9b5..ff4b85e2e 100644
--- a/bluebird/bluebird-tests.ts
+++ b/bluebird/bluebird-tests.ts
@@ -1,319 +1,868 @@
 /// <reference path="bluebird.d.ts" />
 
-// Note: try to maintain the ordering and separators
+// Tests by: Bart van der Schoor <https://github.com/Bartvds>
 
-var obj:Object;
-var bool:boolean;
-var num:number;
-var str:string;
-var x:any = null;
-var f:Function;
-var arr:any[];
-var exp:RegExp;
-var strArr:string[];
-var numArr:string[];
+// Note: replicate changes to all overloads in both definition and test file
+// Note: keep both static and instance members inline (so similar)
 
+// Note: try to maintain the ordering and separators, and keep to the pattern
 
-var value:any = null;
-var reason:any = null;
+var obj: Object;
+var bool: boolean;
+var num: number;
+var str: string;
+var err: Error;
+var x: any;
+var f: Function;
+var func: Function;
+var arr: any[];
+var exp: RegExp;
+var anyArr: any[];
+var strArr: string[];
+var numArr: number[];
 
-var promise:Promise;
-var p:Promise;
+// - - - - - - - - - - - - - - - - -
 
-var resolver:Promise.Resolver;
-var inspection:Promise.Inspection;
+var value: any;
+var reason: any;
+var insanity: any;
 
-// - - - - - - - - - - - - - - - - - - - - - - - -
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-var promise = new Promise((resolve:(value:any) => void, reject:(reason:any) => void) => {
-	if(true) {
-		resolve(123);
-	}
-	else {
-		reject(new Error('nope'));
-	}
+interface Foo {
+	foo(): string;
+}
+interface Bar {
+	bar(): string;
+}
+
+// - - - - - - - - - - - - - - - - -
+
+interface StrFooMap {
+	[key:string]:Foo;
+}
+
+interface StrBarMap {
+	[key:string]:Bar;
+}
+
+// - - - - - - - - - - - - - - - - -
+
+interface StrFooArrMap {
+	[key:string]:Foo[];
+}
+
+interface StrBarArrMap {
+	[key:string]:Bar[];
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+var foo: Foo;
+var bar: Bar;
+
+var fooArr: Foo[];
+var barArr: Bar[];
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+var numProm: Promise<number>;
+var strProm: Promise<string>;
+var anyProm: Promise<any>;
+var boolProm: Promise<boolean>;
+var objProm: Promise<Object>;
+var voidProm: Promise<void>;
+
+var fooProm: Promise<Foo>;
+var barProm: Promise<Bar>;
+
+// - - - - - - - - - - - - - - - - -
+
+var numThen: Promise.Thenable<number>;
+var strThen: Promise.Thenable<string>;
+var anyThen: Promise.Thenable<any>;
+var boolThen: Promise.Thenable<boolean>;
+var objThen: Promise.Thenable<Object>;
+var voidThen: Promise.Thenable<void>;
+
+var fooThen: Promise.Thenable<Foo>;
+var barThen: Promise.Thenable<Bar>;
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+var numArrProm: Promise<number[]>;
+var strArrProm: Promise<string[]>;
+var anyArrProm: Promise<any[]>;
+
+var fooArrProm: Promise<Foo[]>;
+var barArrProm: Promise<Bar[]>;
+
+// - - - - - - - - - - - - - - - - -
+
+var numArrThen: Promise.Thenable<number[]>;
+var strArrThen: Promise.Thenable<string[]>;
+var anyArrThen: Promise.Thenable<any[]>;
+
+var fooArrThen: Promise.Thenable<Foo[]>;
+var barArrThen: Promise.Thenable<Bar[]>;
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+var numPromArr: Promise<number>[];
+var strPromArr: Promise<string>[];
+var anyPromArr: Promise<any>[];
+
+var fooPromArr: Promise<Foo>[];
+var barPromArr: Promise<Bar>[];
+
+// - - - - - - - - - - - - - - - - -
+
+var numThenArr: Promise.Thenable<number>[];
+var strThenArr: Promise.Thenable<string>[];
+var anyThenArr: Promise.Thenable<any>[];
+
+var fooThenArr: Promise.Thenable<Foo>[];
+var barThenArr: Promise.Thenable<Bar>[];
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// booya!
+var fooThenArrThen: Promise.Thenable<Promise.Thenable<Foo>[]>;
+var barThenArrThen: Promise.Thenable<Promise.Thenable<Bar>[]>;
+
+var fooResolver: Promise.Resolver<Foo>;
+var barResolver: Promise.Resolver<Bar>;
+
+var fooInspection: Promise.Inspection<Foo>;
+var barInspection: Promise.Inspection<Bar>;
+
+var fooInspectionArrProm: Promise<Promise.Inspection<Foo>[]>;
+var barInspectionArrProm: Promise<Promise.Inspection<Bar>[]>;
+
+var BlueBird: typeof Promise;
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooThen = fooProm;
+barThen = barProm;
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooProm = new Promise((resolve: (value: Foo) => void, reject: (reason: any) => void) => {
+    if (bool) {
+        resolve(foo);
+    }
+    else {
+        reject(new Error(str));
+    }
+});
+fooProm = new Promise((resolve: (value: Foo) => void) => {
+    if (bool) {
+        resolve(foo);
+    }
 });
 
-// - - - - - - - - - - - - - - - - - - - - - - - -
+// - - - - - - - - - - - - - - - - - - - - - - -
 
-resolver.resolve(x);
+// needs a hint when used untyped?
+fooProm = new Promise<Foo>((resolve, reject) => {
+	if (bool) {
+		resolve(fooThen);
+	}
+	else {
+		reject(new Error(str));
+	}
+});
+fooProm = new Promise<Foo>((resolve) => {
+	resolve(fooThen);
+});
 
-resolver.reject(x);
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-resolver.progress(x);
+fooResolver.resolve(foo);
 
-resolver.callback = () => {
+fooResolver.reject(foo);
+
+fooResolver.progress(foo);
+
+fooResolver.callback = () => {
 
 };
 
-// - - - - - - - - - - - - - - - - - - - - - - - -
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-bool = inspection.isFulfilled();
+bool = fooInspection.isFulfilled();
 
-bool = inspection.isRejected();
+bool = fooInspection.isRejected();
 
-bool = inspection.isPending();
+bool = fooInspection.isPending();
 
-x = inspection.value();
+foo = fooInspection.value();
 
-x = inspection.error();
+x = fooInspection.error();
 
-// - - - - - - - - - - - - - - - - - - - - - - - -
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-p = promise.then((value:any) => {
+barProm = fooProm.then((value: Foo) => {
+    return bar;
+}, (reason: any) => {
+    return bar;
+}, (note: any) => {
+	return bar;
+});
+barProm = fooProm.then((value: Foo) => {
+	return bar;
+}, (reason: any) => {
+	return bar;
+});
+barProm = fooProm.then((value: Foo) => {
+    return bar;
+});
 
-}, (reason:any) => {
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-}, (note:any) => {
+barProm = fooProm.catch((reason: any) => {
+    return bar;
+});
+barProm = fooProm.caught((reason: any) => {
+    return bar;
+});
+
+barProm = fooProm.catch((reason: any) => {
+    return bar;
+}, (reason: any) => {
+    return bar;
+});
+barProm = fooProm.caught((reason: any) => {
+    return bar;
+}, (reason: any) => {
+    return bar;
+});
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+barProm = fooProm.catch(Error, (reason: any) => {
+    return bar;
+});
+barProm = fooProm.caught(Error, (reason: any) => {
+    return bar;
+});
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+barProm = fooProm.error((reason: any) => {
+    return bar;
+});
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooProm = fooProm.finally((value: Foo) => {
+	// return is ignored
+	return foo;
+});
+fooProm = fooProm.finally((value: Foo) => {
+	// return is ignored
+	return fooThen;
+});
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooProm = fooProm.lastly((value: Foo) => {
+	// return is ignored
+	return foo;
+});
+fooProm = fooProm.lastly((value: Foo) => {
+	// return is ignored
+	return fooThen;
+});
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooProm = fooProm.bind(obj);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+barProm = fooProm.done((value: Foo) => {
+    return bar;
+}, (reason: any) => {
+    return bar;
+}, (note: any) => {
 
 });
-p = promise.then((value:any) => {
+barProm = fooProm.done((value: Foo) => {
+    return bar;
+}, (reason: any) => {
+    return bar;
+});
+barProm = fooProm.done((value: Foo) => {
+    return bar;
+});
 
-}, (reason:any) => {
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+barProm = fooProm.done((value: Foo) => {
+    return barThen;
+}, (reason: any) => {
+    return barThen;
+}, (note: any) => {
 
 });
-p = promise.then((value:any) => {
+barProm = fooProm.done((value: Foo) => {
+    return barThen;
+}, (reason: any) => {
+    return barThen;
+});
+barProm = fooProm.done((value: Foo) => {
+    return barThen;
+});
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooProm = fooProm.progressed((note: any) => {
+    return foo;
+});
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooProm = fooProm.delay(num);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooProm = fooProm.timeout(num);
+fooProm = fooProm.timeout(num, str);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooProm.nodeify();
+fooProm = fooProm.nodeify((err: any) => {
+
+});
+fooProm = fooProm.nodeify((err: any, foo?: Foo) => {
 
 });
 
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-p = promise.catch((reason:any) => {
+barProm = fooProm.fork((value: Foo) => {
+    return bar;
+}, (reason: any) => {
+    return bar;
+}, (note: any) => {
 
 });
-p = promise.caught((reason:any) => {
-
+barProm = fooProm.fork((value: Foo) => {
+    return bar;
+}, (reason: any) => {
+    return bar;
 });
-p = promise.catch((reason:any) => {
-	return true;
-}, (reason:any) => {
-
-});
-p = promise.caught((reason:any) => {
-	return true;
-}, (reason:any) => {
-
+barProm = fooProm.fork((value: Foo) => {
+    return bar;
 });
 
-p = promise.catch(Error, (reason:any) => {
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+barProm = fooProm.fork((value: Foo) => {
+    return barThen;
+}, (reason: any) => {
+    return barThen;
+}, (note: any) => {
 
 });
-p = promise.caught(Error, (reason:any) => {
-
+barProm = fooProm.fork((value: Foo) => {
+    return barThen;
+}, (reason: any) => {
+    return barThen;
+});
+barProm = fooProm.fork((value: Foo) => {
+    return barThen;
 });
 
-p = promise.error((reason:any) => {
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
+barProm = fooProm.cancel<Bar>();
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooProm = fooProm.cancellable();
+fooProm = fooProm.uncancellable();
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+bool = fooProm.isCancellable();
+bool = fooProm.isFulfilled();
+bool = fooProm.isRejected();
+bool = fooProm.isPending();
+bool = fooProm.isResolved();
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooInspection = fooProm.inspect();
+
+anyProm = fooProm.call(str);
+anyProm = fooProm.call(str, 1, 2, 3);
+
+//TODO enable get() test when implemented
+// barProm = fooProm.get(str);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+barProm = fooProm.return(bar);
+barProm = fooProm.thenReturn(bar);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// fooProm
+fooProm = fooProm.throw(err);
+fooProm = fooProm.thenThrow(err);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+str = fooProm.toString();
+
+obj = fooProm.toJSON();
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+barProm = fooArrProm.spread<Bar>((one: Foo, two: Bar) => {
+    return bar;
+}, (reason: any) => {
+    return bar;
+});
+barProm = fooArrProm.spread<Bar>((one: Foo, two: Bar, twotwo: Foo) => {
+    return bar;
 });
 
-p = promise.finally((value:any) => {
+// - - - - - - - - - - - - - - - - -
 
+barProm = fooArrProm.spread<Bar>((one: Foo, two: Bar) => {
+    return barThen;
+}, (reason: any) => {
+    return barThen;
 });
-p = promise.lastly((value:any) => {
-
+barProm = fooArrProm.spread<Bar>((one: Foo, two: Bar, twotwo: Foo) => {
+    return barThen;
 });
 
-p = promise.bind(x);
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-p = promise.done((value:any) => {
+//TODO fix collection inference
 
-}, (reason:any) => {
+barArrProm = fooProm.all<Bar>();
 
-}, (note:any) => {
+objProm = fooProm.props();
 
+barInspectionArrProm = fooProm.settle<Bar>();
+
+barProm = fooProm.any<Bar>();
+
+barArrProm = fooProm.some<Bar>(num);
+
+barProm = fooProm.race<Bar>();
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+//TODO fix collection inference
+
+barProm = fooProm.map<Foo, Bar>((item: Foo, index: number, arrayLength: number) => {
+	return bar;
 });
-p = promise.done((value:any) => {
-
-}, (reason:any) => {
-
-});
-p = promise.done((value:any) => {
-
+barProm = fooProm.map<Foo, Bar>((item: Foo) => {
+	return bar;
 });
 
-p = promise.progressed((note:any) => {
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-});
-
-p = promise.delay(x);
-
-p = promise.timeout(x);
-p = promise.timeout(x, str);
-
-p = promise.nodeify();
-p = promise.nodeify(function(err:any) {
-
-});
-
-p = promise.cancellable();
-
-p = promise.cancel();
-
-p = promise.fork((value:any) => {
-
-}, (reason:any) => {
-
-}, (note:any) => {
-
-});
-p = promise.fork((value:any) => {
-
-}, (reason:any) => {
-
-});
-p = promise.fork((value:any) => {
-
-});
-
-p = promise.uncancellable();
-
-bool = promise.isCancellable();
-
-bool = promise.isFulfilled();
-
-bool = promise.isRejected();
-
-bool = promise.isPending();
-
-bool = promise.isResolved();
-
-inspection = promise.inspect();
-
-p = promise.call(str, 1, 2, 3);
-
-p = promise.get(str);
-
-p = promise.return(value);
-p = promise.thenReturn();
-
-p = promise.throw(x);
-p = promise.thenThrow();
-
-str = promise.toString();
-
-obj = promise.toJSON();
-
-p = promise.all();
-
-p = promise.props();
-
-p = promise.settle();
-
-p = promise.any();
-
-p = promise.some(x);
-
-p = promise.race();
-
-p = promise.spread((value:any) => {
-
-}, (reason:any) => {
-
-});
-p = promise.spread((value:any) => {
-
-});
-
-p = promise.map((item:any, index:number, arrayLength:number) => {
-	return x;
-});
-
-p = promise.reduce((total:number, memo:any, index:number, arrayLength:number) => {
+barProm = fooProm.reduce<Foo, Bar>((memo: Bar, item: Foo, index: number, arrayLength: number) => {
 	return memo;
 });
-p = promise.reduce((total:number, memo:any, index:number, arrayLength:number) => {
+barProm = fooProm.reduce<Foo, Bar>((memo: Bar, item: Foo) => {
 	return memo;
-}, x);
+}, bar);
 
-p = promise.filter((item:any, index?:number, arrayLength?:number) => {
-	return true;
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooProm = fooProm.filter<Foo>((item: Foo, index: number, arrayLength: number) => {
+	return bool;
+});
+fooProm = fooProm.filter<Foo>((item: Foo) => {
+	return bool;
 });
 
-// - - - - - - - - - - - - - - - - - - - - - - - -
-
-p = new Promise((resolve:(value:any) => any, reject:(reason:any) => any) => {
-	if(true) {
-		resolve(value);
-	}
-	else {
-		reject(new Error('xyz'));
-	}
-});
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
+///TODO enable try tests
 /*
- p = Promise.try(() => {});
- p = Promise.try(() => {}, arr);
- p = Promise.try(() => {}, arr, x);
- */
+fooProm = Promise.try(() => {
+	return foo;
+});
+fooProm = Promise.try(() => {
+	return foo;
+}, arr);
+fooProm = Promise.try(() => {
+	return foo;
+}, arr, x);
 
-p = Promise.attempt(() => {});
-p = Promise.attempt(() => {}, arr);
-p = Promise.attempt(() => {}, arr, x);
+// - - - - - - - - - - - - - - - - -
 
-f = Promise.method(function() {
+fooProm = Promise.try(() => {
+	return fooThen;
+});
+fooProm = Promise.try(() => {
+	return fooThen;
+}, arr);
+fooProm = Promise.try(() => {
+	return fooThen;
+}, arr, x);
+*/
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooProm = Promise.attempt(() => {
+	return foo;
+});
+fooProm = Promise.attempt(() => {
+	return foo;
+}, arr);
+fooProm = Promise.attempt(() => {
+	return foo;
+}, arr, x);
+
+// - - - - - - - - - - - - - - - - -
+
+fooProm = Promise.attempt(() => {
+	return fooThen;
+});
+fooProm = Promise.attempt(() => {
+	return fooThen;
+}, arr);
+fooProm = Promise.attempt(() => {
+	return fooThen;
+}, arr, x);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+func = Promise.method(function () {
 
 });
 
-p = Promise.resolve(value);
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-p = Promise.reject(reason);
+fooProm = Promise.resolve(foo);
+fooProm = Promise.resolve(fooThen);
 
-resolver = Promise.defer();
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-p = Promise.cast(value);
+voidProm = Promise.reject(reason);
 
-p = Promise.bind(x);
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooResolver = Promise.defer<Foo>();
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooProm = Promise.cast(foo);
+fooProm = Promise.cast(fooThen);
+
+voidProm = Promise.bind(x);
 
 bool = Promise.is(value);
 
 Promise.longStackTraces();
 
-p = Promise.delay(p, x);
-p = Promise.delay(value, x);
-p = Promise.delay(x);
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-f = Promise.promisify(f);
-f = Promise.promisify(f, x);
+//TODO enable delay
 
-obj = Promise.promisify(obj);
+fooProm = Promise.delay(fooThen, num);
+fooProm = Promise.delay(foo, num);
+voidProm = Promise.delay(num);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+func = Promise.promisify(f);
+func = Promise.promisify(f, obj);
+;
 
 obj = Promise.promisifyAll(obj);
 
-f = Promise.coroutine(f);
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-p = Promise.spawn(f);
+//TODO enable generator
+/*
+ func = Promise.coroutine(f);
 
-obj = Promise.noConflict();
+ barProm = Promise.spawn<number>(f);
+ */
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-Promise.onPossiblyUnhandledRejection((reason:any) => {
+BlueBird = Promise.noConflict();
+
+Promise.onPossiblyUnhandledRejection((reason: any) => {
 
 });
 
-p = Promise.all(arr);
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-p = Promise.props(p);
-p = Promise.props(obj);
+//TODO expand tests to overloads
+fooArrProm = Promise.all(fooThenArrThen);
+fooArrProm = Promise.all(fooArrProm);
+fooArrProm = Promise.all(fooThenArr);
+fooArrProm = Promise.all(fooArr);
 
-p = Promise.settle(arr);
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-p = Promise.any(arr);
+objProm = Promise.props(objProm);
+objProm = Promise.props(obj);
 
-p = Promise.race(arr);
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-p = Promise.some(arr, x);
+//TODO expand tests to overloads
+fooInspectionArrProm = Promise.settle(fooThenArrThen);
+fooInspectionArrProm = Promise.settle(fooArrProm);
+fooInspectionArrProm = Promise.settle(fooThenArr);
+fooInspectionArrProm = Promise.settle(fooArr);
 
-p = Promise.join(1, 2, 3);
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-p = Promise.map(arr, (item:any, index:number, arrayLength:number) => {
-	return x;
+//TODO expand tests to overloads
+fooProm = Promise.any(fooThenArrThen);
+fooProm = Promise.any(fooArrProm);
+fooProm = Promise.any(fooThenArr);
+fooProm = Promise.any(fooArr);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+//TODO expand tests to overloads
+fooProm = Promise.race(fooThenArrThen);
+fooProm = Promise.race(fooArrProm);
+fooProm = Promise.race(fooThenArr);
+fooProm = Promise.race(fooArr);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+//TODO expand tests to overloads
+fooArrProm = Promise.some(fooThenArrThen, num);
+fooArrProm = Promise.some(fooArrThen, num);
+fooArrProm = Promise.some(fooThenArr, num);
+fooArrProm = Promise.some(fooArr, num);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+fooArrProm = Promise.join(foo, foo, foo);
+fooArrProm = Promise.join(fooThen, fooThen, fooThen);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// map()
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// fooThenArrThen
+
+barArrProm = Promise.map(fooThenArrThen, (item: Foo) => {
+	return bar;
+});
+barArrProm = Promise.map(fooThenArrThen, (item: Foo) => {
+	return barThen;
+});
+barArrProm = Promise.map(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
+	return bar;
+});
+barArrProm = Promise.map(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
+	return barThen;
 });
 
-p = Promise.reduce(arr, (total:number, memo:any, index:number, arrayLength:number) => {
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// fooArrThen
+
+barArrProm = Promise.map(fooArrThen, (item: Foo) => {
+	return bar;
+});
+barArrProm = Promise.map(fooArrThen, (item: Foo) => {
+	return barThen;
+});
+barArrProm = Promise.map(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
+	return bar;
+});
+barArrProm = Promise.map(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
+	return barThen;
+});
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// fooThenArr
+
+barArrProm = Promise.map(fooThenArr, (item: Foo) => {
+    return bar;
+});
+barArrProm = Promise.map(fooThenArr, (item: Foo) => {
+    return barThen;
+});
+barArrProm = Promise.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
+    return bar;
+});
+barArrProm = Promise.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
+    return barThen;
+});
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// fooArr
+
+barArrProm = Promise.map(fooArr, (item: Foo) => {
+    return bar;
+});
+barArrProm = Promise.map(fooArr, (item: Foo) => {
+    return barThen;
+});
+barArrProm = Promise.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
+    return bar;
+});
+barArrProm = Promise.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
+    return barThen;
+});
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// reduce()
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// fooThenArrThen
+
+barProm = Promise.reduce(fooThenArrThen, (memo: Bar, item: Foo) => {
 	return memo;
-});
-p = Promise.reduce(arr, (total:number, memo:any, index:number, arrayLength:number) => {
+}, bar);
+barProm = Promise.reduce(fooThenArrThen, (memo: Bar, item: Foo) => {
+	return barThen;
+}, bar);
+barProm = Promise.reduce(fooThenArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
 	return memo;
-}, x);
+}, bar);
+barProm = Promise.reduce(fooThenArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+	return barThen;
+}, bar);
 
-p = Promise.filter(arr, (item:any, index?:number, arrayLength?:number) => {
-	return true;
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// fooArrThen
+
+barProm = Promise.reduce(fooArrThen, (memo: Bar, item: Foo) => {
+	return memo;
+}, bar);
+barProm = Promise.reduce(fooArrThen, (memo: Bar, item: Foo) => {
+	return barThen;
+}, bar);
+barProm = Promise.reduce(fooArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+	return memo;
+}, bar);
+barProm = Promise.reduce(fooArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+	return barThen;
+}, bar);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// fooThenArr
+
+barProm = Promise.reduce(fooThenArr, (memo: Bar, item: Foo) => {
+    return memo;
+}, bar);
+barProm = Promise.reduce(fooThenArr, (memo: Bar, item: Foo) => {
+    return barThen;
+}, bar);
+barProm = Promise.reduce(fooThenArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+    return memo;
+}, bar);
+barProm = Promise.reduce(fooThenArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+    return barThen;
+}, bar);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// fooArr
+
+barProm = Promise.reduce(fooArr, (memo: Bar, item: Foo) => {
+    return memo;
+}, bar);
+barProm = Promise.reduce(fooArr, (memo: Bar, item: Foo) => {
+	return barThen;
+}, bar);
+barProm = Promise.reduce(fooArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+	return memo;
+}, bar);
+barProm = Promise.reduce(fooArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+	return barThen;
+}, bar);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// filter()
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// fooThenArrThen
+
+fooArrProm = Promise.filter(fooThenArrThen, (item: Foo) => {
+	return bool;
 });
+fooArrProm = Promise.filter(fooThenArrThen, (item: Foo) => {
+	return boolThen;
+});
+fooArrProm = Promise.filter(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
+	return bool;
+});
+fooArrProm = Promise.filter(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
+	return boolThen;
+});
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// fooArrThen
+
+fooArrProm = Promise.filter(fooArrThen, (item: Foo) => {
+	return bool;
+});
+fooArrProm = Promise.filter(fooArrThen, (item: Foo) => {
+	return boolThen;
+});
+fooArrProm = Promise.filter(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
+	return bool;
+});
+fooArrProm = Promise.filter(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
+	return boolThen;
+});
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// fooThenArr
+
+fooArrProm = Promise.filter(fooThenArr, (item: Foo) => {
+    return bool;
+});
+fooArrProm = Promise.filter(fooThenArr, (item: Foo) => {
+    return boolThen;
+});
+fooArrProm = Promise.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
+    return bool;
+});
+fooArrProm = Promise.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
+    return boolThen;
+});
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// fooArr
+
+fooArrProm = Promise.filter(fooArr, (item: Foo) => {
+    return bool;
+});
+fooArrProm = Promise.filter(fooArr, (item: Foo) => {
+    return boolThen;
+});
+fooArrProm = Promise.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
+    return bool;
+});
+fooArrProm = Promise.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
+    return boolThen;
+});
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
diff --git a/bluebird/bluebird.d.ts b/bluebird/bluebird.d.ts
index ba5c60ded..13494cb82 100644
--- a/bluebird/bluebird.d.ts
+++ b/bluebird/bluebird.d.ts
@@ -1,663 +1,653 @@
 // Type definitions for bluebird 1.0.0
 // Project: https://github.com/petkaantonov/bluebird
 // Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 // ES6 model with generics overload was sourced and trans-multiplied from es6-promises.d.ts
 // By: Campredon <https://github.com/fdecampredon/>
-// By: Igorbek <https://github.com/Igorbek/>
+
+// Warning: recommended to use `tsc > v1.0.0` (critical bugs in generic code:
+// - https://github.com/borisyankov/DefinitelyTyped/issues/1563
+// - https://github.com/borisyankov/DefinitelyTyped/tree/def/bluebird
 
 // Note: replicate changes to all overloads in both definition and test file
 // Note: keep both static and instance members inline (so similar)
 
-//TODO fix all TODO annotations in the file
+// TODO fix remaining TODO annotations in both definition and test
 
-//TODO support to have no return statement in handlers to get a Promise<void> (more overloads?)
+// TODO verify support to have no return statement in handlers to get a Promise<void> (more overloads?)
 
-interface Thenable<R> {
-    then<U>(onFulfilled:(value:R) => Thenable<U>, onRejected:(error:any) => Thenable<U>): Thenable<U>;
-    then<U>(onFulfilled:(value:R) => Thenable<U>, onRejected?:(error:any) => U): Thenable<U>;
-    then<U>(onFulfilled:(value:R) => U, onRejected:(error:any) => Thenable<U>): Thenable<U>;
-    then<U>(onFulfilled?:(value:R) => U, onRejected?:(error:any) => U): Thenable<U>;
+declare class Promise<R> implements Promise.Thenable<R> {
+	/**
+	 * Create a new promise. The passed in function will receive functions `resolve` and `reject` as its arguments which can be called to seal the fate of the created promise.
+	 */
+	constructor(callback: (resolve: (thenable: Promise.Thenable<R>) => void, reject: (error: any) => void) => void);
+	constructor(callback: (resolve: (result: R) => void, reject: (error: any) => void) => void);
+
+	/**
+	 * Promises/A+ `.then()` with progress handler. Returns a new promise chained from this promise. The new promise will be rejected or resolved dedefer on the passed `fulfilledHandler`, `rejectedHandler` and the state of this promise.
+	 */
+	then<U>(onFulfill: (value: R) => Promise.Thenable<U>, onReject: (error: any) => Promise.Thenable<U>, onProgress?: (note: any) => any): Promise<U>;
+	then<U>(onFulfill: (value: R) => Promise.Thenable<U>, onReject?: (error: any) => U, onProgress?: (note: any) => any): Promise<U>;
+	then<U>(onFulfill: (value: R) => U, onReject: (error: any) => Promise.Thenable<U>, onProgress?: (note: any) => any): Promise<U>;
+	then<U>(onFulfill?: (value: R) => U, onReject?: (error: any) => U, onProgress?: (note: any) => any): Promise<U>;
+
+	/**
+	 * This is a catch-all exception handler, shortcut for calling `.then(null, handler)` on this promise. Any exception happening in a `.then`-chain will propagate to nearest `.catch` handler.
+	 *
+	 * Alias `.caught();` for compatibility with earlier ECMAScript version.
+	 */
+	catch<U>(onReject?: (error: any) => Promise.Thenable<U>): Promise<U>;
+	caught<U>(onReject?: (error: any) => Promise.Thenable<U>): Promise<U>;
+
+	catch<U>(onReject?: (error: any) => U): Promise<U>;
+	caught<U>(onReject?: (error: any) => U): Promise<U>;
+
+	/**
+	 * This extends `.catch` to work more like catch-clauses in languages like Java or C#. Instead of manually checking `instanceof` or `.name === "SomeError"`, you may specify a number of error constructors which are eligible for this catch handler. The catch handler that is first met that has eligible constructors specified, is the one that will be called.
+	 *
+	 * This method also supports predicate-based filters. If you pass a predicate function instead of an error constructor, the predicate will receive the error as an argument. The return result of the predicate will be used determine whether the error handler should be called.
+	 *
+	 * Alias `.caught();` for compatibility with earlier ECMAScript version.
+	 */
+	catch<U>(predicate: (error: any) => boolean, onReject: (error: any) => Promise.Thenable<U>): Promise<U>;
+	caught<U>(predicate: (error: any) => boolean, onReject: (error: any) => Promise.Thenable<U>): Promise<U>;
+
+	catch<U>(predicate: (error: any) => boolean, onReject: (error: any) => U): Promise<U>;
+	caught<U>(predicate: (error: any) => boolean, onReject: (error: any) => U): Promise<U>;
+
+	catch<U>(ErrorClass: Function, onReject: (error: any) => Promise.Thenable<U>): Promise<U>;
+	caught<U>(ErrorClass: Function, onReject: (error: any) => Promise.Thenable<U>): Promise<U>;
+
+	catch<U>(ErrorClass: Function, onReject: (error: any) => U): Promise<U>;
+	caught<U>(ErrorClass: Function, onReject: (error: any) => U): Promise<U>;
+
+	/**
+	 * Like `.catch` but instead of catching all types of exceptions, it only catches those that don't originate from thrown errors but rather from explicit rejections.
+	 */
+	error<U>(onReject: (reason: any) => Promise.Thenable<U>): Promise<U>;
+	error<U>(onReject: (reason: any) => U): Promise<U>;
+
+	/**
+	 * Pass a handler that will be called regardless of this promise's fate. Returns a new promise chained from this promise. There are special semantics for `.finally()` in that the final value cannot be modified from the handler.
+	 *
+	 * Alias `.lastly();` for compatibility with earlier ECMAScript version.
+	 */
+	finally(handler: (value: R) => Promise.Thenable<R>): Promise<R>;
+	finally(handler: (value: R) => R): Promise<R>;
+
+	lastly(handler: (value: R) => Promise.Thenable<R>): Promise<R>;
+	lastly(handler: (value: R) => R): Promise<R>;
+
+	/**
+	 * Create a promise that follows this promise, but is bound to the given `thisArg` value. A bound promise will call its handlers with the bound value set to `this`. Additionally promises derived from a bound promise will also be bound promises with the same `thisArg` binding as the original promise.
+	 */
+	bind(thisArg: any): Promise<R>;
+
+	/**
+	 * Like `.then()`, but any unhandled rejection that ends up here will be thrown as an error.
+	 */
+	done<U>(onFulfilled: (value: R) => Promise.Thenable<U>, onRejected: (error: any) => Promise.Thenable<U>, onProgress?: (note: any) => any): Promise<U>;
+	done<U>(onFulfilled: (value: R) => Promise.Thenable<U>, onRejected?: (error: any) => U, onProgress?: (note: any) => any): Promise<U>;
+	done<U>(onFulfilled: (value: R) => U, onRejected: (error: any) => Promise.Thenable<U>, onProgress?: (note: any) => any): Promise<U>;
+	done<U>(onFulfilled?: (value: R) => U, onRejected?: (error: any) => U, onProgress?: (note: any) => any): Promise<U>;
+
+	/**
+	 * Shorthand for `.then(null, null, handler);`. Attach a progress handler that will be called if this promise is progressed. Returns a new promise chained from this promise.
+	 */
+	progressed(handler: (note: any) => any): Promise<R>;
+
+	/**
+	 * Same as calling `Promise.delay(this, ms)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+	 */
+	delay(ms: number): Promise<R>;
+
+	/**
+	 * Returns a promise that will be fulfilled with this promise's fulfillment value or rejection reason. However, if this promise is not fulfilled or rejected within `ms` milliseconds, the returned promise is rejected with a `Promise.TimeoutError` instance.
+	 *
+	 * You may specify a custom error message with the `message` parameter.
+	 */
+	timeout(ms: number, message?: string): Promise<R>;
+
+	/**
+	 * Register a node-style callback on this promise. When this promise is is either fulfilled or rejected, the node callback will be called back with the node.js convention where error reason is the first argument and success value is the second argument. The error argument will be `null` in case of success.
+	 * Returns back this promise instead of creating a new one. If the `callback` argument is not a function, this method does not do anything.
+	 */
+	nodeify(callback: (err: any, value?: R) => void): Promise<R>;
+	nodeify(...sink: any[]): void;
+
+	/**
+	 * Marks this promise as cancellable. Promises by default are not cancellable after v0.11 and must be marked as such for `.cancel()` to have any effect. Marking a promise as cancellable is infectious and you don't need to remark any descendant promise.
+	 */
+	cancellable(): Promise<R>;
+
+	/**
+	 * Cancel this promise. The cancellation will propagate to farthest cancellable ancestor promise which is still pending.
+	 *
+	 * That ancestor will then be rejected with a `CancellationError` (get a reference from `Promise.CancellationError`) object as the rejection reason.
+	 *
+	 * In a promise rejection handler you may check for a cancellation by seeing if the reason object has `.name === "Cancel"`.
+	 *
+	 * Promises are by default not cancellable. Use `.cancellable()` to mark a promise as cancellable.
+	 */
+	// TODO what to do with this?
+	cancel<U>(): Promise<U>;
+
+	/**
+	 * Like `.then()`, but cancellation of the the returned promise or any of its descendant will not propagate cancellation to this promise or this promise's ancestors.
+	 */
+	fork<U>(onFulfilled: (value: R) => Promise.Thenable<U>, onRejected: (error: any) => Promise.Thenable<U>, onProgress?: (note: any) => any): Promise<U>;
+	fork<U>(onFulfilled: (value: R) => Promise.Thenable<U>, onRejected?: (error: any) => U, onProgress?: (note: any) => any): Promise<U>;
+	fork<U>(onFulfilled: (value: R) => U, onRejected: (error: any) => Promise.Thenable<U>, onProgress?: (note: any) => any): Promise<U>;
+	fork<U>(onFulfilled?: (value: R) => U, onRejected?: (error: any) => U, onProgress?: (note: any) => any): Promise<U>;
+
+	/**
+	 * Create an uncancellable promise based on this promise.
+	 */
+	uncancellable(): Promise<R>;
+
+	/**
+	 * See if this promise can be cancelled.
+	 */
+	isCancellable(): boolean;
+
+	/**
+	 * See if this `promise` has been fulfilled.
+	 */
+	isFulfilled(): boolean;
+
+	/**
+	 * See if this `promise` has been rejected.
+	 */
+	isRejected(): boolean;
+
+	/**
+	 * See if this `promise` is still defer.
+	 */
+	isPending(): boolean;
+
+	/**
+	 * See if this `promise` is resolved -> either fulfilled or rejected.
+	 */
+	isResolved(): boolean;
+
+	/**
+	 * Synchronously inspect the state of this `promise`. The `PromiseInspection` will represent the state of the promise as snapshotted at the time of calling `.inspect()`.
+	 */
+	inspect(): Promise.Inspection<R>;
+
+	/**
+	 * This is a convenience method for doing:
+	 *
+	 * <code>
+	 * promise.then(function(obj){
+	*     return obj[propertyName].call(obj, arg...);
+	* });
+	 * </code>
+	 */
+	call(propertyName: string, ...args: any[]): Promise<any>;
+
+	/**
+	 * This is a convenience method for doing:
+	 *
+	 * <code>
+	 * promise.then(function(obj){
+	*     return obj[propertyName];
+	* });
+	 * </code>
+	 */
+	// TODO find way to fix get()
+	// get<U>(propertyName: string): Promise<U>;
+
+	/**
+	 * Convenience method for:
+	 *
+	 * <code>
+	 * .then(function() {
+	*    return value;
+	* });
+	 * </code>
+	 *
+	 * in the case where `value` doesn't change its value. That means `value` is bound at the time of calling `.return()`
+	 *
+	 * Alias `.thenReturn();` for compatibility with earlier ECMAScript version.
+	 */
+	return<U>(value?: U): Promise<U>;
+	thenReturn<U>(value?: U): Promise<U>;
+
+	/**
+	 * Convenience method for:
+	 *
+	 * <code>
+	 * .then(function() {
+	*    throw reason;
+	* });
+	 * </code>
+	 * Same limitations apply as with `.return()`.
+	 *
+	 * Alias `.thenThrow();` for compatibility with earlier ECMAScript version.
+	 */
+	throw(reason: Error): Promise<R>;
+	thenThrow(reason: Error): Promise<R>;
+
+	/**
+	 * Convert to String.
+	 */
+	toString(): string;
+
+	/**
+	 * This is implicitly called by `JSON.stringify` when serializing the object. Returns a serialized representation of the `Promise`.
+	 */
+	toJSON(): Object;
+
+	/**
+	 * Like calling `.then`, but the fulfillment value or rejection reason is assumed to be an array, which is flattened to the formal parameters of the handlers.
+	 */
+	// TODO how to model instance.spread()? like Q?
+	spread<U>(onFulfill: Function, onReject?: (reason: any) => Promise.Thenable<U>): Promise<U>;
+	spread<U>(onFulfill: Function, onReject?: (reason: any) => U): Promise<U>;
+	/*
+	// TODO or something like this?
+	spread<U, W>(onFulfill: (...values: W[]) => Promise.Thenable<U>, onReject?: (reason: any) => Promise.Thenable<U>): Promise<U>;
+	spread<U, W>(onFulfill: (...values: W[]) => Promise.Thenable<U>, onReject?: (reason: any) => U): Promise<U>;
+	spread<U, W>(onFulfill: (...values: W[]) => U, onReject?: (reason: any) => Promise.Thenable<U>): Promise<U>;
+	spread<U, W>(onFulfill: (...values: W[]) => U, onReject?: (reason: any) => U): Promise<U>;
+	*/
+	/**
+	 * Same as calling `Promise.all(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+	 */
+	// TODO type inference from array-resolving promise?
+	all<U>(): Promise<U[]>;
+
+	/**
+	 * Same as calling `Promise.props(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+	 */
+	// TODO how to model instance.props()?
+	props(): Promise<Object>;
+
+	/**
+	 * Same as calling `Promise.settle(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+	 */
+	// TODO type inference from array-resolving promise?
+	settle<U>(): Promise<Promise.Inspection<U>[]>;
+
+	/**
+	 * Same as calling `Promise.any(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+	 */
+	// TODO type inference from array-resolving promise?
+	any<U>(): Promise<U>;
+
+	/**
+	 * Same as calling `Promise.some(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+	 */
+	// TODO type inference from array-resolving promise?
+	some<U>(count: number): Promise<U[]>;
+
+	/**
+	 * Same as calling `Promise.race(thisPromise, count)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+	 */
+	// TODO type inference from array-resolving promise?
+	race<U>(): Promise<U>;
+
+	/**
+	 * Same as calling `Promise.map(thisPromise, mapper)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+	 */
+	// TODO type inference from array-resolving promise?
+	map<Q, U>(mapper: (item: Q, index: number, arrayLength: number) => Promise.Thenable<U>): Promise<U>;
+	map<Q, U>(mapper: (item: Q, index: number, arrayLength: number) => U): Promise<U>;
+
+	/**
+	 * Same as calling `Promise.reduce(thisPromise, Function reducer, initialValue)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+	 */
+	// TODO type inference from array-resolving promise?
+	reduce<Q, U>(reducer: (memo: U, item: Q, index: number, arrayLength: number) => Promise.Thenable<U>, initialValue?: U): Promise<U>;
+	reduce<Q, U>(reducer: (memo: U, item: Q, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
+
+	/**
+	 * Same as calling ``Promise.filter(thisPromise, filterer)``. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+	 */
+	// TODO type inference from array-resolving promise?
+	filter<U>(filterer: (item: U, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<U>;
+	filter<U>(filterer: (item: U, index: number, arrayLength: number) => boolean): Promise<U>;
 }
 
-interface ArrayLike {
-    length:number;
-}
-
-declare class Promise<R> implements Thenable<R> {
-    /**
-     * Create a new promise. The passed in function will receive functions `resolve` and `reject` as its arguments which can be called to seal the fate of the created promise.
-     */
-    constructor(callback:(resolve:(result:R) => void, reject:(error:any) => void) => void);
-    constructor(callback:(resolve:(thenable:Thenable<R>) => void, reject:(error:any) => void) => void);
-
-    /**
-     * Promises/A+ `.then()` with progress handler. Returns a new promise chained from this promise. The new promise will be rejected or resolved dedefer on the passed `fulfilledHandler`, `rejectedHandler` and the state of this promise.
-     */
-    then<U>(onFulfill:(value:R) => Thenable<U>, onReject:(error:any) => Thenable<U>, onProgress?:(note:any) => any):Promise<U>;
-    then<U>(onFulfill:(value:R) => Thenable<U>, onReject?:(error:any) => U, onProgress?:(note:any) => any):Promise<U>;
-    then<U>(onFulfill:(value:R) => U, onReject:(error:any) => Thenable<U>, onProgress?:(note:any) => any):Promise<U>;
-    then<U>(onFulfill?:(value:R) => U, onReject?:(error:any) => U, onProgress?:(note:any) => any):Promise<U>;
-
-    /**
-     * This is a catch-all exception handler, shortcut for calling `.then(null, handler)` on this promise. Any exception happening in a `.then`-chain will propagate to nearest `.catch` handler.
-     *
-     * Alias `.caught();` for compatibility with earlier ECMAScript version.
-     */
-    catch<U>(onReject?:(error:any) => Thenable<U>):Promise<U>;
-    caught<U>(onReject?:(error:any) => Thenable<U>):Promise<U>;
-
-    catch<U>(onReject?:(error:any) => U):Promise<U>;
-    caught<U>(onReject?:(error:any) => U):Promise<U>;
-
-    /**
-     * This extends `.catch` to work more like catch-clauses in languages like Java or C#. Instead of manually checking `instanceof` or `.name === "SomeError"`, you may specify a number of error constructors which are eligible for this catch handler. The catch handler that is first met that has eligible constructors specified, is the one that will be called.
-     *
-     * This method also supports predicate-based filters. If you pass a predicate function instead of an error constructor, the predicate will receive the error as an argument. The return result of the predicate will be used determine whether the error handler should be called.
-     *
-     * Alias `.caught();` for compatibility with earlier ECMAScript version.
-     */
-    catch<U>(predicate:(error:any) => boolean, onReject:(error:any) => Thenable<U>):Promise<U>;
-    caught<U>(predicate:(error:any) => boolean, onReject:(error:any) => Thenable<U>):Promise<U>;
-
-    catch<U>(predicate:(error:any) => boolean, onReject:(error:any) => U):Promise<U>;
-    caught<U>(predicate:(error:any) => boolean, onReject:(error:any) => U):Promise<U>;
-
-    catch<U>(ErrorClass:Function, onReject:(error:any) => Thenable<U>):Promise<U>;
-    caught<U>(ErrorClass:Function, onReject:(error:any) => Thenable<U>):Promise<U>;
-
-    catch<U>(ErrorClass:Function, onReject:(error:any) => U):Promise<U>;
-    caught<U>(ErrorClass:Function, onReject:(error:any) => U):Promise<U>;
-
-    /**
-     * Like `.catch` but instead of catching all types of exceptions, it only catches those that don't originate from thrown errors but rather from explicit rejections.
-     */
-    error<U>(onReject:(reason:any) => Thenable<U>):Promise<U>;
-    error<U>(onReject:(reason:any) => U):Promise<U>;
-
-    /**
-     * Pass a handler that will be called regardless of this promise's fate. Returns a new promise chained from this promise. There are special semantics for `.finally()` in that the final value cannot be modified from the handler.
-     *
-     * Alias `.lastly();` for compatibility with earlier ECMAScript version.
-     */
-    finally(handler:(value:R) => Thenable<R>):Promise<R>;
-    finally(handler:(value:R) => R):Promise<R>;
-
-    lastly(handler:(value:R) => Thenable<R>):Promise<R>;
-    lastly(handler:(value:R) => R):Promise<R>;
-
-    /**
-     * Create a promise that follows this promise, but is bound to the given `thisArg` value. A bound promise will call its handlers with the bound value set to `this`. Additionally promises derived from a bound promise will also be bound promises with the same `thisArg` binding as the original promise.
-     */
-    bind(thisArg:any):Promise<R>;
-
-    /**
-     * Like `.then()`, but any unhandled rejection that ends up here will be thrown as an error.
-     */
-    done<U>(onFulfilled:(value:R) => Thenable<U>, onRejected:(error:any) => Thenable<U>, onProgress?:(note:any) => any):Promise<U>;
-    done<U>(onFulfilled:(value:R) => Thenable<U>, onRejected?:(error:any) => U, onProgress?:(note:any) => any):Promise<U>;
-    done<U>(onFulfilled:(value:R) => U, onRejected:(error:any) => Thenable<U>, onProgress?:(note:any) => any):Promise<U>;
-    done<U>(onFulfilled?:(value:R) => U, onRejected?:(error:any) => U, onProgress?:(note:any) => any):Promise<U>;
-
-    /**
-     * Shorthand for `.then(null, null, handler);`. Attach a progress handler that will be called if this promise is progressed. Returns a new promise chained from this promise.
-     */
-    progressed(handler:(note:any) => any):Promise<R>;
-
-    /**
-     * Same as calling `Promise.delay(this, ms)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-     */
-    delay(ms:number):Promise<R>;
-
-    /**
-     * Returns a promise that will be fulfilled with this promise's fulfillment value or rejection reason. However, if this promise is not fulfilled or rejected within `ms` milliseconds, the returned promise is rejected with a `Promise.TimeoutError` instance.
-     *
-     * You may specify a custom error message with the `message` parameter.
-     */
-    timeout(ms:number, message?:string):Promise<R>;
-
-    /**
-     * Register a node-style callback on this promise. When this promise is is either fulfilled or rejected, the node callback will be called back with the node.js convention where error reason is the first argument and success value is the second argument. The error argument will be `null` in case of success.
-     * Returns back this promise instead of creating a new one. If the `callback` argument is not a function, this method does not do anything.
-     */
-    nodeify(callback:(err:any, value?:R) => void):Promise<R>;
-    nodeify(...sink:any[]):void;
-
-    /**
-     * Marks this promise as cancellable. Promises by default are not cancellable after v0.11 and must be marked as such for `.cancel()` to have any effect. Marking a promise as cancellable is infectious and you don't need to remark any descendant promise.
-     */
-    cancellable():Promise<R>;
-
-    /**
-     * Cancel this promise. The cancellation will propagate to farthest cancellable ancestor promise which is still pending.
-     *
-     * That ancestor will then be rejected with a `CancellationError` (get a reference from `Promise.CancellationError`) object as the rejection reason.
-     *
-     * In a promise rejection handler you may check for a cancellation by seeing if the reason object has `.name === "Cancel"`.
-     *
-     * Promises are by default not cancellable. Use `.cancellable()` to mark a promise as cancellable.
-     */
-    //TODO what to do with this?
-    cancel<U>():Promise<U>;
-
-    /**
-     * Like `.then()`, but cancellation of the the returned promise or any of its descendant will not propagate cancellation to this promise or this promise's ancestors.
-     */
-    fork<U>(onFulfilled:(value:R) => Thenable<U>, onRejected:(error:any) => Thenable<U>, onProgress?:(note:any) => any):Promise<U>;
-    fork<U>(onFulfilled:(value:R) => Thenable<U>, onRejected?:(error:any) => U, onProgress?:(note:any) => any):Promise<U>;
-    fork<U>(onFulfilled:(value:R) => U, onRejected:(error:any) => Thenable<U>, onProgress?:(note:any) => any):Promise<U>;
-    fork<U>(onFulfilled?:(value:R) => U, onRejected?:(error:any) => U, onProgress?:(note:any) => any):Promise<U>;
-
-    /**
-     * Create an uncancellable promise based on this promise.
-     */
-    uncancellable():Promise<R>;
-
-    /**
-     * See if this promise can be cancelled.
-     */
-    isCancellable():boolean;
-
-    /**
-     * See if this `promise` has been fulfilled.
-     */
-    isFulfilled():boolean;
-
-    /**
-     * See if this `promise` has been rejected.
-     */
-    isRejected():boolean;
-
-    /**
-     * See if this `promise` is still defer.
-     */
-    isPending():boolean;
-
-    /**
-     * See if this `promise` is resolved -> either fulfilled or rejected.
-     */
-    isResolved():boolean;
-
-    /**
-     * Synchronously inspect the state of this `promise`. The `PromiseInspection` will represent the state of the promise as snapshotted at the time of calling `.inspect()`.
-     */
-    inspect():PromiseInspection<R>;
-
-    /**
-     * This is a convenience method for doing:
-     *
-     * <code>
-     * promise.then(function(obj){
-    *     return obj[propertyName].call(obj, arg...);
-    * });
-     * </code>
-     */
-    call(propertyName:string, ...args:any[]):Promise<any>;
-
-    /**
-     * This is a convenience method for doing:
-     *
-     * <code>
-     * promise.then(function(obj){
-    *     return obj[propertyName];
-    * });
-     * </code>
-     */
-    //TODO find way to fix get()
-    // get<U>(propertyName:string):Promise<U>;
-
-    /**
-     * Convenience method for:
-     *
-     * <code>
-     * .then(function() {
-    *    return value;
-    * });
-     * </code>
-     *
-     * in the case where `value` doesn't change its value. That means `value` is bound at the time of calling `.return()`
-     *
-     * Alias `.thenReturn();` for compatibility with earlier ECMAScript version.
-     */
-    return<U>(value?:U):Promise<U>;
-    thenReturn<U>(value?:U):Promise<U>;
-
-    /**
-     * Convenience method for:
-     *
-     * <code>
-     * .then(function() {
-    *    throw reason;
-    * });
-     * </code>
-     * Same limitations apply as with `.return()`.
-     *
-     * Alias `.thenThrow();` for compatibility with earlier ECMAScript version.
-     */
-    throw(reason:any):Promise<R>;
-    thenThrow(reason:any):Promise<R>;
-
-    /**
-     * Convert to String.
-     */
-    toString():string;
-
-    /**
-     * This is implicitly called by `JSON.stringify` when serializing the object. Returns a serialized representation of the `Promise`.
-     */
-    toJSON():Object;
-
-    /**
-     * Like calling `.then`, but the fulfillment value or rejection reason is assumed to be an array, which is flattened to the formal parameters of the handlers.
-     */
-    //TODO how to model instance.spread()?
-    // like Q?
-    //spread<U>(onFulfilled: Function, onRejected: Function): Promise<U>;
-    /*
-    spread<U, W>(onFulfill:(...values:W[]) => Thenable<U>, onReject?:(reason:any) => Thenable<U>):Promise<U>;
-    spread<U, W>(onFulfill:(...values:W[]) => Thenable<U>, onReject?:(reason:any) => U):Promise<U>;
-    spread<U, W>(onFulfill:(...values:W[]) => U, onReject?:(reason:any) => Thenable<U>):Promise<U>;
-    spread<U, W>(onFulfill:(...values:W[]) => U, onReject?:(reason:any) => U):Promise<U>;
-    */
-    /**
-     * Same as calling `Promise.all(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-     */
-    //TODO how to model instance.all()?
-    all<U>():Promise<U[]>;
-
-    /**
-     * Same as calling `Promise.props(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-     */
-    //TODO how to model instance.props()?
-    props():Promise<Object>;
-
-    /**
-     * Same as calling `Promise.settle(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-     */
-    //TODO how to model instance.settle()?
-    settle<U>():Promise<PromiseInspection<U>[]>;
-
-    /**
-     * Same as calling `Promise.any(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-     */
-    //TODO how to model instance.any()?
-    any<U>():Promise<U>;
-
-    /**
-     * Same as calling `Promise.some(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-     */
-    //TODO how to model instance.some()?
-    some<U>(count:number):Promise<U[]>;
-
-    /**
-     * Same as calling `Promise.race(thisPromise, count)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-     */
-    //TODO how to model instance.race()?
-    race<U>():Promise<U>;
-
-    /**
-     * Same as calling `Promise.map(thisPromise, mapper)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-     */
-    //TODO how to model instance.map()?
-    map<U>(mapper:(item:R, index:number, arrayLength:number) => Thenable<U>):Promise<U>;
-    map<U>(mapper:(item:R, index:number, arrayLength:number) => U):Promise<U>;
-
-    /**
-     * Same as calling `Promise.reduce(thisPromise, Function reducer, initialValue)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-     */
-    //TODO how to model instance.reduce()?
-    reduce<U>(reducer:(total:number, current:R, index:number, arrayLength:number) => Thenable<U>, initialValue?:any):Promise<U>;
-    reduce<U>(reducer:(total:number, current:R, index:number, arrayLength:number) => U, initialValue?:any):Promise<U>;
-
-    /**
-     * Same as calling ``Promise.filter(thisPromise, filterer)``. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
-     */
-    //TODO how to model instance.filter()?
-    filter<U>(filterer:(item:R, index:number, arrayLength:number) => Thenable<U>):Promise<U>;
-    filter<U>(filterer:(item:R, index:number, arrayLength:number) => U):Promise<U>;
-}
-
-interface PromiseResolver<R> {
-    /**
-     * Resolve the underlying promise with `value` as the resolution value. If `value` is a thenable or a promise, the underlying promise will assume its state.
-     */
-    resolve(value:R):void;
-
-    /**
-     * Reject the underlying promise with `reason` as the rejection reason.
-     */
-    reject(reason:any):void;
-
-    /**
-     * Progress the underlying promise with `value` as the progression value.
-     */
-    progress(value:any):void;
-
-    /**
-     * Gives you a callback representation of the `PromiseResolver`. Note that this is not a method but a property. The callback accepts error object in first argument and success values on the 2nd parameter and the rest, I.E. node js conventions.
-     *
-     * If the the callback is called with multiple success values, the resolver fullfills its promise with an array of the values.
-     */
-    //TODO specify resolver callback
-    callback:Function;
-}
-
-interface PromiseInspection<R> {
-    /**
-     * See if the underlying promise was fulfilled at the creation time of this inspection object.
-     */
-    isFulfilled():boolean;
-
-    /**
-     * See if the underlying promise was rejected at the creation time of this inspection object.
-     */
-    isRejected():boolean;
-
-    /**
-     * See if the underlying promise was defer at the creation time of this inspection object.
-     */
-    isPending():boolean;
-
-    /**
-     * Get the fulfillment value of the underlying promise. Throws if the promise wasn't fulfilled at the creation time of this inspection object.
-     *
-     * throws `TypeError`
-     */
-    value():R;
-
-    /**
-     * Get the rejection reason for the underlying promise. Throws if the promise wasn't rejected at the creation time of this inspection object.
-     *
-     * throws `TypeError`
-     */
-    error():any;
-}
 declare module Promise {
-    /**
-     * Start the chain of promises with `Promise.try`. Any synchronous exceptions will be turned into rejections on the returned promise.
-     *
-     * Note about second argument: if it's specifically a true array, its values become respective arguments for the function call. Otherwise it is passed as is as the first argument for the function call.
-     *
-     * Alias for `attempt();` for compatibility with earlier ECMAScript version.
-     */
-    //TODO find way to enable try() without tsc borking
-    // see also: https://typescript.codeplex.com/workitem/2194
-    /*
-    function try<R>(fn:() => Thenable<R>, args?:any[], ctx?:any):Promise<R>;
-    function try<R>(fn:() => R, args?:any[], ctx?:any):Promise<R>;
-    // custom array-like
-    function try<R>(fn:() => Thenable<R>, args?:ArrayLike, ctx?:any):Promise<R>;
-    function try<R>(fn:() => R, args?:ArrayLike, ctx?:any):Promise<R>;
-    */
 
-    function attempt<R>(fn:() => Thenable<R>, args?:any[], ctx?:any):Promise<R>;
-    function attempt<R>(fn:() => R, args?:any[], ctx?:any):Promise<R>;
-    // custom array-like
-    function attempt<R>(fn:() => Thenable<R>, args?:ArrayLike, ctx?:any):Promise<R>;
-    function attempt<R>(fn:() => R, args?:ArrayLike, ctx?:any):Promise<R>;
+	export interface Thenable<R> {
+		then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected: (error: any) => Thenable<U>): Thenable<U>;
+		then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected?: (error: any) => U): Thenable<U>;
+		then<U>(onFulfilled: (value: R) => U, onRejected: (error: any) => Thenable<U>): Thenable<U>;
+		then<U>(onFulfilled?: (value: R) => U, onRejected?: (error: any) => U): Thenable<U>;
+	}
 
-    /**
-     * Returns a new function that wraps the given function `fn`. The new function will always return a promise that is fulfilled with the original functions return values or rejected with thrown exceptions from the original function.
-     * This method is convenient when a function can sometimes return synchronously or throw synchronously.
-     */
-    function method(fn:Function):Function;
+	export interface Resolver<R> {
+		/**
+		 * Resolve the underlying promise with `value` as the resolution value. If `value` is a thenable or a promise, the underlying promise will assume its state.
+		 */
+		resolve(value: R): void;
 
-    /**
-     * Create a promise that is resolved with the given `value`. If `value` is a thenable or promise, the returned promise will assume its state.
-     */
-    function resolve<R>(value:Thenable<R>):Promise<R>;
-    function resolve<R>(value:R):Promise<R>;
+		/**
+		 * Reject the underlying promise with `reason` as the rejection reason.
+		 */
+		reject(reason: any): void;
 
-    /**
-     * Create a promise that is rejected with the given `reason`.
-     */
-    function reject(reason:any):Promise<void>;
+		/**
+		 * Progress the underlying promise with `value` as the progression value.
+		 */
+		progress(value: any): void;
 
-    /**
-     * Create a promise with undecided fate and return a `PromiseResolver` to control it. See resolution?:Promise(#promise-resolution).
-     */
-    function defer<R>():PromiseResolver<R>;
+		/**
+		 * Gives you a callback representation of the `PromiseResolver`. Note that this is not a method but a property. The callback accepts error object in first argument and success values on the 2nd parameter and the rest, I.E. node js conventions.
+		 *
+		 * If the the callback is called with multiple success values, the resolver fullfills its promise with an array of the values.
+		 */
+			// TODO specify resolver callback
+		callback: Function;
+	}
 
-    /**
-     * Cast the given `value` to a trusted promise. If `value` is already a trusted `Promise`, it is returned as is. If `value` is not a thenable, a fulfilled is:Promise returned with `value` as its fulfillment value. If `value` is a thenable (Promise-like object, like those returned by jQuery's `$.ajax`), returns a trusted that:Promise assimilates the state of the thenable.
-     */
-    function cast<R>(value:Thenable<R>):Promise<R>;
-    function cast<R>(value:R):Promise<R>;
+	export interface Inspection<R> {
+		/**
+		 * See if the underlying promise was fulfilled at the creation time of this inspection object.
+		 */
+		isFulfilled(): boolean;
 
-    /**
-     * Sugar for `Promise.resolve(undefined).bind(thisArg);`. See `.bind()`.
-     */
-    function bind(thisArg:any):Promise<void>;
+		/**
+		 * See if the underlying promise was rejected at the creation time of this inspection object.
+		 */
+		isRejected(): boolean;
 
-    /**
-     * See if `value` is a trusted Promise.
-     */
-    function is(value:any):boolean;
+		/**
+		 * See if the underlying promise was defer at the creation time of this inspection object.
+		 */
+		isPending(): boolean;
 
-    /**
-     * Call this right after the library is loaded to enabled long stack traces. Long stack traces cannot be disabled after being enabled, and cannot be enabled after promises have alread been created. Long stack traces imply a substantial performance penalty, around 4-5x for throughput and 0.5x for latency.
-     */
-    function longStackTraces():void;
+		/**
+		 * Get the fulfillment value of the underlying promise. Throws if the promise wasn't fulfilled at the creation time of this inspection object.
+		 *
+		 * throws `TypeError`
+		 */
+		value(): R;
 
-    /**
-     * Returns a promise that will be fulfilled with `value` (or `undefined`) after given `ms` milliseconds. If `value` is a promise, the delay will start counting down when it is fulfilled and the returned promise will be fulfilled with the fulfillment value of the `value` promise.
-     */
-    //TODO enable more overloads
-    function delay<R>(value:Thenable<R>, ms:number):Promise<R>;
-    // function delay<R>(value:R, ms:number):Promise<R>;
-    function delay(ms:number):Promise<void>;
+		/**
+		 * Get the rejection reason for the underlying promise. Throws if the promise wasn't rejected at the creation time of this inspection object.
+		 *
+		 * throws `TypeError`
+		 */
+		error(): any;
+	}
 
-    /**
-     * Returns a function that will wrap the given `nodeFunction`. Instead of taking a callback, the returned function will return a promise whose fate is decided by the callback behavior of the given node function. The node function should conform to node.js convention of accepting a callback as last argument and calling that callback with error as the first argument and success value on the second argument.
-     *
-     * If the `nodeFunction` calls its callback with multiple success values, the fulfillment value will be an array of them.
-     *
-     * If you pass a `receiver`, the `nodeFunction` will be called as a method on the `receiver`.
-     */
-    //TODO how to model promisify?
-    function promisify(nodeFunction:Function, receiver?:any):Function;
+	/**
+	 * Start the chain of promises with `Promise.try`. Any synchronous exceptions will be turned into rejections on the returned promise.
+	 *
+	 * Note about second argument: if it's specifically a true array, its values become respective arguments for the function call. Otherwise it is passed as is as the first argument for the function call.
+	 *
+	 * Alias for `attempt();` for compatibility with earlier ECMAScript version.
+	 */
+	// TODO find way to enable try() without tsc borking
+	// see also: https://typescript.codeplex.com/workitem/2194
+	/*
+	export function try<R>(fn: () => Promise.Thenable<R>, args?: any[], ctx?: any): Promise<R>;
+	export function try<R>(fn: () => R, args?: any[], ctx?: any): Promise<R>;
+	*/
 
-    /**
-     * Promisifies the entire object by going through the object's properties and creating an async equivalent of each function on the object and its prototype chain. The promisified method name will be the original method name postfixed with `Async`. Returns the input object.
-     *
-     * Note that the original methods on the object are not overwritten but new methods are created with the `Async`-postfix. For example, if you `promisifyAll()` the node.js `fs` object use `fs.statAsync()` to call the promisified `stat` method.
-     */
-    //TODO how to model promisifyAll?
-    function promisifyAll(target:Object):Object;
+	export function attempt<R>(fn: () => Promise.Thenable<R>, args?: any[], ctx?: any): Promise<R>;
+	export function attempt<R>(fn: () => R, args?: any[], ctx?: any): Promise<R>;
 
-    /**
-     * Returns a function that can use `yield` to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch.
-     */
-    //TODO fix coroutine GeneratorFunction
-    function coroutine<R>(generatorFunction:Function):Function;
+	/**
+	 * Returns a new function that wraps the given function `fn`. The new function will always return a promise that is fulfilled with the original functions return values or rejected with thrown exceptions from the original function.
+	 * This method is convenient when a function can sometimes return synchronously or throw synchronously.
+	 */
+	export function method(fn: Function): Function;
 
-    /**
-     * Spawn a coroutine which may yield promises to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch.
-     */
-    //TODO fix spawn GeneratorFunction
-    function spawn<R>(generatorFunction:Function):Promise<R>;
+	/**
+	 * Create a promise that is resolved with the given `value`. If `value` is a thenable or promise, the returned promise will assume its state.
+	 */
+	export function resolve<R>(value: Promise.Thenable<R>): Promise<R>;
+	export function resolve<R>(value: R): Promise<R>;
 
-    /**
-     * This is relevant to browser environments with no module loader.
-     *
-     * Release control of the `Promise` namespace to whatever it was before this library was loaded. Returns a reference to the library namespace so you can attach it to something else.
-     */
-    function noConflict():typeof Promise;
+	/**
+	 * Create a promise that is rejected with the given `reason`.
+	 */
+	export function reject(reason: any): Promise<void>;
 
-    /**
-     * Add `handler` as the handler to call when there is a possibly unhandled rejection. The default handler logs the error stack to stderr or `console.error` in browsers.
-     *
-     * Passing no value or a non-function will have the effect of removing any kind of handling for possibly unhandled rejections.
-     */
-    function onPossiblyUnhandledRejection(handler:(reason:any) => any):void;
+	/**
+	 * Create a promise with undecided fate and return a `PromiseResolver` to control it. See resolution?: Promise(#promise-resolution).
+	 */
+	export function defer<R>(): Promise.Resolver<R>;
 
-    /**
-     * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are fulfilled. The promise's fulfillment value is an array with fulfillment values at respective positions to the original array. If any promise in the array rejects, the returned promise is rejected with the rejection reason.
-     */
-    //TODO enable more overloads
-    // promise of array with promises of value
-    // function all<R>(values:Thenable<Thenable<R>[]>):Promise<R[]>;
-    // promise of array with values
-    // function all<R>(values:Thenable<R[]>):Promise<R[]>;
-    // array with promises of value
-    function all<R>(values:Thenable<R>[]):Promise<R[]>;
-    // array with values
-    function all<R>(values:R[]):Promise<R[]>;
+	/**
+	 * Cast the given `value` to a trusted promise. If `value` is already a trusted `Promise`, it is returned as is. If `value` is not a thenable, a fulfilled is: Promise returned with `value` as its fulfillment value. If `value` is a thenable (Promise-like object, like those returned by jQuery's `$.ajax`), returns a trusted that: Promise assimilates the state of the thenable.
+	 */
+	export function cast<R>(value: Promise.Thenable<R>): Promise<R>;
+	export function cast<R>(value: R): Promise<R>;
 
-    /**
-     * Like ``Promise.all`` but for object properties instead of array items. Returns a promise that is fulfilled when all the properties of the object are fulfilled. The promise's fulfillment value is an object with fulfillment values at respective keys to the original object. If any promise in the object rejects, the returned promise is rejected with the rejection reason.
-     *
-     * If `object` is a trusted `Promise`, then it will be treated as a promise for object rather than for its properties. All other objects are treated for their properties as is returned by `Object.keys` - the object's own enumerable properties.
-     *
-     * *The original object is not modified.*
-     */
-    // trusted promise for object
-    function props(object:Promise<Object>):Promise<Object>;
-    // object
-    function props(object:Object):Promise<Object>;
+	/**
+	 * Sugar for `Promise.resolve(undefined).bind(thisArg);`. See `.bind()`.
+	 */
+	export function bind(thisArg: any): Promise<void>;
 
-    /**
-     * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are either fulfilled or rejected. The fulfillment value is an array of ``PromiseInspection`` instances at respective positions in relation to the input array.
-     *
-     * *original:The array is not modified. The input array sparsity is retained in the resulting array.*
-     */
-    //TODO enable more overloads
-    // promise of array with promises of value
-    // function settle<R>(values:Thenable<Thenable<R>[]>):Promise<PromiseInspection<R>[]>;
-    // promise of array with values
-    // function settle<R>(values:Thenable<R[]>):Promise<PromiseInspection<R>[]>;
-    // array with promises of value
-    function settle<R>(values:Thenable<R>[]):Promise<PromiseInspection<R>[]>;
-    // array with values
-    function settle<R>(values:R[]):Promise<PromiseInspection<R>[]>;
+	/**
+	 * See if `value` is a trusted Promise.
+	 */
+	export function is(value: any): boolean;
 
-    /**
-     * Like `Promise.some()`, with 1 as `count`. However, if the promise fulfills, the fulfillment value is not an array of 1 but the value directly.
-     */
-    //TODO enable more overloads
-    // promise of array with promises of value
-    // function any<R>(values:Thenable<Thenable<R>[]>):Promise<R>;
-    // promise of array with values
-    // function any<R>(values:Thenable<R[]>):Promise<R>;
-    // array with promises of value
-    function any<R>(values:Thenable<R>[]):Promise<R>;
-    // array with values
-    function any<R>(values:R[]):Promise<R>;
+	/**
+	 * Call this right after the library is loaded to enabled long stack traces. Long stack traces cannot be disabled after being enabled, and cannot be enabled after promises have alread been created. Long stack traces imply a substantial performance penalty, around 4-5x for throughput and 0.5x for latency.
+	 */
+	export function longStackTraces(): void;
 
-    /**
-     * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled or rejected as soon as a promise in the array is fulfilled or rejected with the respective rejection reason or fulfillment value.
-     *
-     * **Note** If you pass empty array or a sparse array with no values, or a promise/thenable for such, it will be forever pending.
-     */
-    //TODO enable more overloads
-    // promise of array with promises of value
-    // function race<R>(values:Thenable<Thenable<R>[]>):Promise<R>;
-    // promise of array with values
-    // function race<R>(values:Thenable<R[]>):Promise<R>;
-    // array with promises of value
-    function race<R>(values:Thenable<R>[]):Promise<R>;    
-    // array with values
-    function race<R>(values:R[]):Promise<R>;
+	/**
+	 * Returns a promise that will be fulfilled with `value` (or `undefined`) after given `ms` milliseconds. If `value` is a promise, the delay will start counting down when it is fulfilled and the returned promise will be fulfilled with the fulfillment value of the `value` promise.
+	 */
+	// TODO enable more overloads
+	export function delay<R>(value: Promise.Thenable<R>, ms: number): Promise<R>;
+	export function delay<R>(value: R, ms: number): Promise<R>;
+	export function delay(ms: number): Promise<void>;
 
-    /**
-     * Initiate a competetive race between multiple promises or values (values will become immediately fulfilled promises). When `count` amount of promises have been fulfilled, the returned promise is fulfilled with an array that contains the fulfillment values of the winners in order of resolution.
-     *
-     * If too many promises are rejected so that the promise can never become fulfilled, it will be immediately rejected with an array of rejection reasons in the order they were thrown in.
-     *
-     * *The original array is not modified.*
-     */
-    //TODO enable more overloads
-    // promise of array with promises of value
-    // function some<R>(values:Thenable<Thenable<R>[]>, count:number):Promise<R>;
-    // promise of array with values
-    // function some<R>(values:Thenable<R[]>, count:number):Promise<R[]>;
-    // array with promises of value
-    function some<R>(values:Thenable<R>[], count:number):Promise<R[]>;
-    // array with values
-    function some<R>(values:R[], count:number):Promise<R[]>;
+	/**
+	 * Returns a function that will wrap the given `nodeFunction`. Instead of taking a callback, the returned function will return a promise whose fate is decided by the callback behavior of the given node function. The node function should conform to node.js convention of accepting a callback as last argument and calling that callback with error as the first argument and success value on the second argument.
+	 *
+	 * If the `nodeFunction` calls its callback with multiple success values, the fulfillment value will be an array of them.
+	 *
+	 * If you pass a `receiver`, the `nodeFunction` will be called as a method on the `receiver`.
+	 */
+	// TODO how to model promisify?
+	export function promisify(nodeFunction: Function, receiver?: any): Function;
 
-    /**
-     * Like `Promise.all()` but instead of having to pass an array, the array is generated from the passed variadic arguments.
-     */
-    //TODO not quite like Promise.all() or does it miss something?
-    // variadic array with promises of value
-    function join<R>(...values:Thenable<R>[]):Promise<R[]>;
-    // variadic array with values
-    function join<R>(...values:R[]):Promise<R[]>;
+	/**
+	 * Promisifies the entire object by going through the object's properties and creating an async equivalent of each function on the object and its prototype chain. The promisified method name will be the original method name postfixed with `Async`. Returns the input object.
+	 *
+	 * Note that the original methods on the object are not overwritten but new methods are created with the `Async`-postfix. For example, if you `promisifyAll()` the node.js `fs` object use `fs.statAsync()` to call the promisified `stat` method.
+	 */
+	// TODO how to model promisifyAll?
+	export function promisifyAll(target: Object): Object;
 
-    /**
-     * Map an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `mapper` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
-     *
-     * If the `mapper` function returns promises or thenables, the returned promise will wait for all the mapped results to be resolved as well.
-     *
-     * *The original array is not modified.*
-     */
-    //TODO enable more overloads
-    // promise of array with promises of value
-    // function map<R, U>(values:Thenable<Thenable<R>[]>, mapper:(item:R, index:number, arrayLength:number) => Thenable<U>):Promise<U[]>;
-    // function map<R, U>(values:Thenable<Thenable<R>[]>, mapper:(item:R, index:number, arrayLength:number) => U):Promise<U[]>;
+	/**
+	 * Returns a function that can use `yield` to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch.
+	 */
+	// TODO fix coroutine GeneratorFunction
+	export function coroutine<R>(generatorFunction: Function): Function;
 
-    // promise of array with values
-    // function map<R, U>(values:Thenable<R[]>, mapper:(item:R, index:number, arrayLength:number) => Thenable<U>):Promise<U[]>;
-    // function map<R, U>(values:Thenable<R[]>, mapper:(item:R, index:number, arrayLength:number) => U):Promise<U[]>;
+	/**
+	 * Spawn a coroutine which may yield promises to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch.
+	 */
+	// TODO fix spawn GeneratorFunction
+	export function spawn<R>(generatorFunction: Function): Promise<R>;
 
-    // array with promises of value
-    function map<R, U>(values:Thenable<R>[], mapper:(item:R, index:number, arrayLength:number) => Thenable<U>):Promise<U[]>;
-    function map<R, U>(values:Thenable<R>[], mapper:(item:R, index:number, arrayLength:number) => U):Promise<U[]>;
+	/**
+	 * This is relevant to browser environments with no module loader.
+	 *
+	 * Release control of the `Promise` namespace to whatever it was before this library was loaded. Returns a reference to the library namespace so you can attach it to something else.
+	 */
+	export function noConflict(): typeof Promise;
 
-    // array with values
-    function map<R, U>(values:R[], mapper:(item:R, index:number, arrayLength:number) => Thenable<U>):Promise<U[]>;
-    function map<R, U>(values:R[], mapper:(item:R, index:number, arrayLength:number) => U):Promise<U[]>;
+	/**
+	 * Add `handler` as the handler to call when there is a possibly unhandled rejection. The default handler logs the error stack to stderr or `console.error` in browsers.
+	 *
+	 * Passing no value or a non-function will have the effect of removing any kind of handling for possibly unhandled rejections.
+	 */
+	export function onPossiblyUnhandledRejection(handler: (reason: any) => any): void;
 
-    /**
-     * Reduce an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `reducer` function with the signature `(total, current, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
-     *
-     * If the reducer function returns a promise or a thenable, the result for the promise is awaited for before continuing with next iteration.
-     *
-     * *The original array is not modified. If no `intialValue` is given and the array doesn't contain at least 2 items, the callback will not be called and `undefined` is returned. If `initialValue` is given and the array doesn't have at least 1 item, `initialValue` is returned.*
-     */
-    //TODO enable more overloads
-    // promise of array with promises of value
-    // function reduce<R, U>(values:Thenable<Thenable<R>[]>, reducer:(total:U, current:R, index:number, arrayLength:number) => Thenable<U>, initialValue?:U):Promise<U>;
-    // function reduce<R, U>(values:Thenable<Thenable<R>[]>, reducer:(total:U, current:R, index:number, arrayLength:number) => U, initialValue?:U):Promise<U>;
+	/**
+	 * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are fulfilled. The promise's fulfillment value is an array with fulfillment values at respective positions to the original array. If any promise in the array rejects, the returned promise is rejected with the rejection reason.
+	 */
+	// TODO enable more overloads
+	// promise of array with promises of value
+	export function all<R>(values: Thenable<Thenable<R>[]>): Promise<R[]>;
+	// promise of array with values
+	export function all<R>(values: Thenable<R[]>): Promise<R[]>;
+	// array with promises of value
+	export function all<R>(values: Thenable<R>[]): Promise<R[]>;
+	// array with values
+	export function all<R>(values: R[]): Promise<R[]>;
 
-    // promise of array with values
-    // function reduce<R, U>(values:Thenable<R[]>, reducer:(total:U, current:R, index:number, arrayLength:number) => Thenable<U>, initialValue?:U):Promise<U>;
-    // function reduce<R, U>(values:Thenable<R[]>, reducer:(total:U, current:R, index:number, arrayLength:number) => U, initialValue?:U):Promise<U>;
+	/**
+	 * Like ``Promise.all`` but for object properties instead of array items. Returns a promise that is fulfilled when all the properties of the object are fulfilled. The promise's fulfillment value is an object with fulfillment values at respective keys to the original object. If any promise in the object rejects, the returned promise is rejected with the rejection reason.
+	 *
+	 * If `object` is a trusted `Promise`, then it will be treated as a promise for object rather than for its properties. All other objects are treated for their properties as is returned by `Object.keys` - the object's own enumerable properties.
+	 *
+	 * *The original object is not modified.*
+	 */
+	// TODO verify this is correct
+	// trusted promise for object
+	export function props(object: Promise<Object>): Promise<Object>;
+	// object
+	export function props(object: Object): Promise<Object>;
 
-    // array with promises of value
-    function reduce<R, U>(values:Thenable<R>[], reducer:(total:U, current:R, index:number, arrayLength:number) => Thenable<U>, initialValue?:U):Promise<U>;
-    function reduce<R, U>(values:Thenable<R>[], reducer:(total:U, current:R, index:number, arrayLength:number) => U, initialValue?:U):Promise<U>;
+	/**
+	 * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are either fulfilled or rejected. The fulfillment value is an array of ``PromiseInspection`` instances at respective positions in relation to the input array.
+	 *
+	 * *original: The array is not modified. The input array sparsity is retained in the resulting array.*
+	 */
+		// promise of array with promises of value
+	export function settle<R>(values: Thenable<Thenable<R>[]>): Promise<Promise.Inspection<R>[]>;
+	// promise of array with values
+	export function settle<R>(values: Thenable<R[]>): Promise<Promise.Inspection<R>[]>;
+	// array with promises of value
+	export function settle<R>(values: Thenable<R>[]): Promise<Promise.Inspection<R>[]>;
+	// array with values
+	export function settle<R>(values: R[]): Promise<Promise.Inspection<R>[]>;
 
-    // array with values
-    function reduce<R, U>(values:R[], reducer:(total:U, current:R, index:number, arrayLength:number) => Thenable<U>, initialValue?:U):Promise<U>;
-    function reduce<R, U>(values:R[], reducer:(total:U, current:R, index:number, arrayLength:number) => U, initialValue?:U):Promise<U>;
+	/**
+	 * Like `Promise.some()`, with 1 as `count`. However, if the promise fulfills, the fulfillment value is not an array of 1 but the value directly.
+	 */
+	// promise of array with promises of value
+	export function any<R>(values: Thenable<Thenable<R>[]>): Promise<R>;
+	// promise of array with values
+	export function any<R>(values: Thenable<R[]>): Promise<R>;
+	// array with promises of value
+	export function any<R>(values: Thenable<R>[]): Promise<R>;
+	// array with values
+	export function any<R>(values: R[]): Promise<R>;
 
-    /**
-     * Filter an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `filterer` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
-     *
-     * The return values from the filtered functions are coerced to booleans, with the exception of promises and thenables which are awaited for their eventual result.
-     *
-     * *The original array is not modified.
-     */
-    //TODO enable more overloads
-    // promise of array with promises of value
-    // function filter<R>(values:Thenable<Thenable<R>[]>, filterer:(item:R, index:number, arrayLength:number) => Thenable<boolean>):Promise<R[]>;
-    // function filter<R>(values:Thenable<Thenable<R>[]>, filterer:(item:R, index:number, arrayLength:number) => boolean):Promise<R[]>;
+	/**
+	 * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled or rejected as soon as a promise in the array is fulfilled or rejected with the respective rejection reason or fulfillment value.
+	 *
+	 * **Note** If you pass empty array or a sparse array with no values, or a promise/thenable for such, it will be forever pending.
+	 */
+	// promise of array with promises of value
+	export function race<R>(values: Thenable<Thenable<R>[]>): Promise<R>;
+	// promise of array with values
+	export function race<R>(values: Thenable<R[]>): Promise<R>;
+	// array with promises of value
+	export function race<R>(values: Thenable<R>[]): Promise<R>;
+	// array with values
+	export function race<R>(values: R[]): Promise<R>;
 
-    // promise of array with values
-    // function filter<R>(values:Thenable<R[]>, filterer:(item:R, index:number, arrayLength:number) => Thenable<boolean>):Promise<R[]>;
-    // function filter<R>(values:Thenable<R[]>, filterer:(item:R, index:number, arrayLength:number) => boolean):Promise<R[]>;
+	/**
+	 * Initiate a competetive race between multiple promises or values (values will become immediately fulfilled promises). When `count` amount of promises have been fulfilled, the returned promise is fulfilled with an array that contains the fulfillment values of the winners in order of resolution.
+	 *
+	 * If too many promises are rejected so that the promise can never become fulfilled, it will be immediately rejected with an array of rejection reasons in the order they were thrown in.
+	 *
+	 * *The original array is not modified.*
+	 */
+	// promise of array with promises of value
+	export function some<R>(values: Thenable<Thenable<R>[]>, count: number): Promise<R[]>;
+	// promise of array with values
+	export function some<R>(values: Thenable<R[]>, count: number): Promise<R[]>;
+	// array with promises of value
+	export function some<R>(values: Thenable<R>[], count: number): Promise<R[]>;
+	// array with values
+	export function some<R>(values: R[], count: number): Promise<R[]>;
 
-    // array with promises of value
-    function filter<R>(values:Thenable<R>[], filterer:(item:R, index:number, arrayLength:number) => Thenable<boolean>):Promise<R[]>;
-    function filter<R>(values:Thenable<R>[], filterer:(item:R, index:number, arrayLength:number) => boolean):Promise<R[]>;
+	/**
+	 * Like `Promise.all()` but instead of having to pass an array, the array is generated from the passed variadic arguments.
+	 */
+	// variadic array with promises of value
+	export function join<R>(...values: Thenable<R>[]): Promise<R[]>;
+	// variadic array with values
+	export function join<R>(...values: R[]): Promise<R[]>;
 
-    // array with values
-    function filter<R>(values:R[], filterer:(item:R, index:number, arrayLength:number) => Thenable<boolean>):Promise<R[]>;
-    function filter<R>(values:R[], filterer:(item:R, index:number, arrayLength:number) => boolean):Promise<R[]>;
+	/**
+	 * Map an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `mapper` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
+	 *
+	 * If the `mapper` function returns promises or thenables, the returned promise will wait for all the mapped results to be resolved as well.
+	 *
+	 * *The original array is not modified.*
+	 */
+	// promise of array with promises of value
+	export function map<R, U>(values: Thenable<Thenable<R>[]>, mapper: (item: R, index: number, arrayLength: number) => Thenable<U>): Promise<U[]>;
+	export function map<R, U>(values: Thenable<Thenable<R>[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
+
+	// promise of array with values
+	export function map<R, U>(values: Thenable<R[]>, mapper: (item: R, index: number, arrayLength: number) => Thenable<U>): Promise<U[]>;
+	export function map<R, U>(values: Thenable<R[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
+
+	// array with promises of value
+	export function map<R, U>(values: Thenable<R>[], mapper: (item: R, index: number, arrayLength: number) => Thenable<U>): Promise<U[]>;
+	export function map<R, U>(values: Thenable<R>[], mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
+
+	// array with values
+	export function map<R, U>(values: R[], mapper: (item: R, index: number, arrayLength: number) => Thenable<U>): Promise<U[]>;
+	export function map<R, U>(values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
+
+	/**
+	 * Reduce an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `reducer` function with the signature `(total, current, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
+	 *
+	 * If the reducer function returns a promise or a thenable, the result for the promise is awaited for before continuing with next iteration.
+	 *
+	 * *The original array is not modified. If no `intialValue` is given and the array doesn't contain at least 2 items, the callback will not be called and `undefined` is returned. If `initialValue` is given and the array doesn't have at least 1 item, `initialValue` is returned.*
+	 */
+	// promise of array with promises of value
+	export function reduce<R, U>(values: Thenable<Thenable<R>[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Thenable<U>, initialValue?: U): Promise<U>;
+	export function reduce<R, U>(values: Thenable<Thenable<R>[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
+
+	// promise of array with values
+	export function reduce<R, U>(values: Thenable<R[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Thenable<U>, initialValue?: U): Promise<U>;
+	export function reduce<R, U>(values: Thenable<R[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
+
+	// array with promises of value
+	export function reduce<R, U>(values: Thenable<R>[], reducer: (total: U, current: R, index: number, arrayLength: number) => Thenable<U>, initialValue?: U): Promise<U>;
+	export function reduce<R, U>(values: Thenable<R>[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
+
+	// array with values
+	export function reduce<R, U>(values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Thenable<U>, initialValue?: U): Promise<U>;
+	export function reduce<R, U>(values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
+
+	/**
+	 * Filter an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `filterer` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
+	 *
+	 * The return values from the filtered functions are coerced to booleans, with the exception of promises and thenables which are awaited for their eventual result.
+	 *
+	 * *The original array is not modified.
+	 */
+	// promise of array with promises of value
+	export function filter<R>(values: Thenable<Thenable<R>[]>, filterer: (item: R, index: number, arrayLength: number) => Thenable<boolean>): Promise<R[]>;
+	export function filter<R>(values: Thenable<Thenable<R>[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
+
+	// promise of array with values
+	export function filter<R>(values: Thenable<R[]>, filterer: (item: R, index: number, arrayLength: number) => Thenable<boolean>): Promise<R[]>;
+	export function filter<R>(values: Thenable<R[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
+
+	// array with promises of value
+	export function filter<R>(values: Thenable<R>[], filterer: (item: R, index: number, arrayLength: number) => Thenable<boolean>): Promise<R[]>;
+	export function filter<R>(values: Thenable<R>[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
+
+	// array with values
+	export function filter<R>(values: R[], filterer: (item: R, index: number, arrayLength: number) => Thenable<boolean>): Promise<R[]>;
+	export function filter<R>(values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
 }
 
 declare module 'bluebird' {
-export = Promise;
+	export = Promise;
 }

From a490e14f0121a8823d9bf4400de827e0d088456a Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Fri, 7 Mar 2014 18:38:29 +0100
Subject: [PATCH 060/309] Small fixes for bluebird generics

---
 bluebird/bluebird-tests.ts | 15 +++++++++++++++
 bluebird/bluebird.d.ts     | 13 ++++++++-----
 2 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/bluebird/bluebird-tests.ts b/bluebird/bluebird-tests.ts
index ff4b85e2e..e5d83db7a 100644
--- a/bluebird/bluebird-tests.ts
+++ b/bluebird/bluebird-tests.ts
@@ -264,6 +264,12 @@ fooProm = fooProm.finally((value: Foo) => {
 	// return is ignored
 	return fooThen;
 });
+fooProm = fooProm.finally((value: Foo) => {
+	// return is ignored
+});
+fooProm = fooProm.finally(() => {
+	// return is ignored
+});
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
@@ -275,6 +281,12 @@ fooProm = fooProm.lastly((value: Foo) => {
 	// return is ignored
 	return fooThen;
 });
+fooProm = fooProm.lastly((value: Foo) => {
+	// return is ignored
+});
+fooProm = fooProm.lastly(() => {
+	// return is ignored
+});
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
@@ -408,6 +420,9 @@ anyProm = fooProm.call(str, 1, 2, 3);
 barProm = fooProm.return(bar);
 barProm = fooProm.thenReturn(bar);
 
+voidProm = fooProm.return();
+voidProm = fooProm.thenReturn();
+
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 // fooProm
diff --git a/bluebird/bluebird.d.ts b/bluebird/bluebird.d.ts
index 13494cb82..0d57e49b0 100644
--- a/bluebird/bluebird.d.ts
+++ b/bluebird/bluebird.d.ts
@@ -6,9 +6,8 @@
 // ES6 model with generics overload was sourced and trans-multiplied from es6-promises.d.ts
 // By: Campredon <https://github.com/fdecampredon/>
 
-// Warning: recommended to use `tsc > v1.0.0` (critical bugs in generic code:
+// Warning: recommended to use `tsc > v0.9.7` (critical bugs in earlier generic code):
 // - https://github.com/borisyankov/DefinitelyTyped/issues/1563
-// - https://github.com/borisyankov/DefinitelyTyped/tree/def/bluebird
 
 // Note: replicate changes to all overloads in both definition and test file
 // Note: keep both static and instance members inline (so similar)
@@ -75,9 +74,11 @@ declare class Promise<R> implements Promise.Thenable<R> {
 	 */
 	finally(handler: (value: R) => Promise.Thenable<R>): Promise<R>;
 	finally(handler: (value: R) => R): Promise<R>;
+	finally(handler: (value: R) => void): Promise<R>;
 
 	lastly(handler: (value: R) => Promise.Thenable<R>): Promise<R>;
 	lastly(handler: (value: R) => R): Promise<R>;
+	lastly(handler: (value: R) => void): Promise<R>;
 
 	/**
 	 * Create a promise that follows this promise, but is bound to the given `thisArg` value. A bound promise will call its handlers with the bound value set to `this`. Additionally promises derived from a bound promise will also be bound promises with the same `thisArg` binding as the original promise.
@@ -212,8 +213,10 @@ declare class Promise<R> implements Promise.Thenable<R> {
 	 *
 	 * Alias `.thenReturn();` for compatibility with earlier ECMAScript version.
 	 */
-	return<U>(value?: U): Promise<U>;
-	thenReturn<U>(value?: U): Promise<U>;
+	return<U>(value: U): Promise<U>;
+	thenReturn<U>(value: U): Promise<U>;
+	return(): Promise<void>;
+	thenReturn(): Promise<void>;
 
 	/**
 	 * Convenience method for:
@@ -341,7 +344,7 @@ declare module Promise {
 		 *
 		 * If the the callback is called with multiple success values, the resolver fullfills its promise with an array of the values.
 		 */
-			// TODO specify resolver callback
+		// TODO specify resolver callback
 		callback: Function;
 	}
 

From 12366aca7ebaa383c5689844dfca35754d90de7b Mon Sep 17 00:00:00 2001
From: Josh Rosen <rosenville@gmail.com>
Date: Sat, 8 Mar 2014 17:10:29 -0800
Subject: [PATCH 061/309] Export as "rx" module for CommonJS loading.

---
 rx.js/rx.d.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index 51f4dae89..fa06b407a 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -354,3 +354,7 @@ declare module Rx {
 
 	export var AsyncSubject: AsyncSubjectStatic;
 }
+
+declare module "rx" {
+    export = Rx
+}

From f788ac6ca45061c34ff5fd3671a792f3432aafa1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=A1clav=20Oborn=C3=ADk?= <register.ufon@gmail.com>
Date: Sun, 9 Mar 2014 06:23:11 +0100
Subject: [PATCH 062/309] renamed 'next' intarface to 'Next'

---
 restify/restify.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/restify/restify.d.ts b/restify/restify.d.ts
index ca047e17d..2afacc520 100644
--- a/restify/restify.d.ts
+++ b/restify/restify.d.ts
@@ -152,12 +152,12 @@ declare module "restify" {
     overrides?: Object;
   }
 
-  interface next {
+  interface Next {
     (err?: any): any;
   }
 
   interface RequestHandler {
-    (req: Request, res: Response, next: next): any;
+    (req: Request, res: Response, next: Next): any;
   }
 
   export function createServer(options?: ServerOptions): Server;

From 5a8800501d86f8d0873f25b05d0c185ebc5cdfcf Mon Sep 17 00:00:00 2001
From: Greg Smith <smr.kyu@gmail.com>
Date: Sun, 9 Mar 2014 03:04:18 -0500
Subject: [PATCH 063/309] d3.js definitions: added a more complex Voronoi
 diagram test case, and updated definitions to pass

---
 d3/d3-tests.ts | 118 ++++++++++++++++++++++++++++++++++++++++++++++++-
 d3/d3.d.ts     |  56 ++++++++++++++++-------
 2 files changed, 156 insertions(+), 18 deletions(-)

diff --git a/d3/d3-tests.ts b/d3/d3-tests.ts
index 362f31ea0..aab65c06c 100644
--- a/d3/d3-tests.ts
+++ b/d3/d3-tests.ts
@@ -1160,7 +1160,7 @@ function azimuthalEquidistant() {
 }
  
 //Example from http://bl.ocks.org/mbostock/4060366
-function voroniTesselation() {
+function voronoiTesselation() {
     var width = 960,
         height = 500;
 
@@ -1195,6 +1195,122 @@ function voroniTesselation() {
     }
 }
 
+// Example from https://gist.github.com/christophermanning/1734663
+function forceDirectedVoronoi() {
+    var w = window.innerWidth > 960 ? 960 : (window.innerWidth || 960),
+        h = window.innerHeight > 500 ? 500 : (window.innerHeight || 500),
+        radius = 5.25,
+        links = [],
+        simulate = true,
+        zoomToAdd = true,
+        color = d3.scale.quantize().domain([10000, 7250]).range(["#dadaeb","#bcbddc","#9e9ac8","#807dba","#6a51a3","#54278f","#3f007d"])
+ 
+    var numVertices = (w*h) / 3000;
+    var vertices = d3.range(numVertices).map(function(i) {
+        var angle = radius * (i+10);
+        return <D3.Layout.GraphNode>{x: angle*Math.cos(angle)+(w/2), y: angle*Math.sin(angle)+(h/2)};
+    });
+    var d3_geom_voronoi = d3.geom.voronoi<D3.Layout.GraphNode>()
+        .x(function(d) { return d.x; })
+        .y(function(d) { return d.y; })
+    var prevEventScale = 1;
+    var zoom = d3.behavior.zoom().on("zoom", function(d,i) {
+        if (zoomToAdd){
+            if (d3.event.scale > prevEventScale) {
+                var angle = radius * vertices.length;
+                vertices.push(<D3.Layout.GraphNode>{x: angle*Math.cos(angle)+(w/2), y: angle*Math.sin(angle)+(h/2)})
+            } else if (vertices.length > 2 && d3.event.scale != prevEventScale) {
+                vertices.pop();
+            }
+            force.nodes(vertices).start()
+        } else {
+            if (d3.event.scale > prevEventScale) {
+                radius+= .01
+            } else {
+                radius -= .01
+            }
+            vertices.forEach(function(d, i) {
+                var angle = radius * (i+10);
+                vertices[i] = <D3.Layout.GraphNode>{x: angle*Math.cos(angle)+(w/2), y: angle*Math.sin(angle)+(h/2)};
+            });
+            force.nodes(vertices).start()
+        }
+        prevEventScale = d3.event.scale;
+    });
+ 
+    d3.select(window)
+        .on("keydown", function() {
+            // shift
+            if(d3.event.keyCode == 16) {
+                zoomToAdd = false
+            }
+     
+            // s
+            if(d3.event.keyCode == 83) {
+                simulate = !simulate
+                if(simulate) {
+                    force.start()
+                } else {
+                    force.stop()
+                }
+            }
+        })
+        .on("keyup", function() {
+            zoomToAdd = true
+        })
+ 
+    var svg = d3.select("#chart")
+        .append("svg")
+        .attr("width", w)
+        .attr("height", h)
+        .call(zoom)
+ 
+    var force = d3.layout.force()
+        .charge(-300)
+        .size([w, h])
+        .on("tick", update);
+ 
+    force.nodes(vertices).start();
+ 
+    var circle = <D3.UpdateSelection>svg.selectAll("circle");
+    var path = <D3.UpdateSelection>svg.selectAll("path");
+    var link = <D3.UpdateSelection>svg.selectAll("line");
+ 
+    function update() {
+        path = path.data(d3_geom_voronoi(vertices));
+        path.enter().append("path")
+            // drag node by dragging cell
+            .call(d3.behavior.drag()
+              .on("drag", function(d, i) {
+                  vertices[i] = <D3.Layout.GraphNode>{x: vertices[i].x + d3.event.dx, y: vertices[i].y + d3.event.dy}
+              })
+            )
+            .style("fill", function(d, i) { return color(0) })
+        path.attr("d", function(d) { return "M" + d.join("L") + "Z"; })
+            .transition().duration(150).style("fill", function(d, i) { return color(d3.geom.polygon(d).area()) })
+        path.exit().remove();
+ 
+        circle = circle.data(vertices)
+        circle.enter().append("circle")
+              .attr("r", 0)
+              .transition().duration(1000).attr("r", 5);
+        circle.attr("cx", function(d) { return d.x; })
+              .attr("cy", function(d) { return d.y; });
+        circle.exit().transition().attr("r", 0).remove();
+ 
+        link = link.data(d3_geom_voronoi.links(vertices))
+        link.enter().append("line")
+        link.attr("x1", function(d) { return d.source.x; })
+            .attr("y1", function(d) { return d.source.y; })
+            .attr("x2", function(d) { return d.target.x; })
+            .attr("y2", function(d) { return d.target.y; })
+ 
+        link.exit().remove()
+ 
+        if(!simulate) force.stop()
+    }
+}
+
 //Example from http://bl.ocks.org/mbostock/4341156
 function delaunayTesselation() {
     var width = 960,
diff --git a/d3/d3.d.ts b/d3/d3.d.ts
index 9f6965cfa..0b3f7e0b3 100644
--- a/d3/d3.d.ts
+++ b/d3/d3.d.ts
@@ -3211,11 +3211,11 @@ declare module D3 {
     // Geometry
     export module Geom {
         export interface Geom {
-            voronoi(): Voronoi;
+            voronoi<T>(): Voronoi<T>;
             /**
             * compute the Voronoi diagram for the specified points.
             */
-            voronoi(vertices?: Array<Vertice>): Array<Polygon>;
+            voronoi(vertices: Array<Vertice>): Array<Polygon>;
             /**
             * compute the Delaunay triangulation for the specified points.
             */
@@ -3296,48 +3296,58 @@ declare module D3 {
             y: number;
         }
 
-        export interface Voronoi {
+        export interface Voronoi<T> {
             /**
-            * compute the Voronoi diagram for the specified points.
+            * Compute the Voronoi diagram for the specified data.
             */
-            (vertices?: Array<Vertice>): Array<Polygon>;
+            (data: Array<T>): Array<Polygon>;
+            /**
+            * Compute the graph links for the Voronoi diagram for the specified data.
+            */
+            links(data: Array<T>): Array<Layout.GraphLink>;
+            /**
+            * Compute the triangles for the Voronoi diagram for the specified data.
+            */
+            triangles(data: Array<T>): Array<Array<number>>;
             x: {
                 /**
                 * Get the x-coordinate accessor.
                 */
-                (): (data: any, index ?: number) => number;
+                (): (data: T, index ?: number) => number;
+
                 /**
                 * Set the x-coordinate accessor.
                 *
                 * @param accessor The new accessor function
                 */
-                (accessor: (data: any) => number): Voronoi;
-                (accessor: (data: any, index: number) => number): Voronoi;
+                (accessor: (data: T, index: number) => number): Voronoi<T>;
+
                 /**
                 * Set the x-coordinate to a constant.
                 *
-                * @param cnst The new constant value.
+                * @param constant The new constant value.
                 */
-                (cnst: number): Voronoi;
+                (constant: number): Voronoi<T>;
             }
             y: {
                 /**
                 * Get the y-coordinate accessor.
                 */
-                (): (data: any, index ?: number) => number;
+                (): (data: T, index ?: number) => number;
+
                 /**
                 * Set the y-coordinate accessor.
                 *
-                * @param accessor The new accessor function.
+                * @param accessor The new accessor function
                 */
-                (accessor: (data: any) => number): Voronoi;
-                (accessor: (data: any, index: number) => number): Voronoi;
+                (accessor: (data: T, index: number) => number): Voronoi<T>;
+
                 /**
                 * Set the y-coordinate to a constant.
                 *
-                * @param cnst The new constant value.
+                * @param constant The new constant value.
                 */
-                (cnst: number): Voronoi;
+                (constant: number): Voronoi<T>;   
             }
             clipExtent: {
                 /**
@@ -3349,7 +3359,19 @@ declare module D3 {
                 *
                 * @param extent The new clip extent.
                 */
-                (extent: Array<Array<number>>): Voronoi;
+                (extent: Array<Array<number>>): Voronoi<T>;
+            }
+            size: {
+                /**
+                * Get the size.
+                */
+                (): Array<number>;
+                /**
+                * Set the size, equivalent to a clip extent starting from (0,0).
+                *
+                * @param size The new size.
+                */
+                (size: Array<number>): Voronoi<T>;
             }
         }
 

From 5be35e694ea6f9d5c22af4e27a969483ea8deec6 Mon Sep 17 00:00:00 2001
From: Greg Smith <smr.kyu@gmail.com>
Date: Sun, 9 Mar 2014 03:25:58 -0500
Subject: [PATCH 064/309] Added missing functions to d3 EnterSelection
 interface

---
 d3/d3.d.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/d3/d3.d.ts b/d3/d3.d.ts
index 8435e9fe4..2a616bdbb 100644
--- a/d3/d3.d.ts
+++ b/d3/d3.d.ts
@@ -812,6 +812,8 @@ declare module D3 {
         select: (selector: string) => Selection;
         empty: () => boolean;
         node: () => Element;
+        call: (callback: (selection: EnterSelection) => void) => EnterSelection;
+        size: () => number;
     }
 
     export interface UpdateSelection extends Selection {

From e7491baf9db166486d795523faf77e6627a09c0f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=A1clav=20Oborn=C3=ADk?= <register.ufon@gmail.com>
Date: Mon, 10 Mar 2014 12:15:15 +0100
Subject: [PATCH 065/309] Socket.io - added return type of SocketNamespace for
 authorization method

---
 socket.io/socket.io.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/socket.io/socket.io.d.ts b/socket.io/socket.io.d.ts
index 8d137d7af..3c85d7351 100644
--- a/socket.io/socket.io.d.ts
+++ b/socket.io/socket.io.d.ts
@@ -47,7 +47,7 @@ interface SocketNamespace {
 	send(data: any): any;
 	emit(ev: any, ...data:any[]): Socket;
 	socket(sid: any, readable: boolean): Socket;
-	authorization(fn: Function);
+	authorization(fn: Function): SocketNamespace;
 }
 
 interface SocketManager {

From 01dd203b6c91a7918020b379b18dac4d12c810eb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=A1clav=20Oborn=C3=ADk?= <register.ufon@gmail.com>
Date: Mon, 10 Mar 2014 12:19:57 +0100
Subject: [PATCH 066/309] Socket.io - moved interfaces from global evil
 namespace 'socket.io' module

---
 socket.io/socket.io.d.ts | 97 +++++++++++++++++++++-------------------
 1 file changed, 50 insertions(+), 47 deletions(-)

diff --git a/socket.io/socket.io.d.ts b/socket.io/socket.io.d.ts
index 3c85d7351..be79b2dcd 100644
--- a/socket.io/socket.io.d.ts
+++ b/socket.io/socket.io.d.ts
@@ -12,55 +12,58 @@ declare module "socket.io" {
 	export function listen(server: http.Server, options: any, fn: Function): SocketManager;
 	export function listen(server: http.Server, fn?: Function): SocketManager;
 	export function listen(port: Number): SocketManager;
-}
 
-interface Socket {
-	id: string;
-	json:any;
-	log: any;
-	volatile: any;
-	broadcast: any;
-	in(room: string): Socket;
-	to(room: string): Socket;
-	join(name: string, fn: Function): Socket;
-	leave(name: string, fn: Function): Socket;
-	set(key: string, value: any, fn: Function): Socket;
-	get(key: string, fn: Function): Socket;
-	has(key: string, fn: Function): Socket;
-	del(key: string, fn: Function): Socket;
-	disconnect(): Socket;
-	send(data: any, fn: Function): Socket;
-	emit(ev: any, ...data:any[]): Socket;
-	on(ns: string, fn: Function): Socket;
-}
 
-interface SocketNamespace {
-	clients(room: string): Socket[];
-	log: any;
-	store: any;
-	json: any;
-	volatile: any;
-	in(room: string): SocketNamespace;
-	on(evt: string, fn: (socket: Socket) => void): SocketNamespace;
-	to(room: string): SocketNamespace;
-	except(id: any): SocketNamespace;
-	send(data: any): any;
-	emit(ev: any, ...data:any[]): Socket;
-	socket(sid: any, readable: boolean): Socket;
-	authorization(fn: Function): SocketNamespace;
-}
+  interface Socket {
+    id: string;
+    json:any;
+    log: any;
+    volatile: any;
+    broadcast: any;
+    in(room: string): Socket;
+    to(room: string): Socket;
+    join(name: string, fn: Function): Socket;
+    leave(name: string, fn: Function): Socket;
+    set(key: string, value: any, fn: Function): Socket;
+    get(key: string, fn: Function): Socket;
+    has(key: string, fn: Function): Socket;
+    del(key: string, fn: Function): Socket;
+    disconnect(): Socket;
+    send(data: any, fn: Function): Socket;
+    emit(ev: any, ...data:any[]): Socket;
+    on(ns: string, fn: Function): Socket;
+  }
+
+  interface SocketNamespace {
+    clients(room: string): Socket[];
+    log: any;
+    store: any;
+    json: any;
+    volatile: any;
+    in(room: string): SocketNamespace;
+    on(evt: string, fn: (socket: Socket) => void): SocketNamespace;
+    to(room: string): SocketNamespace;
+    except(id: any): SocketNamespace;
+    send(data: any): any;
+    emit(ev: any, ...data:any[]): Socket;
+    socket(sid: any, readable: boolean): Socket;
+    authorization(fn: Function): SocketNamespace;
+  }
+
+  interface SocketManager {
+    get(key: any): any;
+    set(key: any, value: any): SocketManager;
+    enable(key: any): SocketManager;
+    disable(key: any): SocketManager;
+    enabled(key: any): boolean;
+    disabled(key: any): boolean;
+    configure(env: string, fn: Function): SocketManager;
+    configure(fn: Function): SocketManager;
+    of(nsp: string): SocketNamespace;
+    on(ns: string, fn: Function): SocketManager;
+    sockets: SocketNamespace;
+  }
+
 
-interface SocketManager {
-	get(key: any): any;
-	set(key: any, value: any): SocketManager;
-	enable(key: any): SocketManager;
-	disable(key: any): SocketManager;
-        enabled(key: any): boolean;
-        disabled(key: any): boolean;
-	configure(env: string, fn: Function): SocketManager;
-	configure(fn: Function): SocketManager;
-	of(nsp: string): SocketNamespace;
-	on(ns: string, fn: Function): SocketManager;
-	sockets: SocketNamespace;
 }
 

From 3d44fb65ea35ed5a2704bca3afad4d70bcc4ab7a Mon Sep 17 00:00:00 2001
From: Blake Niemyjski <bniemyjski@gmail.com>
Date: Mon, 10 Mar 2014 09:39:05 -0500
Subject: [PATCH 067/309] More updates for the latest version.

---
 zeroclipboard/zeroclipboard.d.ts | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/zeroclipboard/zeroclipboard.d.ts b/zeroclipboard/zeroclipboard.d.ts
index f4799fc92..44c6423ed 100644
--- a/zeroclipboard/zeroclipboard.d.ts
+++ b/zeroclipboard/zeroclipboard.d.ts
@@ -6,31 +6,27 @@
 
 declare class ZeroClipboard {
     constructor(elements?: any, options?: ZeroClipboardOptions);
-    setCurrent(element: any): void;
+    activate(element: any): void;
     setText(newText: string): void;
-    setTitle(newTitle: string): void;
+    title(newTitle: string): void;
     setSize(width: number, height: number): void;
-    setHandCursor(enabled: boolean): void;
+    forceHandCursor(enabled: boolean): void;
     version: string;
     moviePath: string;
     trustedDomains: any;
     text: string;
     hoverClass: string;
     activeClass: string;
-    resetBridge(): void;
+    deactivate(): void;
     ready: boolean;
     reposition(): void; // returns false in some scenarios, but never returns true
     on(eventName: string, func: Function): void;
-    addEventListener(eventName: string, func: Function): void;
     off(eventName: string, func: Function): void;
-    removeEventListener(eventName: string, func: Function): void;
-    receiveEvent(eventName: string, args: any): void;
-    glue(elements: any): void;
-    unglue(elements: any): void;
+    clip(elements: any): void;
+    unclip(elements: any): void;
     static config(options: ZeroClipboardOptions): void;
     static destroy(): void;
-    static detectFlashSupport(): boolean;
-    static dispatch(eventName: string, args: any): void;
+    static emit(eventName: string, args: any): void;
 }
 
 interface ZeroClipboardOptions {

From 071788e34568c34c5ad2cc1609a455ef2aa577ff Mon Sep 17 00:00:00 2001
From: Santi Albo <santialbo@gmail.com>
Date: Mon, 10 Mar 2014 16:44:30 +0000
Subject: [PATCH 068/309] Add CORS method on restify module

---
 restify/restify.d.ts | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/restify/restify.d.ts b/restify/restify.d.ts
index 2afacc520..f3e5bc46e 100644
--- a/restify/restify.d.ts
+++ b/restify/restify.d.ts
@@ -160,6 +160,17 @@ declare module "restify" {
     (req: Request, res: Response, next: Next): any;
   }
 
+  interface CORS {
+      (cors?: {
+          origins?: string[];
+          credentials?: boolean;
+          headers?: string[];
+      }): RequestHandler;
+      origins: string[];
+      ALLOW_HEADERS: string[];
+      credentials: boolean;
+  }
+
   export function createServer(options?: ServerOptions): Server;
 
   export function createJsonClient(options?: ClientOptions): Client;
@@ -199,4 +210,5 @@ declare module "restify" {
   export function auditLogger(options?: Object): Function;
   export function fullResponse(): RequestHandler;
   export var defaultResponseHeaders : any;
+  export var CORS: CORS;
 }

From 207d7d0faca60a073d8dcc8c981eedddf9e2879a Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 10 Mar 2014 21:26:58 +0400
Subject: [PATCH 069/309] promises-a-plus: updated tests of compatibility with
 implementation libraries

---
 promises-a-plus/promises-a-plus-tests.ts | 40 ++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/promises-a-plus/promises-a-plus-tests.ts b/promises-a-plus/promises-a-plus-tests.ts
index 5b10b1b6e..5ae93113a 100644
--- a/promises-a-plus/promises-a-plus-tests.ts
+++ b/promises-a-plus/promises-a-plus-tests.ts
@@ -1,5 +1,8 @@
 /// <reference path="promises-a-plus.d.ts"/>
 /// <reference path="../rx.js/rx.async.d.ts"/>
+/// <reference path="../es6-promises/es6-promises.d.ts"/>
+/// <reference path="../q/q.d.ts"/>
+/// <reference path="../when/when.d.ts"/>
 
 var thenNum: PromisesAPlus.Thenable<number>; 
 var thenStr: PromisesAPlus.Thenable<string>; 
@@ -35,7 +38,44 @@ function testCompatibleWithRxJS() {
 
 	var obsNum: Rx.Observable<number>;
 
+	// implementation usage
 	thenNum = obsNum.toPromise<PromisesAPlus.Thenable<number>>(impl);
 	thenNum = obsNum.toPromise(impl);
 	obsNum.toPromise(PromiseImpl);
 }
+
+function testCompatibleWithES6Promises() {
+	// from spec to ES6
+	var es6ThenNum: Thenable<number> = thenNum;
+	var es6ThenStr: Thenable<string> = thenStr;
+
+	// from ES6 to spec
+	thenNum = es6ThenNum;
+	thenStr = es6ThenStr;
+
+	// implementation
+	impl = Promise;
+}
+
+function testCompatibleWithQ() {
+	// from spec to ES6
+	var qThenNum: Q.IPromise<number> = thenNum;
+	var qThenStr: Q.IPromise<string> = thenStr;
+
+	// from ES6 to spec
+	thenNum = qThenNum;
+	thenStr = qThenStr;
+
+	// there's no standart implementation with constructor behaviour
+}
+
+function testCompatibleWithWhen() {
+	var whenPromiseNum: When.Promise<number>;
+	var whenPromiseStr: When.Promise<string>;
+
+	// from ES6 to spec
+	thenNum = whenPromiseNum;
+	thenStr = whenPromiseStr;
+
+	// there's no standart implementation with constructor behaviour
+}

From c0faaf0ebc278b3c3feae8cc63b1b5570303296f Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 10 Mar 2014 21:43:25 +0400
Subject: [PATCH 070/309] promises-a-plus: fixed Q import casing in tests

---
 promises-a-plus/promises-a-plus-tests.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/promises-a-plus/promises-a-plus-tests.ts b/promises-a-plus/promises-a-plus-tests.ts
index 5ae93113a..fa1453645 100644
--- a/promises-a-plus/promises-a-plus-tests.ts
+++ b/promises-a-plus/promises-a-plus-tests.ts
@@ -1,7 +1,7 @@
 /// <reference path="promises-a-plus.d.ts"/>
 /// <reference path="../rx.js/rx.async.d.ts"/>
 /// <reference path="../es6-promises/es6-promises.d.ts"/>
-/// <reference path="../q/q.d.ts"/>
+/// <reference path="../q/Q.d.ts"/>
 /// <reference path="../when/when.d.ts"/>
 
 var thenNum: PromisesAPlus.Thenable<number>; 

From a8115c9191d174fa978f89c40470ffa886f04ab0 Mon Sep 17 00:00:00 2001
From: Santi Albo <santialbo@gmail.com>
Date: Mon, 10 Mar 2014 18:46:25 +0000
Subject: [PATCH 071/309] Add missing _.mapValues type definition

---
 lodash/lodash.d.ts | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index b48f7e603..1fda4516e 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -3457,6 +3457,18 @@ declare module _ {
 		keys(object: any): string[];
 	}
 
+    //_.mapValues
+    interface LodashStatic {
+        mapValues<Mapped, T>(
+            object: any,
+            callback: ObjectIterator<any, any>,
+            thisArg?: any): Mapped;
+
+        mapValues<Mapped, T>(
+            object: any,
+            pluckValue: string): Mapped;
+    }
+
 	//_.merge
 	interface LoDashStatic {
 		/**

From ff75f784e1b47dc999a7fe242823869f3b66989d Mon Sep 17 00:00:00 2001
From: Santi Albo <santialbo@gmail.com>
Date: Mon, 10 Mar 2014 18:56:46 +0000
Subject: [PATCH 072/309] Add method documentation

---
 lodash/lodash.d.ts | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index 1fda4516e..fc50a0cb2 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -3458,7 +3458,23 @@ declare module _ {
 	}
 
     //_.mapValues
-    interface LodashStatic {
+    interface LoDashStatic {
+        /**
+         * Creates an object with the same keys as object and values generated by running each own
+         * enumerable property of object through the callback. The callback is bound to thisArg and
+         * invoked with three arguments; (value, key, object).
+         *
+         * If a property name is provided for callback the created "_.pluck" style callback will return
+         * the property value of the given element.
+         *
+         * If an object is provided for callback the created "_.where" style callback will return true
+         * for elements that have the properties of the given object, else false.
+         *
+         * @param object The object to iterate over.
+         * @param callback The function called per iteration.
+         * @param thisArg `this` object in `iterator`, optional.
+         * @return Returns a new object with values of the results of each callback execution.
+         */
         mapValues<Mapped, T>(
             object: any,
             callback: ObjectIterator<any, any>,

From 00aec5744b668f60661d987c3795e62a52180cd1 Mon Sep 17 00:00:00 2001
From: Santi Albo <santialbo@gmail.com>
Date: Mon, 10 Mar 2014 18:59:36 +0000
Subject: [PATCH 073/309] Use tabs instead of spaces, like the rest of the file

---
 lodash/lodash.d.ts | 52 +++++++++++++++++++++++-----------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index fc50a0cb2..dac7a26ed 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -3457,33 +3457,33 @@ declare module _ {
 		keys(object: any): string[];
 	}
 
-    //_.mapValues
-    interface LoDashStatic {
-        /**
-         * Creates an object with the same keys as object and values generated by running each own
-         * enumerable property of object through the callback. The callback is bound to thisArg and
-         * invoked with three arguments; (value, key, object).
-         *
-         * If a property name is provided for callback the created "_.pluck" style callback will return
-         * the property value of the given element.
-         *
-         * If an object is provided for callback the created "_.where" style callback will return true
-         * for elements that have the properties of the given object, else false.
-         *
-         * @param object The object to iterate over.
-         * @param callback The function called per iteration.
-         * @param thisArg `this` object in `iterator`, optional.
-         * @return Returns a new object with values of the results of each callback execution.
-         */
-        mapValues<Mapped, T>(
-            object: any,
-            callback: ObjectIterator<any, any>,
-            thisArg?: any): Mapped;
+	//_.mapValues
+	interface LoDashStatic {
+		/**
+		* Creates an object with the same keys as object and values generated by running each own
+		* enumerable property of object through the callback. The callback is bound to thisArg and
+		* invoked with three arguments; (value, key, object).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will return
+		* the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return true
+		* for elements that have the properties of the given object, else false.
+		*
+		* @param object The object to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg `this` object in `iterator`, optional.
+		* @return Returns a new object with values of the results of each callback execution.
+		*/
+		mapValues<Mapped, T>(
+			object: any,
+			callback: ObjectIterator<any, any>,
+			thisArg?: any): Mapped;
 
-        mapValues<Mapped, T>(
-            object: any,
-            pluckValue: string): Mapped;
-    }
+		mapValues<Mapped, T>(
+			object: any,
+			pluckValue: string): Mapped;
+	}
 
 	//_.merge
 	interface LoDashStatic {

From dca457aa7193072d75c295e974e53228739756fc Mon Sep 17 00:00:00 2001
From: Santi Albo <santialbo@gmail.com>
Date: Tue, 11 Mar 2014 10:12:49 +0000
Subject: [PATCH 074/309] Use generic parameter

---
 lodash/lodash.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index dac7a26ed..9f186f433 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -3476,12 +3476,12 @@ declare module _ {
 		* @return Returns a new object with values of the results of each callback execution.
 		*/
 		mapValues<Mapped, T>(
-			object: any,
+			object: T,
 			callback: ObjectIterator<any, any>,
 			thisArg?: any): Mapped;
 
 		mapValues<Mapped, T>(
-			object: any,
+			object: T,
 			pluckValue: string): Mapped;
 	}
 

From a5ad3549eac7930c1d327ff854d62bedbf8edbc6 Mon Sep 17 00:00:00 2001
From: dougajmcdonald <dougajmcdonald@gmail.com>
Date: Tue, 11 Mar 2014 13:34:45 +0000
Subject: [PATCH 075/309] Create jquery.ui.datetimepicker.d.ts

---
 jquery.ui.datetimepicker.d.ts | 140 ++++++++++++++++++++++++++++++++++
 1 file changed, 140 insertions(+)
 create mode 100644 jquery.ui.datetimepicker.d.ts

diff --git a/jquery.ui.datetimepicker.d.ts b/jquery.ui.datetimepicker.d.ts
new file mode 100644
index 000000000..3ae8924f9
--- /dev/null
+++ b/jquery.ui.datetimepicker.d.ts
@@ -0,0 +1,140 @@
+// Type definitions for jQuery UI DateTimePicker 0.3 Addon
+//
+// Project: http://trentrichardson.com/examples/timepicker/
+// Definitions by: https://github.com/dougajmcdonald
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="jquery.d.ts"/>
+/// <reference path="jqueryui.d.ts"/>
+
+interface DateTimePickerOptions extends JQueryUI.DatepickerOptions {
+
+    // Control options
+    showButtonPanel?: boolean; //Default: true - Whether to show the button panel at the bottom.This is generally needed.
+    timeOnly?: boolean; //Default: false - Hide the datepicker and only provide a time interface.
+    onSelect?: () => any; //Default: null - Function to be called when a date is chosen or time has changed(parameters: datetimeText, datepickerInstance).
+    alwaysSetTime?: boolean; //Default: true - Always have a time set internally, even before user has chosen one.
+    separator?: string; //Default: " " - When formatting the time this string is placed between the formatted date and formatted time.
+    pickerTimeFormat?: string; //Default: (timeFormat option) - How to format the time displayed within the timepicker.
+    pickerTimeSuffix?: string; //Default: (timeSuffix option) - String to place after the formatted time within the timepicker.
+    showTimepicker?: boolean; //Default: true - Whether to show the timepicker within the datepicker.
+    addSliderAccess?: boolean; //Default: false - Adds the sliderAccess plugin to sliders within timepicker
+    sliderAccessArgs?: any; //Default: null - Object to pass to sliderAccess when used.
+    defaultValue?: string; //Default: null - String of the default time value placed in the input on focus when the input is empty.
+    minDateTime?: Date; //Default: null - Date object of the minimum datetime allowed.Also available as minDate.
+    maxDateTime?: Date; //Default: null - Date object of the maximum datetime allowed.Also Available as maxDate.
+    parse?: string; //Default: 'strict' - How to parse the time string. Two methods are provided: 'strict' which must match the timeFormat exactly, and 'loose' which uses javascript's new Date(timeString) to guess the time. You may also pass in a function(timeFormat, timeString, options) to handle the parsing yourself, returning a simple object:      
+
+    // Alt field options
+    altFieldTimeOnly?: boolean;  //Default: true - When altField is used from datepicker altField will only receive the formatted time and the original field only receives date.
+    altSeparator?: string;       //Default: (separator option) - String placed between formatted date and formatted time in the altField.
+    altTimeSuffix?: string;      //Default: (timeSuffix option) - String always placed after the formatted time in the altField.
+    altTimeFormat?: string;      //Default: (timeFormat option) - The time format to use with the altField.
+
+    // Localization options
+    localizationOptions?: DateTimePickerLocalizationOptions;
+    // Timezone options
+    timezoneList?: Array<TimezoneOptions> //Default: [generated timezones] - An array of timezones used to populate the timezone select.Can be an array of values or an array of objects: { label: "EDT", value: -240 }. The value should be the offset number in minutes.So "-0400" which is the format "-hhmm", would equate to - 240 minutes.
+}
+
+interface DateTimePickerLocalizationOptions {
+    // Localization options
+    currentText?: string;    //Default: "Now", A Localization Setting - Text for the Now button.
+    closeText?: string;      //Default: "Done", A Localization Setting - Text for the Close button.
+    amNames?: string;        //Default: ['AM', 'A'], A Localization Setting - Array of strings to try and parse against to determine AM.
+    pmNames?: string;        //Default: ['PM', 'P'], A Localization Setting - Array of strings to try and parse against to determine PM.
+    timeFormat?: string;     //Default: "HH:mm", A Localization Setting - String of format tokens to be replaced with the time.See Formatting.
+    timeSuffix?: string;     //Default: "", A Localization Setting - String to place after the formatted time.
+    timeOnlyTitle?: string;  //Default: "Choose Time", A Localization Setting - Title of the wigit when using only timepicker.
+    timeText?: string;       //Default: "Time", A Localization Setting - Label used within timepicker for the formatted time.
+    hourText?: string;       //Default: "Hour", A Localization Setting - Label used to identify the hour slider.
+    minuteText?: string;     //Default: "Minute", A Localization Setting - Label used to identify the minute slider.
+    secondText?: string;     //Default: "Second", A Localization Setting - Label used to identify the second slider.
+    millisecText?: string;   //Default: "Millisecond", A Localization Setting - Label used to identify the millisecond slider.
+    microsecText?: string;   //Default: "Microsecond", A Localization Setting - Label used to identify the microsecond slider.
+    timezoneText?: string;   //Default: "Timezone", A Localization Setting - Label used to identify the timezone slider.
+    isRTL?: boolean;         //Default: false, A Localization Setting - Right to Left support.  
+}
+
+interface TimezoneOptions {
+    label: string;
+    value: number;
+}
+
+interface Time {
+    hour?: number;
+    minute?: number;
+    second?: number;
+    millisecond?: number;
+    timezone?: string;
+}
+
+interface TimeFieldOptions {
+    controlType: string;    //Default: 'slider' - Whether to use 'slider' or 'select'.If 'slider' is unavailable through jQueryUI, 'select' will be used.For advanced usage you may pass an object which implements "create", "options", "value" methods to use controls other than sliders or selects.See the _controls property in the source code for more details.
+    showHour?: boolean;     //Default: null - Whether to show the hour control. The default of null will use detection from timeFormat.
+    showMinute?: boolean;   //Default: null - Whether to show the minute control. The default of null will use detection from timeFormat.
+    showSecond?: boolean;   //Default: null - Whether to show the second control. The default of null will use detection from timeFormat.
+    showMillisec?: boolean; //Default: null - Whether to show the millisecond control. The default of null will use detection from timeFormat.
+    showMicrosec?: boolean; //Default: null - Whether to show the microsecond control. The default of null will use detection from timeFormat.
+    showTimezone?: boolean; //Default: null - Whether to show the timezone select.
+    showTime: boolean;      //Default: true - Whether to show the time selected within the datetimepicker.
+    stepHour: number;       //Default: 1 - Hours per step the slider makes.
+    stepMinute: number;     //Default: 1 - Minutes per step the slider makes.
+    stepSecond: number;     //Default: 1 - Seconds per step the slider makes.
+    stepMillisec: number;   //Default: 1 - Milliseconds per step the slider makes.
+    stepMicrosec: number;   //Default: 1 - Microseconds per step the slider makes.
+    hour: number;           //Default: 0 - Initial hour set.
+    minute: number;         //Default: 0 - Initial minute set.
+    second: number;         //Default: 0 - Initial second set.
+    millisec: number;       //Default: 0 - Initial millisecond set.
+    microsec: number;       //Default: 0 - Initial microsecond set. Note: Javascript's native Date object does not natively support microseconds. Timepicker adds ability to simply Date.setMicroseconds(m) and Date.getMicroseconds(). Date comparisons will not acknowledge microseconds. Use this only for display purposes.
+    timezone?: number;      //Default: null - Initial timezone set.This is the offset in minutes.If null the browser's local timezone will be used. If you're timezone is "-0400" you would use - 240. For backwards compatibility you may pass "-0400", however the timezone is stored in minutes and more reliable.
+    hourMin: number;        //Default: 0 - The minimum hour allowed for all dates.
+    minuteMin: number;      //Default: 0 - The minimum minute allowed for all dates.
+    secondMin: number;      //Default: 0 - The minimum second allowed for all dates.
+    millisecMin: number;    //Default: 0 - The minimum millisecond allowed for all dates.
+    microsecMin: number;    //Default: 0 - The minimum microsecond allowed for all dates.
+    hourMax: number;        //Default: 23 - The maximum hour allowed for all dates.
+    minuteMax: number;      //Default: 59 - The maximum minute allowed for all dates.
+    secondMax: number;      //Default: 59 - The maximum second allowed for all dates.
+    millisecMax: number;    //Default: 999 - The maximum millisecond allowed for all dates.
+    microsecMax: number;    //Default: 999 - The maximum microsecond allowed for all dates.
+    hourGrid: number;       //Default: 0 - When greater than 0 a label grid will be generated under the slider.This number represents the units (in hours) between labels.
+    minuteGrid: number;     //Default: 0 - When greater than 0 a label grid will be generated under the slider.This number represents the units (in minutes) between labels.
+    secondGrid: number;     //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in seconds) between labels.
+    millisecGrid: number;   //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in milliseconds) between labels.
+    microsecGrid: number;   //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in microseconds) between labels.
+}
+
+interface formatTimeOptions {
+    format: string;
+    time: Time;
+    options?: DateTimePickerLocalizationOptions;
+}
+
+interface parseTimeOptions {
+    format: string;
+    time: string;
+    options?: DateTimePickerLocalizationOptions;
+}
+
+interface parseDateTimeOptions {
+    dateFormat: string;
+    timeFormat: string;
+    dateTimeString: string;
+    dateSettings: string;
+    timeSettings: string;
+}
+
+interface JQuery {
+    datetimepicker(): JQuery;
+    datetimepicker(options?: DateTimePickerOptions): JQuery;            
+
+    //datetimepicker(method: string): any;
+    datetimepicker(method: string, methodParameter: any): any;
+    datetimepicker(method: 'formatTime', methodParameter: formatTimeOptions): string;
+    datetimepicker(method: 'parseTime', methodParameter: parseTimeOptions): Time;
+    datetimepicker(method: 'parseDateTime', methodParameter: parseDateTimeOptions): Date;
+
+}
+

From 5c4144acda93492df9c75a65b5d54eb0cb6e755d Mon Sep 17 00:00:00 2001
From: dougajmcdonald <dougajmcdonald@gmail.com>
Date: Tue, 11 Mar 2014 13:37:41 +0000
Subject: [PATCH 076/309] Create jquery.ui.datetimepicker.d.ts

---
 .../jquery.ui.datetimepicker.d.ts             | 140 ++++++++++++++++++
 1 file changed, 140 insertions(+)
 create mode 100644 jquery.ui.datetimepicker/jquery.ui.datetimepicker.d.ts

diff --git a/jquery.ui.datetimepicker/jquery.ui.datetimepicker.d.ts b/jquery.ui.datetimepicker/jquery.ui.datetimepicker.d.ts
new file mode 100644
index 000000000..3ae8924f9
--- /dev/null
+++ b/jquery.ui.datetimepicker/jquery.ui.datetimepicker.d.ts
@@ -0,0 +1,140 @@
+// Type definitions for jQuery UI DateTimePicker 0.3 Addon
+//
+// Project: http://trentrichardson.com/examples/timepicker/
+// Definitions by: https://github.com/dougajmcdonald
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="jquery.d.ts"/>
+/// <reference path="jqueryui.d.ts"/>
+
+interface DateTimePickerOptions extends JQueryUI.DatepickerOptions {
+
+    // Control options
+    showButtonPanel?: boolean; //Default: true - Whether to show the button panel at the bottom.This is generally needed.
+    timeOnly?: boolean; //Default: false - Hide the datepicker and only provide a time interface.
+    onSelect?: () => any; //Default: null - Function to be called when a date is chosen or time has changed(parameters: datetimeText, datepickerInstance).
+    alwaysSetTime?: boolean; //Default: true - Always have a time set internally, even before user has chosen one.
+    separator?: string; //Default: " " - When formatting the time this string is placed between the formatted date and formatted time.
+    pickerTimeFormat?: string; //Default: (timeFormat option) - How to format the time displayed within the timepicker.
+    pickerTimeSuffix?: string; //Default: (timeSuffix option) - String to place after the formatted time within the timepicker.
+    showTimepicker?: boolean; //Default: true - Whether to show the timepicker within the datepicker.
+    addSliderAccess?: boolean; //Default: false - Adds the sliderAccess plugin to sliders within timepicker
+    sliderAccessArgs?: any; //Default: null - Object to pass to sliderAccess when used.
+    defaultValue?: string; //Default: null - String of the default time value placed in the input on focus when the input is empty.
+    minDateTime?: Date; //Default: null - Date object of the minimum datetime allowed.Also available as minDate.
+    maxDateTime?: Date; //Default: null - Date object of the maximum datetime allowed.Also Available as maxDate.
+    parse?: string; //Default: 'strict' - How to parse the time string. Two methods are provided: 'strict' which must match the timeFormat exactly, and 'loose' which uses javascript's new Date(timeString) to guess the time. You may also pass in a function(timeFormat, timeString, options) to handle the parsing yourself, returning a simple object:      
+
+    // Alt field options
+    altFieldTimeOnly?: boolean;  //Default: true - When altField is used from datepicker altField will only receive the formatted time and the original field only receives date.
+    altSeparator?: string;       //Default: (separator option) - String placed between formatted date and formatted time in the altField.
+    altTimeSuffix?: string;      //Default: (timeSuffix option) - String always placed after the formatted time in the altField.
+    altTimeFormat?: string;      //Default: (timeFormat option) - The time format to use with the altField.
+
+    // Localization options
+    localizationOptions?: DateTimePickerLocalizationOptions;
+    // Timezone options
+    timezoneList?: Array<TimezoneOptions> //Default: [generated timezones] - An array of timezones used to populate the timezone select.Can be an array of values or an array of objects: { label: "EDT", value: -240 }. The value should be the offset number in minutes.So "-0400" which is the format "-hhmm", would equate to - 240 minutes.
+}
+
+interface DateTimePickerLocalizationOptions {
+    // Localization options
+    currentText?: string;    //Default: "Now", A Localization Setting - Text for the Now button.
+    closeText?: string;      //Default: "Done", A Localization Setting - Text for the Close button.
+    amNames?: string;        //Default: ['AM', 'A'], A Localization Setting - Array of strings to try and parse against to determine AM.
+    pmNames?: string;        //Default: ['PM', 'P'], A Localization Setting - Array of strings to try and parse against to determine PM.
+    timeFormat?: string;     //Default: "HH:mm", A Localization Setting - String of format tokens to be replaced with the time.See Formatting.
+    timeSuffix?: string;     //Default: "", A Localization Setting - String to place after the formatted time.
+    timeOnlyTitle?: string;  //Default: "Choose Time", A Localization Setting - Title of the wigit when using only timepicker.
+    timeText?: string;       //Default: "Time", A Localization Setting - Label used within timepicker for the formatted time.
+    hourText?: string;       //Default: "Hour", A Localization Setting - Label used to identify the hour slider.
+    minuteText?: string;     //Default: "Minute", A Localization Setting - Label used to identify the minute slider.
+    secondText?: string;     //Default: "Second", A Localization Setting - Label used to identify the second slider.
+    millisecText?: string;   //Default: "Millisecond", A Localization Setting - Label used to identify the millisecond slider.
+    microsecText?: string;   //Default: "Microsecond", A Localization Setting - Label used to identify the microsecond slider.
+    timezoneText?: string;   //Default: "Timezone", A Localization Setting - Label used to identify the timezone slider.
+    isRTL?: boolean;         //Default: false, A Localization Setting - Right to Left support.  
+}
+
+interface TimezoneOptions {
+    label: string;
+    value: number;
+}
+
+interface Time {
+    hour?: number;
+    minute?: number;
+    second?: number;
+    millisecond?: number;
+    timezone?: string;
+}
+
+interface TimeFieldOptions {
+    controlType: string;    //Default: 'slider' - Whether to use 'slider' or 'select'.If 'slider' is unavailable through jQueryUI, 'select' will be used.For advanced usage you may pass an object which implements "create", "options", "value" methods to use controls other than sliders or selects.See the _controls property in the source code for more details.
+    showHour?: boolean;     //Default: null - Whether to show the hour control. The default of null will use detection from timeFormat.
+    showMinute?: boolean;   //Default: null - Whether to show the minute control. The default of null will use detection from timeFormat.
+    showSecond?: boolean;   //Default: null - Whether to show the second control. The default of null will use detection from timeFormat.
+    showMillisec?: boolean; //Default: null - Whether to show the millisecond control. The default of null will use detection from timeFormat.
+    showMicrosec?: boolean; //Default: null - Whether to show the microsecond control. The default of null will use detection from timeFormat.
+    showTimezone?: boolean; //Default: null - Whether to show the timezone select.
+    showTime: boolean;      //Default: true - Whether to show the time selected within the datetimepicker.
+    stepHour: number;       //Default: 1 - Hours per step the slider makes.
+    stepMinute: number;     //Default: 1 - Minutes per step the slider makes.
+    stepSecond: number;     //Default: 1 - Seconds per step the slider makes.
+    stepMillisec: number;   //Default: 1 - Milliseconds per step the slider makes.
+    stepMicrosec: number;   //Default: 1 - Microseconds per step the slider makes.
+    hour: number;           //Default: 0 - Initial hour set.
+    minute: number;         //Default: 0 - Initial minute set.
+    second: number;         //Default: 0 - Initial second set.
+    millisec: number;       //Default: 0 - Initial millisecond set.
+    microsec: number;       //Default: 0 - Initial microsecond set. Note: Javascript's native Date object does not natively support microseconds. Timepicker adds ability to simply Date.setMicroseconds(m) and Date.getMicroseconds(). Date comparisons will not acknowledge microseconds. Use this only for display purposes.
+    timezone?: number;      //Default: null - Initial timezone set.This is the offset in minutes.If null the browser's local timezone will be used. If you're timezone is "-0400" you would use - 240. For backwards compatibility you may pass "-0400", however the timezone is stored in minutes and more reliable.
+    hourMin: number;        //Default: 0 - The minimum hour allowed for all dates.
+    minuteMin: number;      //Default: 0 - The minimum minute allowed for all dates.
+    secondMin: number;      //Default: 0 - The minimum second allowed for all dates.
+    millisecMin: number;    //Default: 0 - The minimum millisecond allowed for all dates.
+    microsecMin: number;    //Default: 0 - The minimum microsecond allowed for all dates.
+    hourMax: number;        //Default: 23 - The maximum hour allowed for all dates.
+    minuteMax: number;      //Default: 59 - The maximum minute allowed for all dates.
+    secondMax: number;      //Default: 59 - The maximum second allowed for all dates.
+    millisecMax: number;    //Default: 999 - The maximum millisecond allowed for all dates.
+    microsecMax: number;    //Default: 999 - The maximum microsecond allowed for all dates.
+    hourGrid: number;       //Default: 0 - When greater than 0 a label grid will be generated under the slider.This number represents the units (in hours) between labels.
+    minuteGrid: number;     //Default: 0 - When greater than 0 a label grid will be generated under the slider.This number represents the units (in minutes) between labels.
+    secondGrid: number;     //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in seconds) between labels.
+    millisecGrid: number;   //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in milliseconds) between labels.
+    microsecGrid: number;   //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in microseconds) between labels.
+}
+
+interface formatTimeOptions {
+    format: string;
+    time: Time;
+    options?: DateTimePickerLocalizationOptions;
+}
+
+interface parseTimeOptions {
+    format: string;
+    time: string;
+    options?: DateTimePickerLocalizationOptions;
+}
+
+interface parseDateTimeOptions {
+    dateFormat: string;
+    timeFormat: string;
+    dateTimeString: string;
+    dateSettings: string;
+    timeSettings: string;
+}
+
+interface JQuery {
+    datetimepicker(): JQuery;
+    datetimepicker(options?: DateTimePickerOptions): JQuery;            
+
+    //datetimepicker(method: string): any;
+    datetimepicker(method: string, methodParameter: any): any;
+    datetimepicker(method: 'formatTime', methodParameter: formatTimeOptions): string;
+    datetimepicker(method: 'parseTime', methodParameter: parseTimeOptions): Time;
+    datetimepicker(method: 'parseDateTime', methodParameter: parseDateTimeOptions): Date;
+
+}
+

From b2a58ab7a2b99857accd3473cf2143308b05cc9f Mon Sep 17 00:00:00 2001
From: dougajmcdonald <dougajmcdonald@gmail.com>
Date: Tue, 11 Mar 2014 13:41:15 +0000
Subject: [PATCH 077/309] Update README.md

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 55be07d84..ba380d9c9 100755
--- a/README.md
+++ b/README.md
@@ -138,6 +138,7 @@ List of Definitions
 * [jQuery.Cycle](http://jquery.malsup.com/cycle/) (by [François Guillot](http://fguillot.developpez.com/))
 * [jQuery.Cycle2](http://jquery.malsup.com/cycle2/) (by [Donny Nadolny](https://github.com/dnadolny))
 * [jQuery.dataTables](http://www.datatables.net) (by [Armin Sander](https://github.com/pragmatrix))
+* [jQuery.datetimepicker](http://trentrichardson.com/examples/timepicker/) (by [Doug McDonald](https://github.com/dougajmcdonald))
 * [jQuery.dynatree](http://code.google.com/p/dynatree/) (by [François de Campredon](https://github.com/fdecampredon))
 * [jQuery.Flot](http://www.flotcharts.org/) (by [Matt Burland](https://github.com/burlandm))
 * [jQuery.form](http://malsup.com/jquery/form/) (by [François Guillot](http://fguillot.developpez.com/))

From f6518d7a5a0c781098418568a21f1be2a79f2bf7 Mon Sep 17 00:00:00 2001
From: dougajmcdonald <dougajmcdonald@gmail.com>
Date: Tue, 11 Mar 2014 13:45:32 +0000
Subject: [PATCH 078/309] Delete jquery.ui.datetimepicker.d.ts

---
 jquery.ui.datetimepicker.d.ts | 140 ----------------------------------
 1 file changed, 140 deletions(-)
 delete mode 100644 jquery.ui.datetimepicker.d.ts

diff --git a/jquery.ui.datetimepicker.d.ts b/jquery.ui.datetimepicker.d.ts
deleted file mode 100644
index 3ae8924f9..000000000
--- a/jquery.ui.datetimepicker.d.ts
+++ /dev/null
@@ -1,140 +0,0 @@
-// Type definitions for jQuery UI DateTimePicker 0.3 Addon
-//
-// Project: http://trentrichardson.com/examples/timepicker/
-// Definitions by: https://github.com/dougajmcdonald
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-/// <reference path="jquery.d.ts"/>
-/// <reference path="jqueryui.d.ts"/>
-
-interface DateTimePickerOptions extends JQueryUI.DatepickerOptions {
-
-    // Control options
-    showButtonPanel?: boolean; //Default: true - Whether to show the button panel at the bottom.This is generally needed.
-    timeOnly?: boolean; //Default: false - Hide the datepicker and only provide a time interface.
-    onSelect?: () => any; //Default: null - Function to be called when a date is chosen or time has changed(parameters: datetimeText, datepickerInstance).
-    alwaysSetTime?: boolean; //Default: true - Always have a time set internally, even before user has chosen one.
-    separator?: string; //Default: " " - When formatting the time this string is placed between the formatted date and formatted time.
-    pickerTimeFormat?: string; //Default: (timeFormat option) - How to format the time displayed within the timepicker.
-    pickerTimeSuffix?: string; //Default: (timeSuffix option) - String to place after the formatted time within the timepicker.
-    showTimepicker?: boolean; //Default: true - Whether to show the timepicker within the datepicker.
-    addSliderAccess?: boolean; //Default: false - Adds the sliderAccess plugin to sliders within timepicker
-    sliderAccessArgs?: any; //Default: null - Object to pass to sliderAccess when used.
-    defaultValue?: string; //Default: null - String of the default time value placed in the input on focus when the input is empty.
-    minDateTime?: Date; //Default: null - Date object of the minimum datetime allowed.Also available as minDate.
-    maxDateTime?: Date; //Default: null - Date object of the maximum datetime allowed.Also Available as maxDate.
-    parse?: string; //Default: 'strict' - How to parse the time string. Two methods are provided: 'strict' which must match the timeFormat exactly, and 'loose' which uses javascript's new Date(timeString) to guess the time. You may also pass in a function(timeFormat, timeString, options) to handle the parsing yourself, returning a simple object:      
-
-    // Alt field options
-    altFieldTimeOnly?: boolean;  //Default: true - When altField is used from datepicker altField will only receive the formatted time and the original field only receives date.
-    altSeparator?: string;       //Default: (separator option) - String placed between formatted date and formatted time in the altField.
-    altTimeSuffix?: string;      //Default: (timeSuffix option) - String always placed after the formatted time in the altField.
-    altTimeFormat?: string;      //Default: (timeFormat option) - The time format to use with the altField.
-
-    // Localization options
-    localizationOptions?: DateTimePickerLocalizationOptions;
-    // Timezone options
-    timezoneList?: Array<TimezoneOptions> //Default: [generated timezones] - An array of timezones used to populate the timezone select.Can be an array of values or an array of objects: { label: "EDT", value: -240 }. The value should be the offset number in minutes.So "-0400" which is the format "-hhmm", would equate to - 240 minutes.
-}
-
-interface DateTimePickerLocalizationOptions {
-    // Localization options
-    currentText?: string;    //Default: "Now", A Localization Setting - Text for the Now button.
-    closeText?: string;      //Default: "Done", A Localization Setting - Text for the Close button.
-    amNames?: string;        //Default: ['AM', 'A'], A Localization Setting - Array of strings to try and parse against to determine AM.
-    pmNames?: string;        //Default: ['PM', 'P'], A Localization Setting - Array of strings to try and parse against to determine PM.
-    timeFormat?: string;     //Default: "HH:mm", A Localization Setting - String of format tokens to be replaced with the time.See Formatting.
-    timeSuffix?: string;     //Default: "", A Localization Setting - String to place after the formatted time.
-    timeOnlyTitle?: string;  //Default: "Choose Time", A Localization Setting - Title of the wigit when using only timepicker.
-    timeText?: string;       //Default: "Time", A Localization Setting - Label used within timepicker for the formatted time.
-    hourText?: string;       //Default: "Hour", A Localization Setting - Label used to identify the hour slider.
-    minuteText?: string;     //Default: "Minute", A Localization Setting - Label used to identify the minute slider.
-    secondText?: string;     //Default: "Second", A Localization Setting - Label used to identify the second slider.
-    millisecText?: string;   //Default: "Millisecond", A Localization Setting - Label used to identify the millisecond slider.
-    microsecText?: string;   //Default: "Microsecond", A Localization Setting - Label used to identify the microsecond slider.
-    timezoneText?: string;   //Default: "Timezone", A Localization Setting - Label used to identify the timezone slider.
-    isRTL?: boolean;         //Default: false, A Localization Setting - Right to Left support.  
-}
-
-interface TimezoneOptions {
-    label: string;
-    value: number;
-}
-
-interface Time {
-    hour?: number;
-    minute?: number;
-    second?: number;
-    millisecond?: number;
-    timezone?: string;
-}
-
-interface TimeFieldOptions {
-    controlType: string;    //Default: 'slider' - Whether to use 'slider' or 'select'.If 'slider' is unavailable through jQueryUI, 'select' will be used.For advanced usage you may pass an object which implements "create", "options", "value" methods to use controls other than sliders or selects.See the _controls property in the source code for more details.
-    showHour?: boolean;     //Default: null - Whether to show the hour control. The default of null will use detection from timeFormat.
-    showMinute?: boolean;   //Default: null - Whether to show the minute control. The default of null will use detection from timeFormat.
-    showSecond?: boolean;   //Default: null - Whether to show the second control. The default of null will use detection from timeFormat.
-    showMillisec?: boolean; //Default: null - Whether to show the millisecond control. The default of null will use detection from timeFormat.
-    showMicrosec?: boolean; //Default: null - Whether to show the microsecond control. The default of null will use detection from timeFormat.
-    showTimezone?: boolean; //Default: null - Whether to show the timezone select.
-    showTime: boolean;      //Default: true - Whether to show the time selected within the datetimepicker.
-    stepHour: number;       //Default: 1 - Hours per step the slider makes.
-    stepMinute: number;     //Default: 1 - Minutes per step the slider makes.
-    stepSecond: number;     //Default: 1 - Seconds per step the slider makes.
-    stepMillisec: number;   //Default: 1 - Milliseconds per step the slider makes.
-    stepMicrosec: number;   //Default: 1 - Microseconds per step the slider makes.
-    hour: number;           //Default: 0 - Initial hour set.
-    minute: number;         //Default: 0 - Initial minute set.
-    second: number;         //Default: 0 - Initial second set.
-    millisec: number;       //Default: 0 - Initial millisecond set.
-    microsec: number;       //Default: 0 - Initial microsecond set. Note: Javascript's native Date object does not natively support microseconds. Timepicker adds ability to simply Date.setMicroseconds(m) and Date.getMicroseconds(). Date comparisons will not acknowledge microseconds. Use this only for display purposes.
-    timezone?: number;      //Default: null - Initial timezone set.This is the offset in minutes.If null the browser's local timezone will be used. If you're timezone is "-0400" you would use - 240. For backwards compatibility you may pass "-0400", however the timezone is stored in minutes and more reliable.
-    hourMin: number;        //Default: 0 - The minimum hour allowed for all dates.
-    minuteMin: number;      //Default: 0 - The minimum minute allowed for all dates.
-    secondMin: number;      //Default: 0 - The minimum second allowed for all dates.
-    millisecMin: number;    //Default: 0 - The minimum millisecond allowed for all dates.
-    microsecMin: number;    //Default: 0 - The minimum microsecond allowed for all dates.
-    hourMax: number;        //Default: 23 - The maximum hour allowed for all dates.
-    minuteMax: number;      //Default: 59 - The maximum minute allowed for all dates.
-    secondMax: number;      //Default: 59 - The maximum second allowed for all dates.
-    millisecMax: number;    //Default: 999 - The maximum millisecond allowed for all dates.
-    microsecMax: number;    //Default: 999 - The maximum microsecond allowed for all dates.
-    hourGrid: number;       //Default: 0 - When greater than 0 a label grid will be generated under the slider.This number represents the units (in hours) between labels.
-    minuteGrid: number;     //Default: 0 - When greater than 0 a label grid will be generated under the slider.This number represents the units (in minutes) between labels.
-    secondGrid: number;     //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in seconds) between labels.
-    millisecGrid: number;   //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in milliseconds) between labels.
-    microsecGrid: number;   //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in microseconds) between labels.
-}
-
-interface formatTimeOptions {
-    format: string;
-    time: Time;
-    options?: DateTimePickerLocalizationOptions;
-}
-
-interface parseTimeOptions {
-    format: string;
-    time: string;
-    options?: DateTimePickerLocalizationOptions;
-}
-
-interface parseDateTimeOptions {
-    dateFormat: string;
-    timeFormat: string;
-    dateTimeString: string;
-    dateSettings: string;
-    timeSettings: string;
-}
-
-interface JQuery {
-    datetimepicker(): JQuery;
-    datetimepicker(options?: DateTimePickerOptions): JQuery;            
-
-    //datetimepicker(method: string): any;
-    datetimepicker(method: string, methodParameter: any): any;
-    datetimepicker(method: 'formatTime', methodParameter: formatTimeOptions): string;
-    datetimepicker(method: 'parseTime', methodParameter: parseTimeOptions): Time;
-    datetimepicker(method: 'parseDateTime', methodParameter: parseDateTimeOptions): Date;
-
-}
-

From a4cd5294d4412797379bf9b5f09a0eacc44d85a4 Mon Sep 17 00:00:00 2001
From: dougajmcdonald <dougajmcdonald@gmail.com>
Date: Tue, 11 Mar 2014 13:58:22 +0000
Subject: [PATCH 079/309] Update jquery.ui.datetimepicker.d.ts

Resolved some issues with the interface for time options I didn't fully understand.

Made many more options...optional.
---
 .../jquery.ui.datetimepicker.d.ts             | 92 +++++++++----------
 1 file changed, 42 insertions(+), 50 deletions(-)

diff --git a/jquery.ui.datetimepicker/jquery.ui.datetimepicker.d.ts b/jquery.ui.datetimepicker/jquery.ui.datetimepicker.d.ts
index 3ae8924f9..047b7f0c9 100644
--- a/jquery.ui.datetimepicker/jquery.ui.datetimepicker.d.ts
+++ b/jquery.ui.datetimepicker/jquery.ui.datetimepicker.d.ts
@@ -31,13 +31,6 @@ interface DateTimePickerOptions extends JQueryUI.DatepickerOptions {
     altTimeSuffix?: string;      //Default: (timeSuffix option) - String always placed after the formatted time in the altField.
     altTimeFormat?: string;      //Default: (timeFormat option) - The time format to use with the altField.
 
-    // Localization options
-    localizationOptions?: DateTimePickerLocalizationOptions;
-    // Timezone options
-    timezoneList?: Array<TimezoneOptions> //Default: [generated timezones] - An array of timezones used to populate the timezone select.Can be an array of values or an array of objects: { label: "EDT", value: -240 }. The value should be the offset number in minutes.So "-0400" which is the format "-hhmm", would equate to - 240 minutes.
-}
-
-interface DateTimePickerLocalizationOptions {
     // Localization options
     currentText?: string;    //Default: "Now", A Localization Setting - Text for the Now button.
     closeText?: string;      //Default: "Done", A Localization Setting - Text for the Close button.
@@ -53,7 +46,46 @@ interface DateTimePickerLocalizationOptions {
     millisecText?: string;   //Default: "Millisecond", A Localization Setting - Label used to identify the millisecond slider.
     microsecText?: string;   //Default: "Microsecond", A Localization Setting - Label used to identify the microsecond slider.
     timezoneText?: string;   //Default: "Timezone", A Localization Setting - Label used to identify the timezone slider.
-    isRTL?: boolean;         //Default: false, A Localization Setting - Right to Left support.  
+    isRTL?: boolean;         //Default: false, A Localization Setting - Right to Left support. 
+
+    // Timefield options
+    controlType?: string;    //Default: 'slider' - Whether to use 'slider' or 'select'.If 'slider' is unavailable through jQueryUI, 'select' will be used.For advanced usage you may pass an object which implements "create", "options", "value" methods to use controls other than sliders or selects.See the _controls property in the source code for more details.
+    showHour?: boolean;     //Default: null - Whether to show the hour control. The default of null will use detection from timeFormat.
+    showMinute?: boolean;   //Default: null - Whether to show the minute control. The default of null will use detection from timeFormat.
+    showSecond?: boolean;   //Default: null - Whether to show the second control. The default of null will use detection from timeFormat.
+    showMillisec?: boolean; //Default: null - Whether to show the millisecond control. The default of null will use detection from timeFormat.
+    showMicrosec?: boolean; //Default: null - Whether to show the microsecond control. The default of null will use detection from timeFormat.
+    showTimezone?: boolean; //Default: null - Whether to show the timezone select.
+    showTime?: boolean;      //Default: true - Whether to show the time selected within the datetimepicker.
+    stepHour?: number;       //Default: 1 - Hours per step the slider makes.
+    stepMinute?: number;     //Default: 1 - Minutes per step the slider makes.
+    stepSecond?: number;     //Default: 1 - Seconds per step the slider makes.
+    stepMillisec?: number;   //Default: 1 - Milliseconds per step the slider makes.
+    stepMicrosec?: number;   //Default: 1 - Microseconds per step the slider makes.
+    hour?: number;           //Default: 0 - Initial hour set.
+    minute?: number;         //Default: 0 - Initial minute set.
+    second?: number;         //Default: 0 - Initial second set.
+    millisec?: number;       //Default: 0 - Initial millisecond set.
+    microsec?: number;       //Default: 0 - Initial microsecond set. Note: Javascript's native Date object does not natively support microseconds. Timepicker adds ability to simply Date.setMicroseconds(m) and Date.getMicroseconds(). Date comparisons will not acknowledge microseconds. Use this only for display purposes.
+    timezone?: number;      //Default: null - Initial timezone set.This is the offset in minutes.If null the browser's local timezone will be used. If you're timezone is "-0400" you would use - 240. For backwards compatibility you may pass "-0400", however the timezone is stored in minutes and more reliable.
+    hourMin?: number;        //Default: 0 - The minimum hour allowed for all dates.
+    minuteMin?: number;      //Default: 0 - The minimum minute allowed for all dates.
+    secondMin?: number;      //Default: 0 - The minimum second allowed for all dates.
+    millisecMin?: number;    //Default: 0 - The minimum millisecond allowed for all dates.
+    microsecMin?: number;    //Default: 0 - The minimum microsecond allowed for all dates.
+    hourMax?: number;        //Default: 23 - The maximum hour allowed for all dates.
+    minuteMax?: number;      //Default: 59 - The maximum minute allowed for all dates.
+    secondMax?: number;      //Default: 59 - The maximum second allowed for all dates.
+    millisecMax?: number;    //Default: 999 - The maximum millisecond allowed for all dates.
+    microsecMax?: number;    //Default: 999 - The maximum microsecond allowed for all dates.
+    hourGrid?: number;       //Default: 0 - When greater than 0 a label grid will be generated under the slider.This number represents the units (in hours) between labels.
+    minuteGrid?: number;     //Default: 0 - When greater than 0 a label grid will be generated under the slider.This number represents the units (in minutes) between labels.
+    secondGrid?: number;     //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in seconds) between labels.
+    millisecGrid?: number;   //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in milliseconds) between labels.
+    microsecGrid?: number;   //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in microseconds) between labels.
+
+    // Timezone options
+    timezoneList?: Array<TimezoneOptions> //Default: [generated timezones] - An array of timezones used to populate the timezone select.Can be an array of values or an array of objects: { label: "EDT", value: -240 }. The value should be the offset number in minutes.So "-0400" which is the format "-hhmm", would equate to - 240 minutes.
 }
 
 interface TimezoneOptions {
@@ -69,53 +101,16 @@ interface Time {
     timezone?: string;
 }
 
-interface TimeFieldOptions {
-    controlType: string;    //Default: 'slider' - Whether to use 'slider' or 'select'.If 'slider' is unavailable through jQueryUI, 'select' will be used.For advanced usage you may pass an object which implements "create", "options", "value" methods to use controls other than sliders or selects.See the _controls property in the source code for more details.
-    showHour?: boolean;     //Default: null - Whether to show the hour control. The default of null will use detection from timeFormat.
-    showMinute?: boolean;   //Default: null - Whether to show the minute control. The default of null will use detection from timeFormat.
-    showSecond?: boolean;   //Default: null - Whether to show the second control. The default of null will use detection from timeFormat.
-    showMillisec?: boolean; //Default: null - Whether to show the millisecond control. The default of null will use detection from timeFormat.
-    showMicrosec?: boolean; //Default: null - Whether to show the microsecond control. The default of null will use detection from timeFormat.
-    showTimezone?: boolean; //Default: null - Whether to show the timezone select.
-    showTime: boolean;      //Default: true - Whether to show the time selected within the datetimepicker.
-    stepHour: number;       //Default: 1 - Hours per step the slider makes.
-    stepMinute: number;     //Default: 1 - Minutes per step the slider makes.
-    stepSecond: number;     //Default: 1 - Seconds per step the slider makes.
-    stepMillisec: number;   //Default: 1 - Milliseconds per step the slider makes.
-    stepMicrosec: number;   //Default: 1 - Microseconds per step the slider makes.
-    hour: number;           //Default: 0 - Initial hour set.
-    minute: number;         //Default: 0 - Initial minute set.
-    second: number;         //Default: 0 - Initial second set.
-    millisec: number;       //Default: 0 - Initial millisecond set.
-    microsec: number;       //Default: 0 - Initial microsecond set. Note: Javascript's native Date object does not natively support microseconds. Timepicker adds ability to simply Date.setMicroseconds(m) and Date.getMicroseconds(). Date comparisons will not acknowledge microseconds. Use this only for display purposes.
-    timezone?: number;      //Default: null - Initial timezone set.This is the offset in minutes.If null the browser's local timezone will be used. If you're timezone is "-0400" you would use - 240. For backwards compatibility you may pass "-0400", however the timezone is stored in minutes and more reliable.
-    hourMin: number;        //Default: 0 - The minimum hour allowed for all dates.
-    minuteMin: number;      //Default: 0 - The minimum minute allowed for all dates.
-    secondMin: number;      //Default: 0 - The minimum second allowed for all dates.
-    millisecMin: number;    //Default: 0 - The minimum millisecond allowed for all dates.
-    microsecMin: number;    //Default: 0 - The minimum microsecond allowed for all dates.
-    hourMax: number;        //Default: 23 - The maximum hour allowed for all dates.
-    minuteMax: number;      //Default: 59 - The maximum minute allowed for all dates.
-    secondMax: number;      //Default: 59 - The maximum second allowed for all dates.
-    millisecMax: number;    //Default: 999 - The maximum millisecond allowed for all dates.
-    microsecMax: number;    //Default: 999 - The maximum microsecond allowed for all dates.
-    hourGrid: number;       //Default: 0 - When greater than 0 a label grid will be generated under the slider.This number represents the units (in hours) between labels.
-    minuteGrid: number;     //Default: 0 - When greater than 0 a label grid will be generated under the slider.This number represents the units (in minutes) between labels.
-    secondGrid: number;     //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in seconds) between labels.
-    millisecGrid: number;   //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in milliseconds) between labels.
-    microsecGrid: number;   //Default: 0 - When greater than 0 a label grid will be genereated under the slider.This number represents the units (in microseconds) between labels.
-}
-
 interface formatTimeOptions {
     format: string;
     time: Time;
-    options?: DateTimePickerLocalizationOptions;
+    options?: DateTimePickerOptions;
 }
 
 interface parseTimeOptions {
     format: string;
     time: string;
-    options?: DateTimePickerLocalizationOptions;
+    options?: DateTimePickerOptions;
 }
 
 interface parseDateTimeOptions {
@@ -129,12 +124,9 @@ interface parseDateTimeOptions {
 interface JQuery {
     datetimepicker(): JQuery;
     datetimepicker(options?: DateTimePickerOptions): JQuery;            
-
-    //datetimepicker(method: string): any;
     datetimepicker(method: string, methodParameter: any): any;
     datetimepicker(method: 'formatTime', methodParameter: formatTimeOptions): string;
     datetimepicker(method: 'parseTime', methodParameter: parseTimeOptions): Time;
     datetimepicker(method: 'parseDateTime', methodParameter: parseDateTimeOptions): Date;
-
 }
 

From 042cf083ffe821f752af83e3841e668a94c2ef93 Mon Sep 17 00:00:00 2001
From: dougajmcdonald <dougajmcdonald@gmail.com>
Date: Tue, 11 Mar 2014 14:11:59 +0000
Subject: [PATCH 080/309] Update jquery.ui.datetimepicker.d.ts

Updated reference to other d.ts (these were different for me locally)
---
 jquery.ui.datetimepicker/jquery.ui.datetimepicker.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/jquery.ui.datetimepicker/jquery.ui.datetimepicker.d.ts b/jquery.ui.datetimepicker/jquery.ui.datetimepicker.d.ts
index 047b7f0c9..9d452332b 100644
--- a/jquery.ui.datetimepicker/jquery.ui.datetimepicker.d.ts
+++ b/jquery.ui.datetimepicker/jquery.ui.datetimepicker.d.ts
@@ -4,8 +4,8 @@
 // Definitions by: https://github.com/dougajmcdonald
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-/// <reference path="jquery.d.ts"/>
-/// <reference path="jqueryui.d.ts"/>
+/// <reference path="../jquery/jquery.d.ts"/>
+/// <reference path="../jqueryui/jqueryui.d.ts"/>
 
 interface DateTimePickerOptions extends JQueryUI.DatepickerOptions {
 

From a0b676989cce801fa70fa3b66c4df43a8196a5fc Mon Sep 17 00:00:00 2001
From: dougajmcdonald <dougajmcdonald@gmail.com>
Date: Tue, 11 Mar 2014 14:12:30 +0000
Subject: [PATCH 081/309] Create jquery.ui.datetimepicker-tests.ts

---
 .../jquery.ui.datetimepicker-tests.ts         | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 jquery.ui.datetimepicker/jquery.ui.datetimepicker-tests.ts

diff --git a/jquery.ui.datetimepicker/jquery.ui.datetimepicker-tests.ts b/jquery.ui.datetimepicker/jquery.ui.datetimepicker-tests.ts
new file mode 100644
index 000000000..52ae3e2e6
--- /dev/null
+++ b/jquery.ui.datetimepicker/jquery.ui.datetimepicker-tests.ts
@@ -0,0 +1,22 @@
+/// <reference path="../jquery/jquery.d.ts"/>
+/// <reference path="jquery.ui.datetimepicker.d.ts" />
+
+// basic no options
+$('#datetimepicker').datetimepicker({
+    
+});
+
+// basic with some options
+$('#datetimepicker').datetimepicker({
+    dateFormat: "yy-mm-dd",
+    timeFormat: 'HH:mm',
+    nextText: "",
+    prevText: ""
+});
+
+// function within the plugin
+$('#datetimepicker').datetimepicker('formatTime', {
+    format: "HH:mm",
+    time: { hours: 1, minutes: 1, seconds: 1 }
+});
+

From 90dd6ead84d4bfe115457c61c47c72ff20d7d049 Mon Sep 17 00:00:00 2001
From: Santi Albo <santialbo@gmail.com>
Date: Wed, 12 Mar 2014 11:49:04 +0000
Subject: [PATCH 082/309] Fix typo on restify type definition

InvalidArgu**e**mentError => InvalidArgumentError
---
 restify/restify.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/restify/restify.d.ts b/restify/restify.d.ts
index 2afacc520..2b447d11b 100644
--- a/restify/restify.d.ts
+++ b/restify/restify.d.ts
@@ -167,7 +167,7 @@ declare module "restify" {
   export function createClient(options?: ClientOptions): HttpClient;
 
   export class ConflictError { constructor(message?: any); }
-  export class InvalidArguementError { constructor(message?: any); }
+  export class InvalidArgumentError { constructor(message?: any); }
   export class RestError { constructor(message?: any); }
   export class BadDigestError { constructor(message: any); }
   export class BadMethodError { constructor(message: any); }

From 08fcf45312c5b25576c07332653ac0d2c3e06b9a Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Wed, 12 Mar 2014 13:15:28 +0000
Subject: [PATCH 083/309] jQuery: 1 more step along the world

to JSDoc completeness I go...
---
 jquery/jquery-tests.ts |   6 ++
 jquery/jquery.d.ts     | 197 +++++++++++++++++++++++++++++++++++++++--
 2 files changed, 194 insertions(+), 9 deletions(-)

diff --git a/jquery/jquery-tests.ts b/jquery/jquery-tests.ts
index 6778f4071..2e48183cd 100644
--- a/jquery/jquery-tests.ts
+++ b/jquery/jquery-tests.ts
@@ -887,6 +887,12 @@ function test_clone() {
           .clone());
 }
 
+function test_prependTo() {
+    $("<p>Test</p>").prependTo(".inner");
+    $("h2").prependTo($(".container"));
+    $("span").prependTo("#foo");
+}
+
 function test_closest() {
     $('li.item-a').closest('ul')
         .css('background-color', 'red');
diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 5fb884b08..64edfa0f8 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -2819,24 +2819,203 @@ interface JQuery {
      */
     appendTo(target: string): JQuery;
 
-    before(...content: any[]): JQuery;
-    before(func: (index: any) => any): JQuery;
+    /**
+     * Insert content, specified by the parameter, before each element in the set of matched elements.
+     * 
+     * param content1 HTML string, DOM element, array of elements, or jQuery object to insert before each element in the set of matched elements.
+     * param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert before each element in the set of matched elements.
+     */
+    before(content1: JQuery, ...content2: any[]): JQuery;
+    /**
+     * Insert content, specified by the parameter, before each element in the set of matched elements.
+     * 
+     * param content1 HTML string, DOM element, array of elements, or jQuery object to insert before each element in the set of matched elements.
+     * param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert before each element in the set of matched elements.
+     */
+    before(content1: any[], ...content2: any[]): JQuery;
+    /**
+     * Insert content, specified by the parameter, before each element in the set of matched elements.
+     * 
+     * param content1 HTML string, DOM element, array of elements, or jQuery object to insert before each element in the set of matched elements.
+     * param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert before each element in the set of matched elements.
+     */
+    before(content1: Element, ...content2: any[]): JQuery;
+    /**
+     * Insert content, specified by the parameter, before each element in the set of matched elements.
+     * 
+     * param content1 HTML string, DOM element, array of elements, or jQuery object to insert before each element in the set of matched elements.
+     * param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert before each element in the set of matched elements.
+     */
+    before(content1: Text, ...content2: any[]): JQuery;
+    /**
+     * Insert content, specified by the parameter, before each element in the set of matched elements.
+     * 
+     * param content1 HTML string, DOM element, array of elements, or jQuery object to insert before each element in the set of matched elements.
+     * param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert before each element in the set of matched elements.
+     */
+    before(content1: string, ...content2: any[]): JQuery;
+    /**
+     * Insert content, specified by the parameter, before each element in the set of matched elements.
+     * 
+     * param func A function that returns an HTML string, DOM element(s), or jQuery object to insert before each element in the set of matched elements. Receives the index position of the element in the set as an argument. Within the function, this refers to the current element in the set.
+     */
+    before(func: (index: number) => any): JQuery;
 
+    /**
+     * Create a deep copy of the set of matched elements.
+     * 
+     * param withDataAndEvents A Boolean indicating whether event handlers and data should be copied along with the elements. The default value is false.
+     * param deepWithDataAndEvents A Boolean indicating whether event handlers and data for all children of the cloned element should be copied. By default its value matches the first argument's value (which defaults to false).
+     */
     clone(withDataAndEvents?: boolean, deepWithDataAndEvents?: boolean): JQuery;
 
-    detach(selector?: any): JQuery;
+    /**
+     * Remove the set of matched elements from the DOM.
+     * 
+     * param selector A selector expression that filters the set of matched elements to be removed.
+     */
+    detach(selector?: string): JQuery;
 
+    /**
+     * Remove all child nodes of the set of matched elements from the DOM.
+     */
     empty(): JQuery;
 
-    insertAfter(target: any): JQuery;
-    insertBefore(target: any): JQuery;
+    /**
+     * Insert every element in the set of matched elements after the target.
+     * 
+     * param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements will be inserted after the element(s) specified by this parameter.
+     */
+    insertAfter(target: JQuery): JQuery;
+    /**
+     * Insert every element in the set of matched elements after the target.
+     * 
+     * param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements will be inserted after the element(s) specified by this parameter.
+     */
+    insertAfter(target: any[]): JQuery;
+    /**
+     * Insert every element in the set of matched elements after the target.
+     * 
+     * param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements will be inserted after the element(s) specified by this parameter.
+     */
+    insertAfter(target: Element): JQuery;
+    /**
+     * Insert every element in the set of matched elements after the target.
+     * 
+     * param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements will be inserted after the element(s) specified by this parameter.
+     */
+    insertAfter(target: Text): JQuery;
+    /**
+     * Insert every element in the set of matched elements after the target.
+     * 
+     * param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements will be inserted after the element(s) specified by this parameter.
+     */
+    insertAfter(target: string): JQuery;
 
-    prepend(...content: any[]): JQuery;
-    prepend(func: (index: any, html: any) => any): JQuery;
+    /**
+     * Insert every element in the set of matched elements before the target.
+     * 
+     * param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements will be inserted before the element(s) specified by this parameter.
+     */
+    insertBefore(target: JQuery): JQuery;
+    /**
+     * Insert every element in the set of matched elements before the target.
+     * 
+     * param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements will be inserted before the element(s) specified by this parameter.
+     */
+    insertBefore(target: any[]): JQuery;
+    /**
+     * Insert every element in the set of matched elements before the target.
+     * 
+     * param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements will be inserted before the element(s) specified by this parameter.
+     */
+    insertBefore(target: Element): JQuery;
+    /**
+     * Insert every element in the set of matched elements before the target.
+     * 
+     * param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements will be inserted before the element(s) specified by this parameter.
+     */
+    insertBefore(target: Text): JQuery;
+    /**
+     * Insert every element in the set of matched elements before the target.
+     * 
+     * param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements will be inserted before the element(s) specified by this parameter.
+     */
+    insertBefore(target: string): JQuery;
 
-    prependTo(target: any): JQuery;
+    /**
+     * Insert content, specified by the parameter, to the beginning of each element in the set of matched elements.
+     * 
+     * param content1 DOM element, array of elements, HTML string, or jQuery object to insert at the beginning of each element in the set of matched elements.
+     * param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert at the beginning of each element in the set of matched elements.
+     */
+    prepend(content1: JQuery, ...content2: any[]): JQuery;
+    /**
+     * Insert content, specified by the parameter, to the beginning of each element in the set of matched elements.
+     * 
+     * param content1 DOM element, array of elements, HTML string, or jQuery object to insert at the beginning of each element in the set of matched elements.
+     * param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert at the beginning of each element in the set of matched elements.
+     */
+    prepend(content1: any[], ...content2: any[]): JQuery;
+    /**
+     * Insert content, specified by the parameter, to the beginning of each element in the set of matched elements.
+     * 
+     * param content1 DOM element, array of elements, HTML string, or jQuery object to insert at the beginning of each element in the set of matched elements.
+     * param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert at the beginning of each element in the set of matched elements.
+     */
+    prepend(content1: Element, ...content2: any[]): JQuery;
+    /**
+     * Insert content, specified by the parameter, to the beginning of each element in the set of matched elements.
+     * 
+     * param content1 DOM element, array of elements, HTML string, or jQuery object to insert at the beginning of each element in the set of matched elements.
+     * param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert at the beginning of each element in the set of matched elements.
+     */
+    prepend(content1: Text, ...content2: any[]): JQuery;
+    /**
+     * Insert content, specified by the parameter, to the beginning of each element in the set of matched elements.
+     * 
+     * param content1 DOM element, array of elements, HTML string, or jQuery object to insert at the beginning of each element in the set of matched elements.
+     * param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert at the beginning of each element in the set of matched elements.
+     */
+    prepend(content1: string, ...content2: any[]): JQuery;
+    /**
+     * Insert content, specified by the parameter, to the beginning of each element in the set of matched elements.
+     * 
+     * param func A function that returns an HTML string, DOM element(s), or jQuery object to insert at the beginning of each element in the set of matched elements. Receives the index position of the element in the set and the old HTML value of the element as arguments. Within the function, this refers to the current element in the set.
+     */
+    prepend(func: (index: number, html: string) => any): JQuery;
 
-    remove(selector?: any): JQuery;
+    /**
+     * Insert every element in the set of matched elements to the beginning of the target.
+     * 
+     * @param target A selector, element, HTML string, array of elements, or jQuery object; the matched set of elements will be inserted at the beginning of the element(s) specified by this parameter.
+     */
+    prependTo(target: JQuery): JQuery;
+    /**
+     * Insert every element in the set of matched elements to the beginning of the target.
+     * 
+     * @param target A selector, element, HTML string, array of elements, or jQuery object; the matched set of elements will be inserted at the beginning of the element(s) specified by this parameter.
+     */
+    prependTo(target: any[]): JQuery;
+    /**
+     * Insert every element in the set of matched elements to the beginning of the target.
+     * 
+     * @param target A selector, element, HTML string, array of elements, or jQuery object; the matched set of elements will be inserted at the beginning of the element(s) specified by this parameter.
+     */
+    prependTo(target: Element): JQuery;
+    /**
+     * Insert every element in the set of matched elements to the beginning of the target.
+     * 
+     * @param target A selector, element, HTML string, array of elements, or jQuery object; the matched set of elements will be inserted at the beginning of the element(s) specified by this parameter.
+     */
+    prependTo(target: string): JQuery;
+
+    /**
+     * Remove the set of matched elements from the DOM.
+     * 
+     * @param selector A selector expression that filters the set of matched elements to be removed.
+     */
+    remove(selector?: string): JQuery;
 
     replaceAll(target: any): JQuery;
 

From adbdf2705fd84deda0f194b706bfc6a4737cff06 Mon Sep 17 00:00:00 2001
From: 44ka28ta <44ka28ta@gmail.com>
Date: Thu, 13 Mar 2014 03:32:59 +0900
Subject: [PATCH 084/309] fix the return type of google.maps.Polygon.getPaths

---
 googlemaps/google.maps.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/googlemaps/google.maps.d.ts b/googlemaps/google.maps.d.ts
index 4589e09f0..86a446508 100644
--- a/googlemaps/google.maps.d.ts
+++ b/googlemaps/google.maps.d.ts
@@ -367,7 +367,7 @@ declare module google.maps {
         getEditable(): boolean;
         getMap(): Map;
         getPath(): MVCArray;
-        getPaths(): MVCArray[];
+        getPaths(): MVCArray;
         getVisible(): boolean;
         setDraggable(draggable: boolean): void;
         setEditable(editable: boolean): void;

From fd156f57315610eec03ff8f80901dc011f6e60cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?St=C3=A9phane=20Le=20Dorze?= <stephane.ledorze@gmail.com>
Date: Wed, 12 Mar 2014 23:46:36 +0100
Subject: [PATCH 085/309] fix polymorphism in Async type signature (how the
 hell were people using it before??)

---
 async/async.d.ts | 60 +++++++++++++++++++++++++-----------------------
 1 file changed, 31 insertions(+), 29 deletions(-)

diff --git a/async/async.d.ts b/async/async.d.ts
index 12aa4123f..b88083c27 100644
--- a/async/async.d.ts
+++ b/async/async.d.ts
@@ -4,10 +4,12 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 interface AsyncMultipleResultsCallback<T> { (err: string, results: T[]): any; }
-interface AsyncSingleResultCallback<T> { (err: string, result: T): any; }
+interface AsyncSingleResultCallback<T> { (err: string, result: T): void; }
 interface AsyncTimesCallback<T> { (n: number, callback: AsyncMultipleResultsCallback<T>): void; }
-interface AsyncIterator<T> { (item: T, callback: AsyncMultipleResultsCallback<T>): void; }
-interface AsyncMemoIterator<T> { (memo: T, item: T, callback: AsyncSingleResultCallback<T>): void; }
+
+interface AsyncIterator<T, R> { (item: T, callback: AsyncSingleResultCallback<R>): void; }
+interface AsyncMemoIterator<T, R> { (memo: R, item: T, callback: AsyncSingleResultCallback<R>): void; }
+
 interface AsyncWorker<T> { (task: T, callback: Function): void; }
 
 interface AsyncQueue<T> {
@@ -22,31 +24,31 @@ interface AsyncQueue<T> {
 interface Async {
 
     // Collections
-    forEach<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>): void;
-    forEachSeries<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>): void;
-    forEachLimit<T>(arr: T[], limit: number, iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>): void;
-    map<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
-    mapSeries<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
-    filter<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
-    select<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
-    filterSeries<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
-    selectSeries<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
-    reject<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
-    rejectSeries<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
-    reduce<T>(arr: T[], memo: T, iterator: AsyncMemoIterator<T>, callback: AsyncSingleResultCallback<T>);
-    inject<T>(arr: T[], memo: T, iterator: AsyncMemoIterator<T>, callback: AsyncSingleResultCallback<T>);
-    foldl<T>(arr: T[], memo: T, iterator: AsyncMemoIterator<T>, callback: AsyncSingleResultCallback<T>);
-    reduceRight<T>(arr: T[], memo: T, iterator: AsyncMemoIterator<T>, callback: AsyncSingleResultCallback<T>);
-    foldr<T, U>(arr: T[], memo: T, iterator: AsyncMemoIterator<T>, callback: AsyncSingleResultCallback<T>);
-    detect<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
-    detectSeries<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
-    sortBy<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
-    some<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
-    any<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
-    every<T>(arr: T[], iterator: AsyncIterator<T>, callback: (result: boolean) => any);
-    all<T>(arr: T[], iterator: AsyncIterator<T>, callback: (result: boolean) => any);
-    concat<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
-    concatSeries<T>(arr: T[], iterator: AsyncIterator<T>, callback: AsyncMultipleResultsCallback<T>);
+    forEach<T,R>(arr: T[], iterator: AsyncIterator<T, R>, callback: AsyncMultipleResultsCallback<R>): void;
+    forEachSeries<T, R>(arr: T[], iterator: AsyncIterator<T, R>, callback: AsyncMultipleResultsCallback<R>): void;
+    forEachLimit<T, R>(arr: T[], limit: number, iterator: AsyncIterator<T, R>, callback: AsyncMultipleResultsCallback<R>): void;
+    map<T, R>(arr: T[], iterator: AsyncIterator<T, R>, callback: AsyncMultipleResultsCallback<R>);
+    mapSeries<T, R>(arr: T[], iterator: AsyncIterator<T, R>, callback: AsyncMultipleResultsCallback<R>);
+    filter<T>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
+    select<T, R>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
+    filterSeries<T, R>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
+    selectSeries<T, R>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
+    reject<T>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
+    rejectSeries<T>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
+    reduce<T, R>(arr: T[], memo: T, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
+    inject<T, R>(arr: T[], memo: T, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
+    foldl<T, R>(arr: T[], memo: T, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
+    reduceRight<T, R>(arr: T[], memo: T, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
+    foldr<T, R>(arr: T[], memo: T, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
+    detect<T>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
+    detectSeries<T>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
+    sortBy<T, V>(arr: T[], iterator: AsyncIterator<T, V>, callback: AsyncMultipleResultsCallback<T>);
+    some<T>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
+    any<T>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
+    every<T>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: (result: boolean) => any);
+    all<T>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: (result: boolean) => any);
+    concat<T, R>(arr: T[], iterator: AsyncIterator<T, R[]>, callback: AsyncMultipleResultsCallback<R>);
+    concatSeries<T, R>(arr: T[], iterator: AsyncIterator<T, R[]>, callback: AsyncMultipleResultsCallback<R>);
 
     // Control Flow
     series<T>(tasks: T[], callback?: AsyncMultipleResultsCallback<T>): void;
@@ -78,5 +80,5 @@ interface Async {
 declare var async: Async;
 
 declare module "async" {
-	export = async;
+    export = async;
 }

From ca93f092ed36eabdb2c82dc3c72f231d91e140b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?St=C3=A9phane=20Le=20Dorze?= <stephane.ledorze@gmail.com>
Date: Wed, 12 Mar 2014 23:52:30 +0100
Subject: [PATCH 086/309] fix memo type

---
 async/async.d.ts | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/async/async.d.ts b/async/async.d.ts
index b88083c27..f36c654df 100644
--- a/async/async.d.ts
+++ b/async/async.d.ts
@@ -35,11 +35,11 @@ interface Async {
     selectSeries<T, R>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
     reject<T>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
     rejectSeries<T>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
-    reduce<T, R>(arr: T[], memo: T, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
-    inject<T, R>(arr: T[], memo: T, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
-    foldl<T, R>(arr: T[], memo: T, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
-    reduceRight<T, R>(arr: T[], memo: T, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
-    foldr<T, R>(arr: T[], memo: T, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
+    reduce<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
+    inject<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
+    foldl<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
+    reduceRight<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
+    foldr<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback: AsyncSingleResultCallback<R>);
     detect<T>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
     detectSeries<T>(arr: T[], iterator: AsyncIterator<T, boolean>, callback: AsyncMultipleResultsCallback<T>);
     sortBy<T, V>(arr: T[], iterator: AsyncIterator<T, V>, callback: AsyncMultipleResultsCallback<T>);

From f1cd2ccc323ed6cd3ce90bd34d0438e7e7193e24 Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Thu, 13 Mar 2014 10:37:17 +0000
Subject: [PATCH 087/309] jQuery: continuing JSDoc

Introducing missing test suites / tightening up typings along the way
---
 jquery/jquery-tests.ts | 56 ++++++++++++++++++++++-------
 jquery/jquery.d.ts     | 82 +++++++++++++++++++++++++++++++++++++++---
 2 files changed, 121 insertions(+), 17 deletions(-)

diff --git a/jquery/jquery-tests.ts b/jquery/jquery-tests.ts
index 2e48183cd..e22e1deff 100644
--- a/jquery/jquery-tests.ts
+++ b/jquery/jquery-tests.ts
@@ -418,7 +418,7 @@ function test_slideToggle() {
     $("#aa").click(function () {
         $("div:not(.still)").slideToggle("slow", function () {
             var n = parseInt($("span").text(), 10);
-            $("span").text(n + 1);
+            $("span").text((n + 1).toString());
         });
     });
 }
@@ -2143,13 +2143,13 @@ function test_html() {
 function test_inArray() {
     var arr: any[] = [4, "Pete", 8, "John"];
     var $spans = $("span");
-    $spans.eq(0).text(jQuery.inArray("John", arr));
-    $spans.eq(1).text(jQuery.inArray(4, arr));
-    $spans.eq(2).text(jQuery.inArray("Karl", arr));
-    $spans.eq(3).text(jQuery.inArray("Pete", arr, 2));
+    $spans.eq(0).text(jQuery.inArray("John", arr).toString());
+    $spans.eq(1).text(jQuery.inArray(4, arr).toString());
+    $spans.eq(2).text(jQuery.inArray("Karl", arr).toString());
+    $spans.eq(3).text(jQuery.inArray("Pete", arr, 2).toString());
 
     var arr2: number[] = [1, 2, 3, 4];
-    $spans.eq(1).text(jQuery.inArray(4, arr2));
+    $spans.eq(1).text(jQuery.inArray(4, arr2).toString());
 }
 
 function test_index() {
@@ -2384,7 +2384,7 @@ function test_isFunction() {
     ];
     jQuery.each(objs, function (i) {
         var isFunc = jQuery.isFunction(objs[i]);
-        $("span").eq(i).text(isFunc);
+        $("span").eq(i).text(isFunc.toString());
     });
     $.isFunction(function () { });
 }
@@ -2749,7 +2749,7 @@ function test_mouseenter() {
     var n = 0;
     $("div.enterleave").mouseenter(function () {
         $("p:first", this).text("mouse enter");
-        $("p:last", this).text(++n);
+        $("p:last", this).text((++n).toString());
     }).mouseleave(function () {
         $("p:first", this).text("mouse leave");
     });
@@ -2767,14 +2767,14 @@ function test_mouseleave() {
         $("p:first", this).text("mouse over");
     }).mouseout(function () {
         $("p:first", this).text("mouse out");
-        $("p:last", this).text(++i);
+        $("p:last", this).text((++i).toString());
     });
     var n = 0;
     $("div.enterleave").mouseenter(function () {
         $("p:first", this).text("mouse enter");
     }).mouseleave(function () {
         $("p:first", this).text("mouse leave");
-        $("p:last", this).text(++n);
+        $("p:last", this).text((++n).toString());
     });
 }
 
@@ -2805,7 +2805,7 @@ function test_mouseout() {
     var i = 0;
     $("div.overout").mouseout(function () {
         $("p:first", this).text("mouse out");
-        $("p:last", this).text(++i);
+        $("p:last", this).text((++i).toString());
     }).mouseover(function () {
         $("p:first", this).text("mouse over");
     });
@@ -2814,7 +2814,7 @@ function test_mouseout() {
         $("p:first", this).text("mouse enter");
     }).bind("mouseleave", function () {
         $("p:first", this).text("mouse leave");
-        $("p:last", this).text(++n);
+        $("p:last", this).text((++n).toString());
     });
 }
 
@@ -2847,7 +2847,7 @@ function test_mouseover() {
     var i = 0;
     $("div.overout").mouseover(function () {
         $("p:first", this).text("mouse over");
-        $("p:last", this).text(++i);
+        $("p:last", this).text((++i).toString());
     }).mouseout(function () {
         $("p:first", this).text("mouse out");
     });
@@ -2870,6 +2870,36 @@ function test_makeArray() {
     jQuery.isArray(arr) === true;
 }
 
+function test_replaceAll() {
+    $("<h2>New heading</h2>").replaceAll(".inner");
+    $(".first").replaceAll(".third");
+    $("<b>Paragraph. </b>").replaceAll("p");
+}
+
+function test_replaceWith() {
+    $("div.second").replaceWith("<h2>New heading</h2>");
+    $("div.inner").replaceWith("<h2>New heading</h2>");
+    $("div.third").replaceWith($(".first"));
+
+    $("button").click(function () {
+        $(this).replaceWith("<div>" + $(this).text() + "</div>");
+    });
+
+    $("p").replaceWith("<b>Paragraph. </b>");
+
+    $("p").click(function () {
+        $(this).replaceWith($("div"));
+    });
+
+    $("button").on("click", function () {
+        var $container = $("div.container").replaceWith(function () {
+            return $(this).contents();
+        });
+
+        $("p").append($container.attr("class"));
+    });
+}
+
 function test_map() {
     $(':checkbox').map(function () {
         return this.id;
diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 64edfa0f8..67baf90e3 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -3017,14 +3017,88 @@ interface JQuery {
      */
     remove(selector?: string): JQuery;
 
-    replaceAll(target: any): JQuery;
+    /**
+     * Replace each target element with the set of matched elements.
+     * 
+     * @param target A selector string, jQuery object, DOM element, or array of elements indicating which element(s) to replace.
+     */
+    replaceAll(target: JQuery): JQuery;
+    /**
+     * Replace each target element with the set of matched elements.
+     * 
+     * @param target A selector string, jQuery object, DOM element, or array of elements indicating which element(s) to replace.
+     */
+    replaceAll(target: any[]): JQuery;
+    /**
+     * Replace each target element with the set of matched elements.
+     * 
+     * @param target A selector string, jQuery object, DOM element, or array of elements indicating which element(s) to replace.
+     */
+    replaceAll(target: Element): JQuery;
+    /**
+     * Replace each target element with the set of matched elements.
+     * 
+     * @param target A selector string, jQuery object, DOM element, or array of elements indicating which element(s) to replace.
+     */
+    replaceAll(target: string): JQuery;
 
-    replaceWith(func: any): JQuery;
+    /**
+     * Replace each element in the set of matched elements with the provided new content and return the set of elements that was removed.
+     * 
+     * param newContent The content to insert. May be an HTML string, DOM element, array of DOM elements, or jQuery object.
+     */
+    replaceWith(newContent: JQuery): JQuery;
+    /**
+     * Replace each element in the set of matched elements with the provided new content and return the set of elements that was removed.
+     * 
+     * param newContent The content to insert. May be an HTML string, DOM element, array of DOM elements, or jQuery object.
+     */
+    replaceWith(newContent: any[]): JQuery;
+    /**
+     * Replace each element in the set of matched elements with the provided new content and return the set of elements that was removed.
+     * 
+     * param newContent The content to insert. May be an HTML string, DOM element, array of DOM elements, or jQuery object.
+     */
+    replaceWith(newContent: Element): JQuery;
+    /**
+     * Replace each element in the set of matched elements with the provided new content and return the set of elements that was removed.
+     * 
+     * param newContent The content to insert. May be an HTML string, DOM element, array of DOM elements, or jQuery object.
+     */
+    replaceWith(newContent: Text): JQuery;
+    /**
+     * Replace each element in the set of matched elements with the provided new content and return the set of elements that was removed.
+     * 
+     * param newContent The content to insert. May be an HTML string, DOM element, array of DOM elements, or jQuery object.
+     */
+    replaceWith(newContent: string): JQuery;
+    /**
+     * Replace each element in the set of matched elements with the provided new content and return the set of elements that was removed.
+     * 
+     * param func A function that returns content with which to replace the set of matched elements.
+     */
+    replaceWith(func: () => any): JQuery;
 
+    /**
+     * Get the combined text contents of each element in the set of matched elements, including their descendants.
+     */
     text(): string;
-    text(textString: any): JQuery;
-    text(textString: (index: number, text: string) => string): JQuery;
+    /**
+     * Set the content of each element in the set of matched elements to the specified text.
+     * 
+     * @param textString A string of text to set as the content of each matched element.
+     */
+    text(textString: string): JQuery;
+    /**
+     * Set the content of each element in the set of matched elements to the specified text.
+     * 
+     * @param func A function returning the text content to set. Receives the index position of the element in the set and the old text value as arguments.
+     */
+    text(func: (index: number, text: string) => string): JQuery;
 
+    /**
+     * Retrieve all the elements contained in the jQuery set, as an array.
+     */
     toArray(): any[];
 
     unwrap(): JQuery;

From 64f7f2b63094dfe1feb2a1fceb0558c993d972b8 Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Thu, 13 Mar 2014 14:02:36 +0000
Subject: [PATCH 088/309] jQuery: expanded text to cover number and boolean

following input from @dmethvin
---
 jquery/jquery-tests.ts | 28 ++++++++++++++--------------
 jquery/jquery.d.ts     | 16 ++++++++++++++--
 2 files changed, 28 insertions(+), 16 deletions(-)

diff --git a/jquery/jquery-tests.ts b/jquery/jquery-tests.ts
index e22e1deff..1a03968ec 100644
--- a/jquery/jquery-tests.ts
+++ b/jquery/jquery-tests.ts
@@ -418,7 +418,7 @@ function test_slideToggle() {
     $("#aa").click(function () {
         $("div:not(.still)").slideToggle("slow", function () {
             var n = parseInt($("span").text(), 10);
-            $("span").text((n + 1).toString());
+            $("span").text(n + 1);
         });
     });
 }
@@ -763,7 +763,7 @@ function test_children() {
         var $kids = $(e.target).children();
         var len = $kids.addClass("hilite").length;
 
-        $("#results span:first").text(len.toString());
+        $("#results span:first").text(len);
         //$("#results span:last").text(e.target.tagName);
 
         e.preventDefault();
@@ -2143,13 +2143,13 @@ function test_html() {
 function test_inArray() {
     var arr: any[] = [4, "Pete", 8, "John"];
     var $spans = $("span");
-    $spans.eq(0).text(jQuery.inArray("John", arr).toString());
-    $spans.eq(1).text(jQuery.inArray(4, arr).toString());
-    $spans.eq(2).text(jQuery.inArray("Karl", arr).toString());
-    $spans.eq(3).text(jQuery.inArray("Pete", arr, 2).toString());
+    $spans.eq(0).text(jQuery.inArray("John", arr));
+    $spans.eq(1).text(jQuery.inArray(4, arr));
+    $spans.eq(2).text(jQuery.inArray("Karl", arr));
+    $spans.eq(3).text(jQuery.inArray("Pete", arr, 2));
 
     var arr2: number[] = [1, 2, 3, 4];
-    $spans.eq(1).text(jQuery.inArray(4, arr2).toString());
+    $spans.eq(1).text(jQuery.inArray(4, arr2));
 }
 
 function test_index() {
@@ -2384,7 +2384,7 @@ function test_isFunction() {
     ];
     jQuery.each(objs, function (i) {
         var isFunc = jQuery.isFunction(objs[i]);
-        $("span").eq(i).text(isFunc.toString());
+        $("span").eq(i).text(isFunc);
     });
     $.isFunction(function () { });
 }
@@ -2749,7 +2749,7 @@ function test_mouseenter() {
     var n = 0;
     $("div.enterleave").mouseenter(function () {
         $("p:first", this).text("mouse enter");
-        $("p:last", this).text((++n).toString());
+        $("p:last", this).text(++n);
     }).mouseleave(function () {
         $("p:first", this).text("mouse leave");
     });
@@ -2767,14 +2767,14 @@ function test_mouseleave() {
         $("p:first", this).text("mouse over");
     }).mouseout(function () {
         $("p:first", this).text("mouse out");
-        $("p:last", this).text((++i).toString());
+        $("p:last", this).text(++i);
     });
     var n = 0;
     $("div.enterleave").mouseenter(function () {
         $("p:first", this).text("mouse enter");
     }).mouseleave(function () {
         $("p:first", this).text("mouse leave");
-        $("p:last", this).text((++n).toString());
+        $("p:last", this).text(++n);
     });
 }
 
@@ -2805,7 +2805,7 @@ function test_mouseout() {
     var i = 0;
     $("div.overout").mouseout(function () {
         $("p:first", this).text("mouse out");
-        $("p:last", this).text((++i).toString());
+        $("p:last", this).text(++i);
     }).mouseover(function () {
         $("p:first", this).text("mouse over");
     });
@@ -2814,7 +2814,7 @@ function test_mouseout() {
         $("p:first", this).text("mouse enter");
     }).bind("mouseleave", function () {
         $("p:first", this).text("mouse leave");
-        $("p:last", this).text((++n).toString());
+        $("p:last", this).text(++n);
     });
 }
 
@@ -2847,7 +2847,7 @@ function test_mouseover() {
     var i = 0;
     $("div.overout").mouseover(function () {
         $("p:first", this).text("mouse over");
-        $("p:last", this).text((++i).toString());
+        $("p:last", this).text(++i);
     }).mouseout(function () {
         $("p:first", this).text("mouse out");
     });
diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 67baf90e3..41f0e15f7 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -3086,9 +3086,21 @@ interface JQuery {
     /**
      * Set the content of each element in the set of matched elements to the specified text.
      * 
-     * @param textString A string of text to set as the content of each matched element.
+     * @param text The text to set as the content of each matched element.
      */
-    text(textString: string): JQuery;
+    text(text: string): JQuery;
+    /**
+     * Set the content of each element in the set of matched elements to the specified text.
+     * 
+     * @param text The text to set as the content of each matched element.
+     */
+    text(text: number): JQuery;
+    /**
+     * Set the content of each element in the set of matched elements to the specified text.
+     * 
+     * @param text The text to set as the content of each matched element.
+     */
+    text(text: boolean): JQuery;
     /**
      * Set the content of each element in the set of matched elements to the specified text.
      * 

From b5e1b5bf5410762ad94fdba905d488f76ec11302 Mon Sep 17 00:00:00 2001
From: cannn <celik.can@gmail.com>
Date: Thu, 13 Mar 2014 15:52:40 +0100
Subject: [PATCH 089/309] Update jquery.address.d.ts

support for several additional functions of jquery.address
---
 jquery.address/jquery.address.d.ts | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/jquery.address/jquery.address.d.ts b/jquery.address/jquery.address.d.ts
index cb7117245..bbf91d84a 100644
--- a/jquery.address/jquery.address.d.ts
+++ b/jquery.address/jquery.address.d.ts
@@ -10,6 +10,13 @@ interface JQueryAddressStatic {
     change(callback: any): void;
     value(url: any): void;
     update(): void;
+    path(): string;
+    path(value: string): void;
+    internalChange(eventhandler: Function): void;
+    externalChange(eventhandler: Function): void;
+    parameter(name: string, value?: string): string;
+    value(): string;
+    history(value: boolean): void;    
 }
 
 interface JQueryAddress {

From 246e0785b887f8070d9d2640bca066edc7d99b17 Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Fri, 14 Mar 2014 10:16:19 +0000
Subject: [PATCH 090/309] jQuery: JSDoc completeness within reach

well nearly
---
 jquery/jquery-tests.ts |  81 ++++++++++++----
 jquery/jquery.d.ts     | 207 +++++++++++++++++++++++++++--------------
 svgjs/svgjs.d.ts       |   8 ++
 3 files changed, 210 insertions(+), 86 deletions(-)

diff --git a/jquery/jquery-tests.ts b/jquery/jquery-tests.ts
index 022e35f9c..53fbe55c3 100644
--- a/jquery/jquery-tests.ts
+++ b/jquery/jquery-tests.ts
@@ -1857,6 +1857,26 @@ function test_getScript() {
     });
 }
 
+function test_jQueryget() {
+    console.log($("li").get(0));
+    console.log($("li")[0]);
+    console.log($("li").get(-1));
+    $("*", document.body).click(function (event) {
+        event.stopPropagation();
+        var domElement = $(this).get(0);
+        $("span:first").text("Clicked on - " + domElement.nodeName);
+    });
+
+    function display(divs) {
+        var a = [];
+        for (var i = 0; i < divs.length; i++) {
+            a.push(divs[i].innerHTML);
+        }
+        $("span").text(a.join(" "));
+    }
+    display($("div").get().reverse());
+}
+
 function test_globalEval() {
     jQuery.globalEval("var newVar = true;");
 }
@@ -2021,6 +2041,38 @@ function test_height() {
     });
 }
 
+function test_wrap() {
+    $(".inner").wrap("<div class='new'></div>");
+    $(".inner").wrap(function () {
+        return "<div class='" + $(this).text() + "'></div>";
+    });
+    $("span").wrap("<div><div><p><em><b></b></em></p></div></div>");
+    $("p").wrap(document.createElement("div"));
+    $("p").wrap($(".doublediv"));
+}
+
+function test_wrapAll() {
+    $(".inner").wrapAll("<div class='new' />");
+    $("p").wrapAll("<div></div>");
+    $("span").wrapAll("<div><div><p><em><b></b></em></p></div></div>");
+    $("p").wrapAll(document.createElement("div"));
+    $("p").wrapAll($(".doublediv"));
+}
+
+function test_wrapInner() {
+    $(".inner").wrapInner("<div class='new'></div>");
+    $(".inner").wrapInner(function () {
+        return "<div class='" + this.nodeValue + "'></div>";
+    });
+    var elem: Element;
+    $(elem).wrapInner("<div class='test'></div>");
+    $(elem).wrapInner("<div class=\"test\"></div>");
+    $("p").wrapInner("<b></b>");
+    $("body").wrapInner("<div><div><p><em><b></b></em></p></div></div>");
+    $("p").wrapInner(document.createElement("b"));
+    $("p").wrapInner($("<span class='red'></span>"));
+}
+
 function test_width() {
     // Returns width of browser viewport
     $(window).width();
@@ -2172,17 +2224,11 @@ function test_index() {
 function test_innerHeight() {
     var p = $("p:first");
     $("p:last").text("innerHeight:" + p.innerHeight());
-
-    p.innerHeight(123);
-    p.innerHeight('123px');
 }
 
 function test_innerWidth() {
     var p = $("p:first");
     $("p:last").text("innerWidth:" + p.innerWidth());
-
-    p.innerWidth(123);
-    p.innerWidth('123px');
 }
 
 function test_outerHeight() {
@@ -2190,9 +2236,6 @@ function test_outerHeight() {
     $("p:last").text(
         "outerHeight:" + p.outerHeight() +
         " , outerHeight( true ):" + p.outerHeight(true));
-
-    p.outerHeight(123);
-    p.outerHeight('123px');
 }
 
 function test_outerWidth() {
@@ -2200,9 +2243,6 @@ function test_outerWidth() {
     $("p:last").text(
         "outerWidth:" + p.outerWidth() +
         " , outerWidth( true ):" + p.outerWidth(true));
-
-    p.outerWidth(123);
-    p.outerWidth('123px');
 }
 
 function test_scrollLeft() {
@@ -2920,16 +2960,25 @@ function test_map() {
         return $(this).val();
     }).get().join(", "));
     var mappedItems = $("li").map(function (index) {
-        var replacement = $("<li>").text($(this).text()).get(0);
-        if (index == 0) {
+        var replacement:any = $("<li>").text($(this).text()).get(0);
+        if (index === 0) {
+
+            // Make the first item all caps
             $(replacement).text($(replacement).text().toUpperCase());
-        } else if (index == 1 || index == 3) {
+        } else if (index === 1 || index === 3) {
+
+            // Delete the second and fourth items
             replacement = null;
-        } else if (index == 2) {
+        } else if (index === 2) {
+
+            // Make two of the third item and add some text
             replacement = [replacement, $("<li>").get(0)];
             $(replacement[0]).append("<b> - A</b>");
             $(replacement[1]).append("Extra <b> - B</b>");
         }
+
+        // Replacement will be a dom element, null,
+        // or an array of dom elements
         return replacement;
     });
     $("#results").append(mappedItems);
diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 5012181e8..540301746 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -1418,39 +1418,11 @@ interface JQuery {
      */
     innerHeight(): number;
 
-    /**
-     * Sets the inner height on elements in the set of matched elements, including padding but not border.
-     *
-     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
-     */
-    innerHeight(height: number): JQuery;
-
-    /**
-     * Sets the inner height on elements in the set of matched elements, including padding but not border.
-     *
-     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
-     */
-    innerHeight(height: string): JQuery;
-
     /**
      * Get the current computed width for the first element in the set of matched elements, including padding but not border.
      */
     innerWidth(): number;
 
-    /**
-     * Sets the inner width on elements in the set of matched elements, including padding but not border.
-     *
-     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
-     */
-    innerWidth(width: number): JQuery;
-
-    /**
-     * Sets the inner width on elements in the set of matched elements, including padding but not border.
-     *
-     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
-     */
-    innerWidth(width: string): JQuery;
-
     /**
      * Get the current coordinates of the first element in the set of matched elements, relative to the document.
      */
@@ -1475,20 +1447,6 @@ interface JQuery {
      */
     outerHeight(includeMargin?: boolean): number;
 
-    /**
-     * Sets the outer height on elements in the set of matched elements, including padding and border.
-     *
-     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
-     */
-    outerHeight(height: number): JQuery;
-
-    /**
-     * Sets the outer height on elements in the set of matched elements, including padding and border.
-     *
-     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
-     */
-    outerHeight(height: string): JQuery;
-
     /**
      * Get the current computed width for the first element in the set of matched elements, including padding and border.
      *
@@ -1496,20 +1454,6 @@ interface JQuery {
      */
     outerWidth(includeMargin?: boolean): number;
 
-    /**
-     * Sets the outer width on elements in the set of matched elements, including padding and border.
-     *
-     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
-     */
-    outerWidth(width: number): JQuery;
-
-    /**
-     * Sets the outer width on elements in the set of matched elements, including padding and border.
-     *
-     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
-     */
-    outerWidth(width: string): JQuery;
-
     /**
      * Get the current coordinates of the first element in the set of matched elements, relative to the offset parent.
      */
@@ -3169,15 +3113,79 @@ interface JQuery {
      */
     toArray(): any[];
 
+    /**
+     * Remove the parents of the set of matched elements from the DOM, leaving the matched elements in their place.
+     */
     unwrap(): JQuery;
 
-    wrap(wrappingElement: any): JQuery;
-    wrap(func: (index: any) => any): JQuery;
+    /**
+     * Wrap an HTML structure around each element in the set of matched elements.
+     * 
+     * @param wrappingElement A selector, element, HTML string, or jQuery object specifying the structure to wrap around the matched elements.
+     */
+    wrap(wrappingElement: JQuery): JQuery;
+    /**
+     * Wrap an HTML structure around each element in the set of matched elements.
+     * 
+     * @param wrappingElement A selector, element, HTML string, or jQuery object specifying the structure to wrap around the matched elements.
+     */
+    wrap(wrappingElement: Element): JQuery;
+    /**
+     * Wrap an HTML structure around each element in the set of matched elements.
+     * 
+     * @param wrappingElement A selector, element, HTML string, or jQuery object specifying the structure to wrap around the matched elements.
+     */
+    wrap(wrappingElement: string): JQuery;
+    /**
+     * Wrap an HTML structure around each element in the set of matched elements.
+     * 
+     * @param func A callback function returning the HTML content or jQuery object to wrap around the matched elements. Receives the index position of the element in the set as an argument. Within the function, this refers to the current element in the set.
+     */
+    wrap(func: (index: number) => any): JQuery;
 
-    wrapAll(wrappingElement: any): JQuery;
+    /**
+     * Wrap an HTML structure around all elements in the set of matched elements.
+     * 
+     * @param wrappingElement A selector, element, HTML string, or jQuery object specifying the structure to wrap around the matched elements.
+     */
+    wrapAll(wrappingElement: JQuery): JQuery;
+    /**
+     * Wrap an HTML structure around all elements in the set of matched elements.
+     * 
+     * @param wrappingElement A selector, element, HTML string, or jQuery object specifying the structure to wrap around the matched elements.
+     */
+    wrapAll(wrappingElement: Element): JQuery;
+    /**
+     * Wrap an HTML structure around all elements in the set of matched elements.
+     * 
+     * @param wrappingElement A selector, element, HTML string, or jQuery object specifying the structure to wrap around the matched elements.
+     */
+    wrapAll(wrappingElement: string): JQuery;
 
-    wrapInner(wrappingElement: any): JQuery;
-    wrapInner(func: (index: any) => any): JQuery;
+    /**
+     * Wrap an HTML structure around the content of each element in the set of matched elements.
+     * 
+     * @param wrappingElement An HTML snippet, selector expression, jQuery object, or DOM element specifying the structure to wrap around the content of the matched elements.
+     */
+    wrapInner(wrappingElement: JQuery): JQuery;
+    /**
+     * Wrap an HTML structure around the content of each element in the set of matched elements.
+     * 
+     * @param wrappingElement An HTML snippet, selector expression, jQuery object, or DOM element specifying the structure to wrap around the content of the matched elements.
+     */
+    wrapInner(wrappingElement: Element): JQuery;
+    /**
+     * Wrap an HTML structure around the content of each element in the set of matched elements.
+     * 
+     * @param wrappingElement An HTML snippet, selector expression, jQuery object, or DOM element specifying the structure to wrap around the content of the matched elements.
+     */
+    wrapInner(wrappingElement: string): JQuery;
+    /**
+     * Wrap an HTML structure around the content of each element in the set of matched elements.
+     * 
+     * @param func A callback function which generates a structure to wrap around the content of the matched elements. Receives the index position of the element in the set as an argument. Within the function, this refers to the current element in the set.
+     */
+    wrapInner(func: (index: number) => any): JQuery;
 
     /**
      * Iterate over a jQuery object, executing a function for each matched element.
@@ -3186,25 +3194,84 @@ interface JQuery {
      */
     each(func: (index: number, elem: Element) => any): JQuery;
 
-    get(index?: number): any;
+    /**
+     * Retrieve one of the elements matched by the jQuery object.
+     * 
+     * @param index A zero-based integer indicating which element to retrieve.
+     */
+    get(index: number): HTMLElement;
+    /**
+     * Retrieve the elements matched by the jQuery object.
+     */
+    get(): any[];
 
+    /**
+     * Search for a given element from among the matched elements.
+     */
     index(): number;
+    /**
+     * Search for a given element from among the matched elements.
+     * 
+     * @param selector A selector representing a jQuery collection in which to look for an element.
+     */
     index(selector: string): number;
-    index(element: any): number;
+    /**
+     * Search for a given element from among the matched elements.
+     * 
+     * @param element The DOM element or first element within the jQuery object to look for.
+     */
+    index(element: JQuery): number;
+    /**
+     * Search for a given element from among the matched elements.
+     * 
+     * @param element The DOM element or first element within the jQuery object to look for.
+     */
+    index(element: Element): number;
 
-    // Properties
+    /**
+     * The number of elements in the jQuery object.
+     */
     length: number;
+    /**
+     * A selector representing selector passed to jQuery(), if any, when creating the original set.
+     * version deprecated: 1.7, removed: 1.9
+     */
     selector: string;
-    [x: string]: any;
-    [x: number]: HTMLElement;
+    [index: string]: any;
+    [index: number]: HTMLElement;
 
-    // Traversing
-    add(selector: string, context?: any): JQuery;
-    add(...elements: any[]): JQuery;
+    /**
+     * Add elements to the set of matched elements.
+     * 
+     * @param selector A string representing a selector expression to find additional elements to add to the set of matched elements.
+     * @param context The point in the document at which the selector should begin matching; similar to the context argument of the $(selector, context) method.
+     */
+    add(selector: string, context?: Element): JQuery;
+    /**
+     * Add elements to the set of matched elements.
+     * 
+     * @param elements One or more elements to add to the set of matched elements.
+     */
+    add(...elements: Element[]): JQuery;
+    /**
+     * Add elements to the set of matched elements.
+     * 
+     * @param html An HTML fragment to add to the set of matched elements.
+     */
     add(html: string): JQuery;
+    /**
+     * Add elements to the set of matched elements.
+     * 
+     * @param obj An existing jQuery object to add to the set of matched elements.
+     */
     add(obj: JQuery): JQuery;
 
-    children(selector?: any): JQuery;
+    /**
+     * Get the children of each element in the set of matched elements, optionally filtered by a selector.
+     * 
+     * @param selector A string containing a selector expression to match elements against.
+     */
+    children(selector?: string): JQuery;
 
     closest(selector: string): JQuery;
     closest(selector: string, context?: Element): JQuery;
diff --git a/svgjs/svgjs.d.ts b/svgjs/svgjs.d.ts
index 44f32d9b1..b68b89f80 100644
--- a/svgjs/svgjs.d.ts
+++ b/svgjs/svgjs.d.ts
@@ -270,3 +270,11 @@ declare module svgjs {
         f?: number;
     }
 }
+interface JQuery {
+    /**
+     * Retrieve one of the elements matched by the jQuery object.
+     * 
+     * @param index A zero-based integer indicating which element to retrieve.
+     */
+    get(index: number): svgjs.LinkedHTMLElement;
+}

From cfde90d4e7ff96b1f18b16fded5e47c6308c175d Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Fri, 14 Mar 2014 10:51:24 +0000
Subject: [PATCH 091/309] jQuery: tests now cast to svgjs.LinkedHTMLElement

This could be made implicit by extending the JQuery interface with:
get(index: number): svgjs.LinkedHTMLElement;

Looking at the library it didn't seem sensible to create a dependency on
jQuery even though the tests have one.
---
 svgjs/svgjs-tests.ts | 8 ++++----
 svgjs/svgjs.d.ts     | 8 --------
 2 files changed, 4 insertions(+), 12 deletions(-)

diff --git a/svgjs/svgjs-tests.ts b/svgjs/svgjs-tests.ts
index 845702ac4..fce9c3a74 100644
--- a/svgjs/svgjs-tests.ts
+++ b/svgjs/svgjs-tests.ts
@@ -1,5 +1,5 @@
-/// <reference path='svgjs.d.ts' />
 /// <reference path='../jquery/jquery.d.ts' />
+/// <reference path='svgjs.d.ts' />
  
 // create svg drawing paper
 
@@ -46,7 +46,7 @@ function renderSVG(data:string) {
     var container = SVG(div) // this creates an SVG tag inside
     container.svg(data) // this creates an SVG inside the SVG
     var $inner = $(div).find("svg svg")
-    var inner:svgjs.Element = $inner.get(0).instance
+    var inner:svgjs.Element = (<svgjs.LinkedHTMLElement>$inner.get(0)).instance
 
     // Copy in the important attributes
     root.attr('x', inner.attr('x'))
@@ -61,8 +61,8 @@ function renderSVG(data:string) {
     // Activate and Label all child paths
     var index = 0
     el.find("rect, path, circle, ellipse").each(function() {
-        var $path = $(this)
-        var path = $path.get(0).instance
+        var $path: JQuery = $(this)
+        var path = (<svgjs.LinkedHTMLElement>$path.get(0)).instance
         var uniqueId = "path"+index++
         path.attr({"path-id": uniqueId})
     })
diff --git a/svgjs/svgjs.d.ts b/svgjs/svgjs.d.ts
index b68b89f80..44f32d9b1 100644
--- a/svgjs/svgjs.d.ts
+++ b/svgjs/svgjs.d.ts
@@ -270,11 +270,3 @@ declare module svgjs {
         f?: number;
     }
 }
-interface JQuery {
-    /**
-     * Retrieve one of the elements matched by the jQuery object.
-     * 
-     * @param index A zero-based integer indicating which element to retrieve.
-     */
-    get(index: number): svgjs.LinkedHTMLElement;
-}

From 002e1bf169e267b71c643ad8321d6a124c0e23c1 Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Fri, 14 Mar 2014 11:02:11 +0000
Subject: [PATCH 092/309] jQuery: Put back in what I accidentally removed

---
 jquery/jquery-tests.ts | 13 ++++++++++
 jquery/jquery.d.ts     | 56 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+)

diff --git a/jquery/jquery-tests.ts b/jquery/jquery-tests.ts
index 53fbe55c3..ad7a9444c 100644
--- a/jquery/jquery-tests.ts
+++ b/jquery/jquery-tests.ts
@@ -2224,11 +2224,18 @@ function test_index() {
 function test_innerHeight() {
     var p = $("p:first");
     $("p:last").text("innerHeight:" + p.innerHeight());
+
+    p.innerHeight(123);
+    p.innerHeight('123px');
 }
 
 function test_innerWidth() {
     var p = $("p:first");
     $("p:last").text("innerWidth:" + p.innerWidth());
+
+
+    p.innerWidth(123);
+    p.innerWidth('123px');
 }
 
 function test_outerHeight() {
@@ -2236,6 +2243,9 @@ function test_outerHeight() {
     $("p:last").text(
         "outerHeight:" + p.outerHeight() +
         " , outerHeight( true ):" + p.outerHeight(true));
+
+    p.outerHeight(123);
+    p.outerHeight('123px');
 }
 
 function test_outerWidth() {
@@ -2243,6 +2253,9 @@ function test_outerWidth() {
     $("p:last").text(
         "outerWidth:" + p.outerWidth() +
         " , outerWidth( true ):" + p.outerWidth(true));
+
+    p.outerWidth(123);
+    p.outerWidth('123px');
 }
 
 function test_scrollLeft() {
diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 540301746..58a672d42 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -1418,11 +1418,39 @@ interface JQuery {
      */
     innerHeight(): number;
 
+    /**
+     * Sets the inner height on elements in the set of matched elements, including padding but not border.
+     *
+     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
+     */
+    innerHeight(height: number): JQuery;
+
+    /**
+     * Sets the inner height on elements in the set of matched elements, including padding but not border.
+     *
+     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
+     */
+    innerHeight(height: string): JQuery;
+    
     /**
      * Get the current computed width for the first element in the set of matched elements, including padding but not border.
      */
     innerWidth(): number;
 
+    /**
+     * Sets the inner width on elements in the set of matched elements, including padding but not border.
+     *
+     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
+     */
+    innerWidth(width: number): JQuery;
+
+    /**
+     * Sets the inner width on elements in the set of matched elements, including padding but not border.
+     *
+     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
+     */
+    innerWidth(width: string): JQuery;
+    
     /**
      * Get the current coordinates of the first element in the set of matched elements, relative to the document.
      */
@@ -1447,6 +1475,20 @@ interface JQuery {
      */
     outerHeight(includeMargin?: boolean): number;
 
+   /**
+    * Sets the outer height on elements in the set of matched elements, including padding and border.
+    *
+    * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
+    */
+   outerHeight(height: number): JQuery;
+
+    /**
+     * Sets the outer height on elements in the set of matched elements, including padding and border.
+     *
+     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
+     */
+    outerHeight(height: string): JQuery;
+    
     /**
      * Get the current computed width for the first element in the set of matched elements, including padding and border.
      *
@@ -1454,6 +1496,20 @@ interface JQuery {
      */
     outerWidth(includeMargin?: boolean): number;
 
+    /**
+     * Sets the outer width on elements in the set of matched elements, including padding and border.
+     *
+     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
+     */
+    outerWidth(width: number): JQuery;
+
+    /**
+     * Sets the outer width on elements in the set of matched elements, including padding and border.
+     *
+     * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string).
+     */
+    outerWidth(width: string): JQuery;
+
     /**
      * Get the current coordinates of the first element in the set of matched elements, relative to the offset parent.
      */

From bd9d835aa7ffa87bd085d386e207e3c6660ff460 Mon Sep 17 00:00:00 2001
From: unknown <j201.alex@gmail.com>
Date: Fri, 14 Mar 2014 11:13:07 -0400
Subject: [PATCH 093/309] Fix $q.when definition

---
 angularjs/angular-tests.ts | 7 +++++++
 angularjs/angular.d.ts     | 1 +
 2 files changed, 8 insertions(+)

diff --git a/angularjs/angular-tests.ts b/angularjs/angular-tests.ts
index 4ce311698..90f77fd7c 100644
--- a/angularjs/angular-tests.ts
+++ b/angularjs/angular-tests.ts
@@ -94,6 +94,7 @@ module HttpAndRegularPromiseTests {
         person: Person;
         theAnswer: number;
         letters: string[];
+		snack: string;
     }
 
     var someController: Function = ($scope: SomeControllerScope, $http: ng.IHttpService, $q: ng.IQService) => {
@@ -132,6 +133,12 @@ module HttpAndRegularPromiseTests {
         cPromise.then((letters: string[]) => {
             $scope.letters = letters;
         });
+
+		// When $q.when is passed an IPromise<T>, it returns an IPromise<T>
+		var dPromise: ng.IPromise<string> = $q.when($q.when("ALBATROSS!"));
+		dPromise.then((snack: string) => {
+			$scope.snack = snack;
+		});
     }
 
   // Test that we can pass around a type-checked success/error Promise Callback
diff --git a/angularjs/angular.d.ts b/angularjs/angular.d.ts
index b369a271f..b7a258be6 100755
--- a/angularjs/angular.d.ts
+++ b/angularjs/angular.d.ts
@@ -455,6 +455,7 @@ declare module ng {
         all(promises: {[id: string]: IPromise<any>;}): IPromise<{[id: string]: any}>;
         defer<T>(): IDeferred<T>;
         reject(reason?: any): IPromise<void>;
+        when<T>(value: IPromise<T>): IPromise<T>;
         when<T>(value: T): IPromise<T>;
     }
 

From e7396efb0cfe45fa2592d9e74ef8dcca56b177c6 Mon Sep 17 00:00:00 2001
From: unknown <j201.alex@gmail.com>
Date: Fri, 14 Mar 2014 11:19:32 -0400
Subject: [PATCH 094/309] Change my tabs to spaces

---
 angularjs/angular-tests.ts | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/angularjs/angular-tests.ts b/angularjs/angular-tests.ts
index 90f77fd7c..8ab1efc72 100644
--- a/angularjs/angular-tests.ts
+++ b/angularjs/angular-tests.ts
@@ -94,7 +94,7 @@ module HttpAndRegularPromiseTests {
         person: Person;
         theAnswer: number;
         letters: string[];
-		snack: string;
+        snack: string;
     }
 
     var someController: Function = ($scope: SomeControllerScope, $http: ng.IHttpService, $q: ng.IQService) => {
@@ -134,11 +134,11 @@ module HttpAndRegularPromiseTests {
             $scope.letters = letters;
         });
 
-		// When $q.when is passed an IPromise<T>, it returns an IPromise<T>
-		var dPromise: ng.IPromise<string> = $q.when($q.when("ALBATROSS!"));
-		dPromise.then((snack: string) => {
-			$scope.snack = snack;
-		});
+        // When $q.when is passed an IPromise<T>, it returns an IPromise<T>
+        var dPromise: ng.IPromise<string> = $q.when($q.when("ALBATROSS!"));
+        dPromise.then((snack: string) => {
+            $scope.snack = snack;
+        });
     }
 
   // Test that we can pass around a type-checked success/error Promise Callback

From c165d333ebd360d8101240757ec53d2b6d23c7e2 Mon Sep 17 00:00:00 2001
From: Drew Noakes <git@drewnoakes.com>
Date: Wed, 5 Mar 2014 11:10:27 +0000
Subject: [PATCH 095/309] Update "smoothie" declarations with version from
 project itself.

This version is more complete and includes inline JSDoc comments for
most types/functions/properties.
---
 smoothie/smoothie-tests.ts |   6 +-
 smoothie/smoothie.d.ts     | 224 ++++++++++++++++++++++++++++---------
 2 files changed, 174 insertions(+), 56 deletions(-)

diff --git a/smoothie/smoothie-tests.ts b/smoothie/smoothie-tests.ts
index 8fb75de8d..9da8eebf6 100644
--- a/smoothie/smoothie-tests.ts
+++ b/smoothie/smoothie-tests.ts
@@ -1,14 +1,14 @@
 /// <reference path="smoothie.d.ts" />
 
 // Smoothie supports browserify
-import Smoothie = require('smoothie');
+import smoothie = require('smoothie');
 
 var canvas: HTMLCanvasElement = document.createElement('canvas');
 
 document.body.appendChild(canvas);
 
-var series: Smoothie.TimeSeries   = new Smoothie.TimeSeries(),
-	chart: Smoothie.SmoothieChart = new Smoothie.SmoothieChart({
+var series: smoothie.TimeSeries   = new smoothie.TimeSeries(),
+	chart: smoothie.SmoothieChart = new smoothie.SmoothieChart({
     grid : {
         strokeStyle : '#404040'
     },
diff --git a/smoothie/smoothie.d.ts b/smoothie/smoothie.d.ts
index d5ba175e9..6267c6e3e 100644
--- a/smoothie/smoothie.d.ts
+++ b/smoothie/smoothie.d.ts
@@ -1,66 +1,184 @@
-// Type definitions for smoothie
+// Type definitions for Smoothie Charts 1.21
 // Project: https://github.com/joewalnes/smoothie
-// Definitions by: Mike H. Hawley <https://github.com/mikehhawley>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
+// Definitions by: Drew Noakes <https://drewnoakes.com>
+//                 Mike H. Hawley <https://github.com/mikehhawley>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped/smoothie
 
+// NOTE this reference is here to make the DefinitelyTyped `npm test` suite pass and
+//      may be removed if you are using this module declaration in isolation from the
+//      rest of DefinitelyTyped.
 /// <reference path="../node/node.d.ts" />
 
-declare module "smoothie" {
-    export class TimeSeries {
-        constructor(options?: {
-            resetBoundsInterval?: number;
-            resetBounds?: boolean
-        });
-
-        public resetBounds(): void;
-        
-        public append(timestamp: number, value: number, sumRepeatedTimeStampValues?: boolean): void;
-        
-        public dropOldData(oldestValidTime: number, maxDataSetLength: number): void;
+declare module "smoothie"
+{
+    export interface ITimeSeriesOptions
+    {
+        resetBounds?: boolean;
+        resetBoundsInterval?: number;
     }
 
-    export class SmoothieChart {
-        constructor(options?: {
-            millisPerPixel?:   number;
-            maxValueScale?:    number;
-            interpolation?:    string;
-            scaleSmoothing?:   number;
-            maxDataSetLength?: number;
-            
-            grid?: {
-                fillStyle?:        string;
-                strokeStyle?:      string;
-                lineWidth?:        number;
-                sharpLines?:       boolean;
-                millisPerLine?:    number;
-                verticalSections?: number;
-                borderVisible?:    boolean
-            };
-    
-            labels?: {
-                fillStyle?:  string;
-                disabled?:   boolean;
-                fontSize?:   number;
-                fontFamily?: string;
-                precision?:  number
-            };
-        
-            horizontalLines?: number[]
-        });
+    export interface ITimeSeriesPresentationOptions
+    {
+        stokeStyle?: string;
+        fillStyle?: string;
+        lineWidth?: number;
+    }
 
-        public addTimeSeries(timeSeries: TimeSeries, options?: {
-            lineWidth?: number;
-            strokeStyle?: string
-        }): void;
+    export class TimeSeries
+    {
+        /**
+         * Initialises a new <code>TimeSeries</code> with optional data options.
+         *
+         * Options are of the form (defaults shown):
+         *
+         * <pre>
+         * {
+         *   resetBounds: true,        // enables/disables automatic scaling of the y-axis
+         *   resetBoundsInterval: 3000 // the period between scaling calculations, in millis
+         * }
+         * </pre>
+         *
+         * Presentation options for TimeSeries are specified as an argument to <code>SmoothieChart.addTimeSeries</code>.
+         */
+        constructor(options?: ITimeSeriesOptions);
 
-        public removeTimeSeries(timeSeries: TimeSeries): void;
+        /**
+         * Recalculate the min/max values for this <code>TimeSeries</code> object.
+         *
+         * This causes the graph to scale itself in the y-axis.
+         */
+        resetBounds(): void;
 
-        public streamTo(canvas: HTMLCanvasElement, delayMillis: number): void;
+        /**
+         * Adds a new data point to the <code>TimeSeries</code>, preserving chronological order.
+         *
+         * @param timestamp the position, in time, of this data point
+         * @param value the value of this data point
+         * @param sumRepeatedTimeStampValues if <code>timestamp</code> has an exact match in the series, this flag controls
+         * whether it is replaced, or the values summed (defaults to false.)
+         */
+        append(timestamp: number, value: number, sumRepeatedTimeStampValues?: boolean): void;
 
-        public start(): void;
-        public stop():  void;
+        dropOldData(oldestValidTime: number, maxDataSetLength: number): void;
+    }
 
-        public updateValueRange(): void;
-        public render(canvas?: HTMLCanvasElement, time?: number): void;
+    export interface IGridOptions
+    {
+        /** The background colour of the chart. */
+        fillStyle?: string;
+        /** The pixel width of grid lines. */
+        lineWidth?: number;
+        /** Colour of grid lines. */
+        stokeStyle?: string;
+        /** Distance between vertical grid lines. */
+        millisPerLine?: number;
+        /** Controls whether grid lines are 1px sharp, or softened. */
+        sharpLines?: boolean;
+        /** Number of vertical sections marked out by horizontal grid lines. */
+        verticalSections?: number;
+        /** Whether the grid lines trace the border of the chart or not. */
+        borderVisible?: boolean;
+    }
+
+    export interface ILabelOptions
+    {
+        /** Enables/disables labels showing the min/max values. */
+        disabled?: boolean;
+        /** Colour for text of labels. */
+        fillStyle?: string;
+        fontSize?: number;
+        fontFamily?: string;
+        precision?: number;
+    }
+
+    export interface IRange { min: number; max: number }
+
+    export interface IHorizontalLine
+    {
+        value?: number;
+        color?: string;
+        lineWidth?: number;
+    }
+
+    export interface IChartOptions
+    {
+        /** Specify to clamp the lower y-axis to a given value. */
+        minValue?: number;
+        /** Specify to clamp the upper y-axis to a given value. */
+        maxValue?: number;
+        /** Allows proportional padding to be added above the chart. for 10% padding, specify 1.1. */
+        maxValueScale?: number;
+        yRangeFunction?: (range:IRange)=>IRange;
+        /** Controls the rate at which y-value zoom animation occurs. */
+        scaleSmoothing?: number;
+        /** Sets the speed at which the chart pans by. */
+        millisPerPixel?: number;
+        maxDataSetLength?: number;
+        /** One of: 'bezier', 'linear', 'step' */
+        interpolation?: string;
+        /** Optional function to format time stamps for bottom of chart. You may use <code>SmoothieChart.timeFormatter</code>, or your own/ */
+        timestampFormatter?: (date:Date)=>string;
+        horizontalLines?: IHorizontalLine[];
+
+        grid?: IGridOptions;
+
+        labels?: ILabelOptions;
+    }
+
+    /**
+     * Initialises a new <code>SmoothieChart</code>.
+     *
+     * Options are optional and may be sparsely populated. Just specify the values you
+     * need and the rest will be given sensible defaults.
+     */
+    export class SmoothieChart
+    {
+        constructor(chartOptions?: IChartOptions);
+
+        /**
+         * Adds a <code>TimeSeries</code> to this chart, with optional presentation options.
+         */
+        addTimeSeries(series: TimeSeries, seriesOptions?: ITimeSeriesPresentationOptions): void;
+
+        /**
+         * Removes the specified <code>TimeSeries</code> from the chart.
+         */
+        removeTimeSeries(series: TimeSeries): void;
+
+        /**
+         * Gets render options for the specified <code>TimeSeries</code>.
+         *
+         * As you may use a single <code>TimeSeries</code> in multiple charts with different formatting in each usage,
+         * these settings are stored in the chart.
+         */
+        getTimeSeriesOptions(timeSeries: TimeSeries): ITimeSeriesPresentationOptions;
+
+        /**
+         * Brings the specified <code>TimeSeries</code> to the top of the chart. It will be rendered last.
+         */
+        bringToFront(timeSeries: TimeSeries): void;
+
+        /**
+         * Instructs the <code>SmoothieChart</code> to start rendering to the provided canvas, with specified delay.
+         *
+         * @param canvas the target canvas element
+         * @param delayMillis an amount of time to wait before a data point is shown. This can prevent the end of the series
+         * from appearing on screen, with new values flashing into view, at the expense of some latency.
+         */
+        streamTo(canvas: HTMLCanvasElement, delayMillis: number): void;
+
+        /**
+         * Starts the animation of this chart. Called by <code>streamTo</code>.
+         */
+        start(): void;
+
+        /**
+         * Stops the animation of this chart.
+         */
+        stop(): void;
+
+        updateValueRange(): void;
+
+        render(canvas?: HTMLCanvasElement, time?: number): void;
     }
 }

From ffc5d0f897c741b5b1e68b5a7abed118e76e5b81 Mon Sep 17 00:00:00 2001
From: Drew Noakes <git@drewnoakes.com>
Date: Wed, 5 Mar 2014 11:16:17 +0000
Subject: [PATCH 096/309] Update README with additional author.

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index ba380d9c9..9bd82091d 100755
--- a/README.md
+++ b/README.md
@@ -242,7 +242,7 @@ List of Definitions
 * [simple-cw-node](https://github.com/astronaughts/simple-cw-node) (by [vvakame](https://github.com/vvakame))
 * [Sinon](http://sinonjs.org/) (by [William Sears](https://github.com/mrbigdog2u))
 * [SlickGrid](https://github.com/mleibman/SlickGrid) (by [Josh Baldwin](https://github.com/jbaldwin))
-* [smoothie](https://github.com/joewalnes/smoothie) (by [Mike H. Hawley](https://github.com/mikehhawley))
+* [smoothie](https://github.com/joewalnes/smoothie) (by [Mike H. Hawley](https://github.com/mikehhawley) and [Drew Noakes](https://drewnoakes.com))
 * [socket.io](http://socket.io) (by [William Orr](https://github.com/worr))
 * [socket.io-client](http://socket.io) (by [Maido Kaara](https://github.com/v3rm0n))
 * [SockJS](https://github.com/sockjs/sockjs-client) (by [Emil Ivanov](https://github.com/vladev))

From 436d2369951a133ea9563a1cf1fcb2980a6a76dd Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Fri, 14 Mar 2014 17:20:17 +0000
Subject: [PATCH 097/309] jQuery: closest

---
 jquery/jquery.d.ts | 26 ++++++++++++++++++++++++--
 1 file changed, 24 insertions(+), 2 deletions(-)

diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 58a672d42..92e95b308 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -3329,10 +3329,32 @@ interface JQuery {
      */
     children(selector?: string): JQuery;
 
-    closest(selector: string): JQuery;
+    /**
+     * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
+     * 
+     * @param selector A string containing a selector expression to match elements against.
+     * @param context A DOM element within which a matching element may be found. If no context is passed in then the context of the jQuery set will be used instead.
+     */
     closest(selector: string, context?: Element): JQuery;
+    /**
+     * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
+     * 
+     * @param obj A jQuery object to match elements against.
+     */
     closest(obj: JQuery): JQuery;
-    closest(element: any): JQuery;
+    /**
+     * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
+     * 
+     * @param element An element to match elements against.
+     */
+    closest(element: Element): JQuery;
+
+    /**
+     * Get an array of all the elements and selectors matched against the current element up through the DOM tree.
+     * 
+     * @param selectors An array or string containing a selector expression to match elements against (can also be a jQuery object).
+     * @param context A DOM element within which a matching element may be found. If no context is passed in then the context of the jQuery set will be used instead.
+     */
     closest(selectors: any, context?: Element): any[];
 
     contents(): JQuery;

From 3fd61644e2eb480eb56181bd685e37c2a20719dc Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Fri, 14 Mar 2014 17:26:43 +0000
Subject: [PATCH 098/309] jQuery: added overload

---
 jquery/jquery.d.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 92e95b308..93cb0b999 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -3329,6 +3329,12 @@ interface JQuery {
      */
     children(selector?: string): JQuery;
 
+    /**
+     * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
+     * 
+     * @param selector A string containing a selector expression to match elements against.
+     */
+    closest(selector: string): JQuery;
     /**
      * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
      * 

From c2b80d5ccb264fde54ec284bc0edd32078401aec Mon Sep 17 00:00:00 2001
From: Artur Soler <artur.soler@gmail.com>
Date: Fri, 14 Mar 2014 18:41:59 +0100
Subject: [PATCH 099/309] Add ddescribe and iit function definitions.

---
 jasmine/jasmine.d.ts | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/jasmine/jasmine.d.ts b/jasmine/jasmine.d.ts
index 4c01b347b..c86d8d4e5 100644
--- a/jasmine/jasmine.d.ts
+++ b/jasmine/jasmine.d.ts
@@ -5,10 +5,13 @@
 
 
 declare function describe(description: string, specDefinitions: () => void): void;
+declare function ddescribe(description: string, specDefinitions: () => void): void;
 declare function xdescribe(description: string, specDefinitions: () => void): void;
 
 declare function it(expectation: string, assertion?: () => void): void;
 declare function it(expectation: string, assertion?: (done: () => void) => void): void;
+declare function iit(expectation: string, assertion?: () => void): void;
+declare function iit(expectation: string, assertion?: (done: () => void) => void): void;
 declare function xit(expectation: string, assertion?: () => void): void;
 declare function xit(expectation: string, assertion?: (done: () => void) => void): void;
 
@@ -95,11 +98,13 @@ declare module jasmine {
         addReporter(reporter: Reporter): void;
         execute(): void;
         describe(description: string, specDefinitions: () => void): Suite;
+        ddescribe(description: string, specDefinitions: () => void): Suite;
         beforeEach(beforeEachFunction: () => void): void;
         currentRunner(): Runner;
         afterEach(afterEachFunction: () => void): void;
         xdescribe(desc: string, specDefinitions: () => void): XSuite;
         it(description: string, func: () => void): Spec;
+        iit(description: string, func: () => void): Spec;
         xit(desc: string, func: () => void): XSpec;
         compareRegExps_(a: RegExp, b: RegExp, mismatchKeys: string[], mismatchValues: string[]): boolean;
         compareObjects_(a: any, b: any, mismatchKeys: string[], mismatchValues: string[]): boolean;

From 814f95190ab6b65e50046f2b2528967ac4d5a5c3 Mon Sep 17 00:00:00 2001
From: Artur Soler <artur.soler@gmail.com>
Date: Fri, 14 Mar 2014 18:43:04 +0100
Subject: [PATCH 100/309] callFake can receive a function that takes
 parameters.

---
 jasmine/jasmine.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/jasmine/jasmine.d.ts b/jasmine/jasmine.d.ts
index c86d8d4e5..2abc82ceb 100644
--- a/jasmine/jasmine.d.ts
+++ b/jasmine/jasmine.d.ts
@@ -367,7 +367,7 @@ declare module jasmine {
         /** By chaining the spy with and.returnValue, all calls to the function will return a specific value. */
         returnValue(val: any): void;
         /** By chaining the spy with and.callFake, all calls to the spy will delegate to the supplied function. */
-        callFake(fn: () => any): void;
+        callFake(fn: Function): void;
         /** By chaining the spy with and.throwError, all calls to the spy will throw the specified value. */
         throwError(msg: string): void;
         /** When a calling strategy is used for a spy, the original stubbing behavior can be returned at any time with and.stub. */

From 099d4dc09f10a01a274a7eed424b11efc4f98eee Mon Sep 17 00:00:00 2001
From: ondrejsevcik <ondrej.sev@gmail.com>
Date: Fri, 14 Mar 2014 18:44:17 +0100
Subject: [PATCH 101/309] Added CKEditor definitions

---
 README.md                  |   1 +
 ckeditor/ckeditor-tests.ts | 254 ++++++++++
 ckeditor/ckeditor.d.ts     | 954 +++++++++++++++++++++++++++++++++++++
 3 files changed, 1209 insertions(+)
 create mode 100644 ckeditor/ckeditor-tests.ts
 create mode 100644 ckeditor/ckeditor.d.ts

diff --git a/README.md b/README.md
index ba380d9c9..a3629d424 100755
--- a/README.md
+++ b/README.md
@@ -283,6 +283,7 @@ List of Definitions
 * [Zepto.js](http://zeptojs.com/) (by [Josh Baldwin](https://github.com/jbaldwin))
 * [Zynga Scroller](https://github.com/zynga/scroller) (by [Boris Yankov](https://github.com/borisyankov))
 * [ZeroClipboard](https://github.com/jonrohan/ZeroClipboard) (by [Eric J. Smith](https://github.com/ejsmith))
+* [CKEditor](https://github.com/ckeditor/ckeditor-dev) (by [Ondrej Sevcik](https://github.com/ondrejsevcik))
 
 Requested Definitions
 ---------------------
diff --git a/ckeditor/ckeditor-tests.ts b/ckeditor/ckeditor-tests.ts
new file mode 100644
index 000000000..976b85717
--- /dev/null
+++ b/ckeditor/ckeditor-tests.ts
@@ -0,0 +1,254 @@
+/// <reference path="ckeditor.d.ts" />
+
+function test_CKEDITOR() {
+    CKEDITOR.basePath = 'test';
+    CKEDITOR.replaceClass = 'rich_editor';
+    CKEDITOR.skinName = 'moono';
+    CKEDITOR.skinName = 'myskin,/customstuff/myskin/';
+    var editor = new CKEDITOR.editor();
+    if (editor.getSelection().getType() == CKEDITOR.SELECTION_ELEMENT)
+        if (editor.getSelection().getType() == CKEDITOR.SELECTION_NONE)
+            if (editor.getSelection().getType() == CKEDITOR.SELECTION_TEXT)
+                alert(CKEDITOR.basePath);
+    if (CKEDITOR.currentInstance)
+        alert(CKEDITOR.currentInstance.name);
+    alert(CKEDITOR.document.getBody().getName());
+    alert(CKEDITOR.instances[0].name);
+    CKEDITOR.loadFullCoreTimeout = 5;
+    alert(CKEDITOR.revision);
+    alert(CKEDITOR.rnd);
+    if (CKEDITOR.status == 'loaded') {
+        CKEDITOR.loadFullCore();
+    }
+    alert(CKEDITOR.timestamp);
+    CKEDITOR.addCss('.cke_editable h1,.cke_editable h2,.cke_editable h3 { border-bottom: 1px dotted red }');
+    CKEDITOR.appendTo('editorSpace');
+    alert(CKEDITOR.getUrl('skins/default/editor.css'));
+    alert(CKEDITOR.getUrl('/skins/default/editor.css'));
+    alert(CKEDITOR.getUrl('http://www.somesite.com/skins/default/editor.css'));
+    CKEDITOR.inline('content');
+    if (CKEDITOR.loadFullCore)
+        CKEDITOR.loadFullCore();
+    CKEDITOR.replace('myfield');
+    var textarea = document.createElement('textarea');
+    CKEDITOR.replace(textarea);
+    CKEDITOR.replaceAll();
+    CKEDITOR.replaceAll('myClassName');
+    CKEDITOR.replaceAll((textarea, config) => false);
+}
+
+function test_dom_comment() {
+    var type = CKEDITOR.NODE_COMMENT;
+    var nativeNode = document.createComment('Example');
+    var comment = new CKEDITOR.dom.comment(nativeNode);
+    var comment2 = new CKEDITOR.dom.comment('Example');
+}
+
+function test_dom_document() {
+    var document = new CKEDITOR.dom.document(window.document);
+    var type = CKEDITOR.NODE_DOCUMENT;
+    CKEDITOR.document.appendStyleSheet('/mystyles.css');
+    var element = CKEDITOR.document.getBody();
+    alert(element.getName());
+    var element2 = CKEDITOR.document.getById('myElement');
+    alert(element.getId());
+    var element3 = CKEDITOR.document.getHead();
+    alert(element.getName());
+    var selection = CKEDITOR.instances[0].document.getSelection();
+    alert(selection.getType());
+    document.write(
+        '<html>' +
+        '<head><title>Sample Doc</title></head>' +
+        '<body>Document contents created by code</body>' +
+        '</html>'
+        );
+}
+
+function test_dom_documentFragment() {
+    var type = CKEDITOR.NODE_DOCUMENT_FRAGMENT;
+}
+
+function test_dom_domObject() {
+    var element = new CKEDITOR.dom.element('span');
+    alert(element.$.nodeType);
+    var nativeElement = element.$;
+    var doc = new CKEDITOR.dom.document(document);
+    alert(doc.equals(CKEDITOR.document));
+    alert(doc == CKEDITOR.document);
+    var element2 = new CKEDITOR.dom.element('span');
+    alert(element.getCustomData('hasCustomData'));
+    alert(element.getCustomData('nonExistingKey'));
+    var elementA = new CKEDITOR.dom.element(nativeElement);
+    elementA.getPrivate().value = 1;
+    var elementB = new CKEDITOR.dom.element(nativeElement).getPrivate().value;
+    var element3 = new CKEDITOR.dom.element('span');
+    element.setCustomData('hasCustomData', true);
+}
+
+function test_dom_element() {
+    var element = new CKEDITOR.dom.element('span');
+    alert(element.$.nodeType);
+    element.addClass('classA');
+    element.addClass('classB');
+    element.addClass('classA');
+    var p = new CKEDITOR.dom.element('p');
+    var strong = new CKEDITOR.dom.element('strong');
+    p.append(strong);
+    var em = p.append('em');
+    var p = new CKEDITOR.dom.element('p');
+    p.appendText('This is');
+    p.appendText(' some text');
+    element.breakParent(strong);
+    element.data('extra-info', 'test');
+    alert(element.data('extra-info'));
+    element.data('extra-info', false);
+    var element5 = CKEDITOR.document.getById('myTextarea');
+    element.focus();
+    element.focusNext();
+    element.focusPrevious();
+    element.forEach(node=> {
+        console.log(node);
+    });
+    var element2 = CKEDITOR.dom.element.createFromHtml('<input type="text" />');
+    alert(element.getAttribute('type'));
+    alert(element.getComputedStyle('display'));
+    element.appendTo(CKEDITOR.document.getBody());
+    alert(element.getEditor().name);
+    var first = element.getFirst();
+    alert(element.getHtml());
+    alert(element.getId());
+    alert(element.getName());
+    alert('<b>' + element.getNameAtt() + '</b>');
+    alert(element.getOuterHtml());
+    alert(element.getTabIndex());
+    alert(element.getText());
+    alert(element.hasAttributes());
+    alert(element.hasAttributes());
+    element.hide();
+    alert(element.is('span'));
+    alert(element.is('p', 'span'));
+    alert(element.is('p'));
+    alert(element.is('p', 'div'));
+    alert(element.is({ p: 1, span: 1 }));
+    element.removeAttribute('class');
+    element.addClass('classA');
+    element.addClass('classB');
+    element.removeClass('classA');
+    element.removeClass('classB');
+    element.removeStyle('display');
+    element.setAttribute('class', 'myClass');
+    element.setAttribute('title', 'This is an example');
+    element.setAttributes({
+        'class': 'myClass',
+        title: 'This is an example'
+    });
+    p.setHtml('<b>Inner</b> HTML');
+    element.setOpacity(0.75);
+    element.setStyle('background-color', '#ff0000');
+    element.setStyle('margin-top', '10px');
+    element.setStyle('float', 'right');
+    element.setStyles({
+        position: 'absolute',
+        float: 'right'
+    });
+    element.setText('A > B & C < D');
+    element.show();
+    element.unselectable();
+    alert(element.getName());
+    alert(element == CKEDITOR.dom.element.get(element));
+    var htmlElement = document.getElementById('myElement');
+    alert(CKEDITOR.dom.element.get(htmlElement).getName());
+}
+
+function test_dom_event() {
+    var event = new CKEDITOR.dom.event(new Event());
+    alert(event.getKey());
+    alert(event.getKeystroke() == 65);
+    alert(event.getKeystroke() == CKEDITOR.CTRL + 65);
+    alert(event.getKeystroke() == CKEDITOR.CTRL + CKEDITOR.SHIFT + 65);
+    var element = new CKEDITOR.dom.element('div');
+    element.on('mousemouse', ev=> {
+        var pageOffset = ev.data.getPageOffset();
+        alert(pageOffset.x);
+        alert(pageOffset.y);
+    });
+    element.on('click', ev=> {
+        var domEvent = ev.data;
+        domEvent.getTarget().addClass('clicked');
+    });
+    element.on('click', ev=> {
+        var domEvent = ev.data;
+        domEvent.preventDefault();
+    });
+}
+
+function test_dom_iterator() {
+    var range = new CKEDITOR.dom.range(new CKEDITOR.dom.element('div'));
+    var iterator = range.createIterator();
+    iterator.getNextParagraph();
+    iterator.getNextParagraph();
+}
+
+function test_dom_node() {
+    var p = new CKEDITOR.dom.element('p');
+    var strong = new CKEDITOR.dom.element('strong');
+    strong.appendTo(p);
+    var node = new CKEDITOR.dom.node(new Node());
+    node = node.getAscendant('b');
+    node = node.getAscendant('b', true);
+    var element = CKEDITOR.document.getById('example');
+    alert(element.getDocument().equals(CKEDITOR.document));
+    element.getIndex();
+    element.getIndex(true);
+    var last = element.getFirst().getNext();
+    var parent = node.getParent();
+    alert(parent.getName());
+    var parents = node.getParents();
+    var em = new CKEDITOR.dom.element('em');
+    strong.insertAfter(em);
+    strong.insertBefore(em);
+    strong.insertBeforeMe(em);
+    element.isReadOnly();
+}
+
+function test_dom_nodeList() {
+    var nodeList = CKEDITOR.document.getBody().getChildren();
+    alert(nodeList.count());
+}
+
+function test_dom_range() {
+    var editor = new CKEDITOR.editor();
+    var range = new CKEDITOR.dom.range(editor.document);
+    range.selectNodeContents(editor.document.getBody());
+    range.deleteContents();
+    range.selectNodeContents(editor.document.getBody());
+    alert(range.collapsed);
+    range.collapse();
+    alert(range.collapsed);
+    range.selectNodeContents(range.document.getBody());
+    range.selectNodeContents(editor.document.getBody());
+    alert(range.endContainer.getName());
+    range.selectNodeContents(editor.document.getBody());
+    alert(range.endOffset);
+    range.selectNodeContents(editor.document.getBody());
+    alert(range.startContainer.getName());
+    range.selectNodeContents(editor.document.getBody());
+    alert(range.startOffset);
+}
+
+function test_dom_text() {
+    var nativeNode = document.createTextNode('Example');
+    var text = new CKEDITOR.dom.text(nativeNode);
+    var text2 = new CKEDITOR.dom.text('Example');
+}
+
+function test_dom_window() {
+    var document = new CKEDITOR.dom.window(window);
+    var win = new CKEDITOR.dom.window(window);
+    var pos = win.getScrollPosition();
+    alert(pos.x);
+    alert(pos.y);
+    var size = win.getViewPaneSize();
+    alert(size.width);
+    alert(size.height);
+}
\ No newline at end of file
diff --git a/ckeditor/ckeditor.d.ts b/ckeditor/ckeditor.d.ts
new file mode 100644
index 000000000..ba81a6a1b
--- /dev/null
+++ b/ckeditor/ckeditor.d.ts
@@ -0,0 +1,954 @@
+// Type definitions for CKEditor
+// Project: http://ckeditor.com/
+// Definitions by: Ondrej Sevcik <https://github.com/ondrejsevcik/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// WORK-IN-PROGRESS: Any contribution support welcomed.
+// See https://github.com/borisyankov/DefinitelyTyped/issues/1827 for more informations.
+declare module CKEDITOR {
+
+    // Config options
+    var disableAutoInline: boolean;
+    var replaceClass: string;
+    var skinName: string;
+
+    // Properties
+    var ALT: number;
+    var CTRL: number;
+    var DIALOG_RESIZE_BOTH: number;
+    var DIALOG_RESIZE_HEIGHT: number;
+    var DIALOG_RESIZE_NONE: number;
+    var DIALOG_RESIZE_WIDTH: number;
+    var ELEMENT_MODE_APPENDTO: number;
+    var ELEMENT_MODE_INLINE: number;
+    var ELEMENT_MODE_NONE: number;
+    var ELEMENT_MODE_REPLACE: number;
+    var END: number;
+    var ENTER_BR: number;
+    var ENTER_P: number;
+    var EVENT_PHASE_AT_TARGET: number;
+    var EVENT_PHASE_BUBBLING: number;
+    var EVENT_PHASE_CAPTURING: number;
+    var LINEUTILS_AFTER: number;
+    var LINEUTILS_BEFORE: number;
+    var LINEUTIS_INSIDE: number;
+    var NODE_COMMENT: number;
+    var NODE_DOCUMENT: number;
+    var NODE_DOCUMENT_FRAGMENT: number;
+    var NODE_ELEMENT: number;
+    var NODE_TEXT: number;
+    var SELECTION_ELEMENT: number;
+    var SELECTION_NONE: number;
+    var SELECTION_TEXT: number;
+    var SHIFT: number;
+    var SHRINK_ELEMENT: number;
+    var SHRINK_TEXT: number;
+    var START: number;
+    var TRISTATE_DISABLED: number;
+    var TRISTATE_OFF: number;
+    var TRISTATE_ON: number;
+    var UI_BUTTON: string;
+    var UI_MENUBUTTON: string;
+    var UI_PANEL: string;
+    var UI_PANELBUTTON: string;
+    var UI_RICHCOMBO: string;
+    var UI_SEPARATOR: string;
+    var basePath: string;
+    var currentInstance: editor;
+    var document: dom.document;
+    var instances: editor[];
+    var loadFullCoreTimeout: number;
+    var revision: string;
+    var rnd: number;
+    var status: string;
+    var timestamp: string;
+    var version: string;
+
+
+    // Methods
+    function add(editor: editor): void;
+    function addCss(css: string): void;
+    function addTemplate(name: string, source: string): template;
+    function appendTo(element: string, config?: config, data?: string): editor;
+    function appendTo(element: HTMLTextAreaElement, config?: config, data?: string): editor;
+    function domReady(): void;
+    function editorConfig(config: config): void;
+    function getCss(): string;
+    function getTemplate(name: string): template;
+    function getUrl(resource: string): string;
+    function inline(element: string, instanceConfig?: config): editor;
+    function inline(element: HTMLTextAreaElement, instanceConfig?: config): editor;
+    function inlineAll(): void;
+    function loadFullCore(): void;
+    function replace(element: string, config?: config): editor;
+    function replace(element: HTMLTextAreaElement, config?: config): editor;
+    function replaceAll(className?: string): void;
+    function replaceAll(assertionFunction: (textarea: HTMLTextAreaElement, config: config) => boolean): void;
+
+
+    module dom {
+
+        class comment {
+
+            // Properties
+            type: number;
+
+            // Methods
+            constructor(comment: string, ownerDocument?: document);
+            constructor(comment: Object, ownerDocument?: document);
+            getOuterHtml(): string;
+
+        }
+
+
+        class document extends domObject {
+
+            // Properties
+            type: number;
+
+            // Methods
+            constructor(domDocument: Object);
+            appendStyleSheet(cssFileUrl: string): void;
+            appendStyleText(cssStyleText: string): Object;
+            createElement(name: string, attribsAndStyles?: { attributes: Object; styles: Object; }): element;
+            createText(text: string): element;
+            find(selector: string): nodeList;
+            findOne(selector: string): element;
+            focus(): void;
+            getActive(): element;
+            getBody(): element;
+            getByAddress(address: any[], normalized?: boolean): node;
+            getById(elementId: string): element;
+            getDocumentElement(): element;
+            getElementsByTag(tagName: string): nodeList;
+            getHead(): element;
+            getSelection(): selection;
+            getWindow(): window;
+            write(html: string): void;
+
+        }
+
+
+        class documentFragment {
+
+            // Properties
+            type: number;
+
+            // Methods
+            constructor(nodeOrDoc: Object);
+            insertAfterNode(node: node): void;
+
+        }
+
+
+        class domObject extends event {
+
+            // Properties
+            $: HTMLElement;
+
+            // Methods
+            constructor(nativeDomObject: Object);
+            clearCustomData(): void;
+            equals(object: any): boolean;
+            getCustomData(key: string): any;
+            getPrivate(): any;
+            getUniqueId(): number;
+            removeAllListeners(): void;
+            removeCustomData(key: string): Object;
+            setCustomData(key: string, value: Object): domObject;
+
+        }
+
+
+        class element extends node {
+
+            // Properties
+            type: number;
+
+            // Methods            
+            constructor(element: string, ownerDocument?: document);
+            constructor(element: HTMLElement, ownerDocument?: document);
+            addClass(className: string): void;
+            append(node: node, toStart?: boolean): node;
+            append(node: string, toStart?: boolean): node;
+            appendBogus(force: boolean): void;
+            appendHtml(html: string): void;
+            appendText(text: string): node;
+            breakParent(parent: element): void;
+            contains(node: node): boolean;
+            copyAttributes(dest: element, skipAttributes: Object): void;
+            data(name: string): string;
+            data(name: string, value: string): void;
+            data(name: string, value: boolean): void;
+            disableContextMenu(): void;
+            find(selector: string): nodeList;
+            findOne(selector: string): element;
+            focus(defer?: boolean): void;
+            focusNext(ignoreChildren?: boolean, indexToUse?: number): void;
+            focusPrevious(ignoreChildren?: boolean, indexToUse?: number): void;
+            forEach(callback: (node: node) => void, type?: number, skipRoot?: boolean): void;
+            getAttribute(name: string): string;
+            getBogus(): Object;
+            getChild(indices: number): node;
+            getChild(indices: number[]): node;
+            getChildCount(): number;
+            getChildren(): nodeList;
+            getClientRect(): any;
+            getComputedStyle(propertyName: string): string;
+            getDirection(useComputed: boolean): string;
+            getDocumentPosition(refDocument: document): position;
+            getDtd(): any;
+            getEditor(): editor;
+            getElementsByTag(tagName: string): nodeList;
+            getFirst(evaluator?: Function): node;
+            getFrameDocument(): document;
+            getHtml(): string;
+            getId(): string;
+            getLast(evaluator?: Function): node;
+            getName(): string;
+            getNameAtt(): string;
+            getOuterHtml(): string;
+            getPositionedAncestor(): element;
+            getSize(type: string, isBorderBox: boolean): void;
+            getStyle(name: string): string;
+            getTabIndex(): number;
+            getText(): string;
+            getValue(): string;
+            getWindow(): window;
+            hasAttributes(): boolean;
+            hasAttribute(name: string): boolean;
+            hasClass(className: string): boolean;
+            hide(): void;
+            is(...name: string[]): boolean;
+            is(name: any): boolean;
+            isBlockBoundary(customNodeNames: Object): boolean;
+            isEditable(textCursor?: boolean): boolean;
+            isEmptyInlineRemoveable(): boolean;
+            isIdentical(otherElement: element): boolean;
+            isVisible(): boolean;
+            mergeSiblings(inlineOnly?: boolean): void;
+            moveChildren(target: element, toStart?: boolean): void;
+            removeAttribute(name: string): void;
+            removeAttributes(attributes?: string[]): void;
+            removeClass(className: string): void;
+            removeStyle(name: string): void;
+            renameNode(newTag: string): void;
+            scrollIntoParent(parent: element, alignToTop: boolean, hscroll: boolean): void;
+            scrollIntoParent(parent: window, alignToTop: boolean, hscroll: boolean): void;
+            scrollIntoView(alignToTop?: boolean): void;
+            setAttribute(name: string, value: string): element;
+            setAttributes(attributesPairs: Object): element;
+            setHtml(html: string): string;
+            setOpacity(opacity: number): void;
+            setSize(type: string, size: number, isBorderBox: boolean): void;
+            setState(state: number, base?: Object, useAria?: Object): void;
+            setStyle(name: string, value: string): element;
+            setStyles(stylesPair: Object): element;
+            setText(text: string): string;
+            setValue(value: string): element;
+            show(): void;
+            unselectable(): void;
+
+            //static method
+            static clearAllMarkers(database: Object): Object;
+            static clearMarkers(database: Object, element: Object, removeFromDatabase: Object): void;
+            static createFromHtml(html: string): element;
+            static get(element: string): element;
+            static get(element: any): element;
+            static setMarker(database: Object, element: Object, name: Object, value: Object): domObject;
+
+        }
+
+
+        class elementPath {
+            constructor(startNode: element, root: element);
+            block: element;
+            blockLimit: element;
+            root: element;
+            elements: element[];
+            compare(otherPath: elementPath): boolean;
+            contains(query: string, excludeRoot: boolean, fromTop: boolean): element;
+            contains(query: string[], excludeRoot: boolean, fromTop: boolean): element;
+            contains(query: (element: element) => boolean, excludeRoot: boolean, fromTop: boolean): element;
+            contains(query: Object, excludeRoot: boolean, fromTop: boolean): element;
+            contains(query: element, excludeRoot: boolean, fromTop: boolean): element;
+            isContextFor(tag: string): boolean;
+            direction(): string;
+        }
+
+
+        class range {
+            constructor(root: element);
+            constructor(root: document);
+            startContainer: any;
+            startOffset: number;
+            endContainer: any;
+            endOffset: number;
+            collapsed: boolean;
+            isDocRoot: boolean;
+            document: document;
+            root: element;
+            clone(): range;
+            collapse(toStart?: boolean): Boolean;
+            cloneContents(): documentFragment;
+            deleteContents(mergeThen?: boolean): void;
+            extractContents(mergeThen?: boolean): documentFragment;
+            createBookmark(serializable: boolean): Object;
+            createBookmark2(normalized: boolean): Object;
+            createIterator(): iterator;
+            moveToBookmark(bookmark: Object): void;
+            getBoundaryNodes(): { startNode: node; endNode: node; };
+            getCommonAncestor(includeSelf: boolean, ignoreTextNode: boolean): element;
+            optimize(): void;
+            optimizeBookmark(): void;
+            trim(ignoreStart?: boolean, ignoreEnd?: boolean): void;
+            enlarge(unit: number, excludeBrs?: boolean): void;
+            shrink(mode: number, selectContents: boolean): void;
+            insertNode(node: node): void;
+            moveToPosition(node: node, position: Object): void;
+            moveToRange(range: range): void;
+            selectNodeContents(node: node): void;
+            setStart(startNode: node, startOffset: number): void;
+            setEnd(endNode: node, endOffset: number): void;
+            setStartAfter(node: node): void;
+            setStartBefore(node: node): void;
+            setStartAt(node: node, position: number): void;
+            setEndAt(node: node, position: number): void;
+            fixBlock(isStart: boolean, blockTag: Object): Object;
+            splitBlock(blockTag: Object): Object;
+            splitElement(toSplit: element): element;
+            removeEmptyBlocksAtEnd(atEnd: boolean): void;
+            startPath(): elementPath;
+            endPath(): elementPath;
+            checkBoundaryOfElement(element: element, checkType: number): boolean;
+            checkStartOfBlock(): boolean;
+            checkEndOfBlock(): boolean;
+            getPreviousNode(evaluator: Function, guard: Function, boundary: element): element;
+            getNextNode(evaluator: Function, guard: Function, boundary: element): element;
+            checkReadOnly(): boolean;
+            moveToElementEditablePosition(element: element, isMoveToEnd: boolean): boolean;
+            movetoClosestEditablePosition(element: element, isMoveToEnd: boolean): boolean;
+            moveToElementEditStart(target: Object): boolean;
+            moveToElementEditEnd(target: Object): boolean;
+            getEnclosedNode(): node;
+            getTouchedStartNode(): node;
+            getTouchedEndNode(): node;
+            getNextEditableNode(): Object;
+            getPreviousEditableNode(): Object;
+            scrollIntoView(): void;
+        }
+
+
+        interface rangeListIterator {
+
+        }
+
+        class selection {
+            document: document;
+            isFake: boolean;
+            isLocked: boolean;
+            rev: number;
+            root: element;
+            constructor(target: document);
+            constructor(target: element);
+            constructor(target: selection);
+            createBookmarks(serializable: Object): any[];
+            createBookmarks2(normalized?: Object): any[];
+            fake(element: element): void;
+            getCommonAncestor(): element;
+            getNative(): Object;
+            getRanges(onlyEditables?: boolean): any[];
+            getSelectedElement(): element;
+            getSelectedText(): string;
+            getStartElement(): element;
+            getType(): number;
+            isHidden(): boolean;
+            lock(): void;
+            removeAllRanges(): void;
+            reset(): void;
+            scrollIntoView(): void;
+            selectBookmarks(bookmarks: any[]): selection;
+            selectElement(element: element): void;
+            selectRanges(ranges: any[]): void;
+            unlock(restore: Object): void;
+        }
+
+
+        class rangeList {
+            constructor(ranges: range[]);
+            constructor(range: range);
+            createIterator(): rangeListIterator;
+            createBokmark(serializable: boolean): Object[];
+            createBookmark2(normalized: boolean): Object[];
+            moveToBookmark(bookmarks: Object[]): void;
+        }
+
+
+        class iterator {
+            constructor(range: range);
+            getNextParagraph(blockTag?: string): element;
+            activeFilter: filter;
+            enforceRealBlocks: Boolean;
+            enlargeBr: Boolean;
+            filter: filter;
+        }
+
+
+        class node extends domObject {
+            constructor(domNode: Node);
+            appendTo(element: element): element;
+            clone(includeChildren: boolean, cloneId: boolean): node;
+            hasPrevious(): boolean;
+            hasNext(): boolean;
+            insertAfter(node: node): node;
+            insertBefore(node: node): node;
+            insertBeforeMe(node: node): node;
+            getAddress(normalized: boolean): Object[];
+            getDocument(): document;
+            getIndex(normalized?: boolean): number;
+            getNextSourceNode(startFromSibling: Object, nodeType: Object, guard: Object): void;
+            getPreviousSourceNode(startFromSibling: Object, nodeType: Object, guard: Object): void;
+            getPrevious(evaluator?: Function): node;
+            getNext(evaluator?: Function): node;
+            getParent(allowFragmentParent?: boolean): element;
+            getParents(closerFirst?: boolean): node[];
+            getCommonAncestor(node: Object): void;
+            getPosition(otherNode: Object): void;
+            getAscendant(reference: string, includeSelf?: boolean): node;
+            hasAscendant(name: Object, includeSelf: any): boolean;
+            move(preserveChildren?: boolean): node;
+            replace(nodeToReplace: node): void;
+            trim(): void;
+            ltrim(): void;
+            rtrim(): void;
+            isReadOnly(): boolean;
+        }
+
+
+        class nodeList {
+            constructor(nativeList: Object);
+            count(): number;
+            getItem(index: number): node;
+        }
+
+
+        class event {
+            constructor(domEvent: Event);
+            getKey(): number;
+            getKeystroke(): number;
+            preventDefault(stopPropagation: boolean): void;
+            stopPropagation(): void;
+            getTarget(): node;
+            getPhase(): number;
+            getPhaseOffset(): position;
+            on(eventName: string, listenerFunction: Function, scopeObj?: Object, listenerData?: Object, priority?: number): Object;
+        }
+
+
+        interface position {
+            x: number;
+            y: number;
+        }
+
+
+        interface widthAndHeight {
+            width: number;
+            height: number;
+        }
+
+
+        class text extends node {
+            constructor(text: Text, ownerDocument?: document);
+            constructor(text: string, ownerDocument?: document);
+            type: number;
+            getLength(): number;
+            getText(): string;
+            setText(text: string): void;
+            split(offset: number): text;
+            substring(indexA: number, indexB: number): void;
+        }
+
+
+        class window extends domObject {
+            constructor(domWindow: Object);
+            focus(): void;
+            getViewPaneSize(): widthAndHeight;
+            getScrollPosition(): position;
+            getFrame(): element;
+        }
+
+
+        class walker {
+            constructor(range: range);
+            end(): void;
+            next(): node;
+            previous(): node;
+            checkForward(): boolean;
+            checkBackward(): boolean;
+            lastForward(): node;
+            lastBackward(): node;
+            reset(): void;
+            //static methods till the end
+            blockBoundary(customNodeNames: Object): Function;
+            listItemBoundary(): Function;
+            bookmark(contentOnly?: boolean, isReject?: boolean): Function;
+            whitespaces(isReject?: boolean): Function;
+            invisible(isReject?: boolean): Function;
+            nodeType(type: number, isReject?: boolean): Function;
+            bogus(isReject?: boolean): Function;
+            temp(isReject?: boolean): Function;
+            ignored(isReject?: boolean): Function;
+            editable(isReject?: boolean): Function;
+        }
+
+    }
+
+
+    module ajax {
+
+        // Methods
+        function load(url: string, callback?: Function): string;
+        function loadXml(url: string, callback?: Function): xml;
+
+    }
+
+
+    interface xml {
+
+    }
+
+
+    class command extends event {
+
+        // Properties
+        contextSensitive: boolean;
+        editorFocus: boolean;
+        modes: any;
+        previousState: number;
+        state: number;
+        uiItems: any[];
+
+        // Methods
+        constructor(editor: editor, commandDefinition: commandDefinition);
+        checkAllowed(noCache: boolean): boolean;
+        disable(): void;
+        enable(): void;
+        exec(data?: Object): boolean;
+        refresh(editor: editor, path: dom.elementPath): void;
+        setState(newState: number): boolean;
+        toggleState(): void;
+
+    }
+
+
+    interface focusManager {
+
+    }
+
+    interface keystrokeHandler {
+
+    }
+
+
+    interface config {
+        startupMode: string;
+        removeButtons: string;
+        toolbar?: any;
+    }
+
+
+    interface feature {
+
+    }
+
+
+    interface style {
+
+    }
+
+
+    interface editable {
+
+    }
+
+
+    class menu {
+        constructor();
+        add(item: any): void;
+        addListener(listenerFn: (startElement: dom.element, selection: dom.selection, path: dom.elementPath) => any);
+        hide(returnFocus?: boolean): void;
+        removeAll(): void;
+        show(offsetParent: dom.element, corner?: number, offsetX?: number, offsetY?: number): void;
+    }
+
+
+    module plugins {
+
+        class contextMenu extends menu {
+            constructor(editor: editor);
+            addTarget(element: dom.element, nativeContextMenuOnCtrl?: boolean): void;
+            open(offsetParent: dom.element, corner?: number, offsetX?: number, offsetY?: number);
+        }
+
+
+        module link {
+            var emptyAnchorFix: boolean;
+            var fakeAnchor: boolean;
+            var synAnchorSelector: boolean;
+            function getEditorAnchors(editor: editor): dom.element[];
+            function getSelectedLink(editor: editor): dom.elementPath;
+            function tryRestoreFakeAnchor(editor: editor, element: dom.element): dom.element;
+        }
+
+
+        module widget {
+            class repository {
+
+            }
+        }
+
+    }
+
+
+    class editor extends event {
+        activeEnterMode: number;
+        activeFilter: filter;
+        activeShiftEnterMode: number;
+        blockless: boolean;
+        config: config;
+        container: dom.element;
+        contextMenu: plugins.contextMenu;
+        dataProcessor: dataProcessor;
+        document: dom.document;
+        element: dom.element;
+        elementMode: number;
+        enterMode: number;
+        filter: filter;
+        focusManager: focusManager;
+        id: string;
+        keystrokeHandler: keystrokeHandler;
+        lang: any;
+        langCode: string;
+        mode: string;
+        name: string;
+        plugins: Object;
+        readOnly: boolean;
+        shiftEnterMode: number;
+        status: string;
+        tabIndex: number;
+        templates: Object;
+        title: any;
+        toolbar: Object;
+        ui: ui;
+        widgets: plugins.widget.repository;
+        window: dom.window;
+        constructor(instanceConfig?: Object, element?: dom.element, mode?: number);
+        addCommand(commandName: string, commandDefinition: commandDefinition): void;
+        addFeature(feature: feature): boolean;
+        addMenuGroup(name: string, order?: number): void;
+        addMenuItem(name: string, definition?: any): void;
+        addMenuItems(definitions: any[]): void;
+        addMode(mode: string, exec: () => void): void;
+        addRemoveFormatFilter(func: Function): void;
+        applyStyle(style: style): void;
+        attachStyleStateChange(style: style, callback: Function): void;
+        checkDirty(): boolean;
+        createFakeElement(realElement: Object, className: Object, realElementType: Object, isResizable: Object): void;
+        createFakeParserElement(realElement: Object, className: Object, realElementType: Object, isResizable: Object): void;
+        createRange(): dom.range;
+        destroy(noUpdate?: boolean): void;
+        editable(elementOrEditable: dom.element): void;
+        editable(elementOrEditable: editable): void;
+        elementPath(startNode?: dom.node): dom.elementPath;
+        execCommand(commandName: string, data?: Object): boolean;
+        focus(): void;
+        forceNextSelectionCheck(): void;
+        getClipboardData(options: Object, callback: Function): void;
+        getColorFromDialog(callback: Function, scope?: Object): void;
+        getCommand(commandName: string): command;
+        getData(noEvents: Object): string;
+        getMenuItem(name: string): Object;
+        getResizable(forContents: boolean): dom.element;
+        getSelection(forceRealSelection?: boolean): dom.selection;
+        getSnapshot(): string;
+        getStylesSet(callback: Function): void;
+        getUiColor(): string;
+        insertElement(element: dom.element): void;
+        insertHtml(html: string, mode?: string): void;
+        insertText(text: string): void;
+        loadSnapshot(snapshot: Object): void;
+        lockSelection(sel?: dom.selection): boolean;
+        openDialog(dialogName: string, callback: Function): dialog;
+        popup(url: string, width?: number, height?: number, options?: string): void;
+        popup(url: string, width?: string, height?: number, options?: string): void;
+        popup(url: string, width?: number, height?: string, options?: string): void;
+        popup(url: string, width?: string, height?: string, options?: string): void;
+        removeMenuItem(name: string): void;
+        removeStyle(style: style): void;
+        resetDirty(): void;
+        resetUndo(): void;
+        resize(width: number, height: number, isContentHeight?: boolean, resizeInner?: boolean): void;
+        resize(width: string, height: number, isContentHeight?: boolean, resizeInner?: boolean): void;
+        resize(width: number, height: string, isContentHeight?: boolean, resizeInner?: boolean): void;
+        resize(width: string, height: string, isContentHeight?: boolean, resizeInner?: boolean): void;
+        restoreRealElement(fakeElement: Object): dom.element;
+        selectionChange(checkNow?: boolean): void;
+        setActiveEnterMode(enterMode: number, shiftEnterMode: number): void;
+        setActiveFilter(filter: filter): void;
+        setData(data: string, callback: Function, internal: boolean): void;
+        setKeystroke(keystroke: number, behavior?: string): void;
+        setKeystroke(keystroke: any[], behavior?: string): void;
+        setKeystroke(keystroke: number, behavior?: boolean): void;
+        setKeystroke(keystroke: any[], behavior?: boolean): void;
+        setMode(newMode: string, callback: Function): void;
+        setReadOnly(isReadOnly?: boolean): void;
+        setUiColor(color: string): void;
+        unlockSelection(restore?: boolean): void;
+        updateElement(): void;
+    }
+
+
+    interface eventInfo {
+        data: any;
+        editor: editor;
+        listenerData: any;
+        name: string;
+        sender: any;
+        cancel(): void;
+        removeListener(): void;
+        stop(): void;
+    }
+
+
+    class filter {
+
+    }
+
+
+    interface template {
+
+    }
+
+
+    interface dataProcessor {
+        toDataFormat(html: string, fixForBody: string): void;
+        toHtml(data: string, fixForBody?: string): void;
+    }
+
+
+    class event {
+        constructor();
+        useCapture: boolean;
+        capture(): void;
+        define(name: string, meta: Object);
+        fire(eventName: string, data?: Object, editor?: editor): any;
+        fireOnce(eventName: string, data?: Object, editor?: editor): any;
+        hasListeners(eventName: string): boolean;
+        on(eventName: string, listenerFunction: (eventInfo: eventInfo) => void, scopeObj?: Object, listenerData?: Object, priority?: number): void;
+        once(eventName: string, listenerFunction: Function, scopeObj?: Object, listenerData?: Object, priority?: number): void;
+        removeAllListeners(): void;
+        removeListener(eventName: string, listenerFunction: Function): void;
+        static implementOn(targetObject: Object): void;
+    }
+
+
+    interface commandDefinition {
+        async?: boolean;
+        canUndo?: boolean;
+        context?: boolean;
+        contextSensitive?: boolean;
+        editorFocus?: boolean;
+        modes?: Object;
+        startDisabled?: boolean;
+        exec(editor: editor, data?: Object): boolean;
+        refresh? (editor: editor, path: dom.elementPath): void;
+    }
+
+
+    class dtd {
+
+    }
+
+
+    class ui extends event {
+        constructor(editor: editor);
+        add(name: string, type: Object, definition: Object): void;
+        addButton(name: string, definition: dialog.definition.button): void;
+        addHandler(type: Object, handler: Object): void;
+    }
+
+
+    module dialog {
+
+        module definition {
+
+            interface button extends uiElement {
+                disabled?: boolean;
+                label?: string;
+            }
+
+
+            interface uiElement {
+                align?: string;
+                className?: string;
+                commit?: Function;
+                id?: string;
+                onHide?: Function;
+                onLoad?: Function;
+                requiredcontent?: any;
+                setup?: Function;
+                style?: string;
+                title?: string;
+                type?: string;
+            }
+
+        }
+
+    }
+
+
+    module htmlParser {
+
+        class basicWriter {
+            constructor();
+            openTag(tagName: string, attributes: Object): void;
+            openTagClose(tagName: string, isSelfClose: boolean): void;
+            attribute(attName: string, attValue: string): void;
+            closeTag(tagName: string): void;
+            text(text: string): void;
+            comment(comment: string): void;
+            write(data: string): void;
+            reset(): void;
+            getHtml(reset: boolean): string;
+        }
+
+
+        class node {
+            constructor();
+            remove(preserveChildren?: boolean): node;
+            replaceWith(node: node): void;
+            insertAfter(node: node): void;
+            insertBefore(node: node): void;
+            getAscendant(condition: string): element;
+            getAscendant(condition: Object): element;
+            getAscendant(condition: Function): element;
+            wrapWith(wrapper: element): element;
+            getIndex(): number;
+        }
+
+
+        class filter {
+            constructor(rules?: filterRulesDefinition);
+            id: number;
+            elementNameRules: filterRulesGroup;
+            attributeNameRules: filterRulesGroup;
+            elementsRules: Object;
+            attributesRules: Object;
+            textRules: filterRulesGroup;
+            commentRules: filterRulesGroup;
+            rootRules: filterRulesGroup;
+            addRules(rules: filterRulesDefinition, options?: number): void;
+            addRules(rules: filterRulesDefinition, options?: { priority?: number; applyToAll?: boolean; }): void;
+            applyTo(node: node): void;
+        }
+
+
+        interface filterRulesDefinition {
+
+        }
+
+
+        class filterRulesGroup {
+            rules: Object[];
+            add(rule: Function, priority: number, options: Object): void;
+            add(rule: Object[], priority: number, options: Object): void;
+            addMany(rules: Object[], priority: number, options: Object): void;
+            findIndex(priority: number): number;
+            exec(currentValue: Object): Object;
+            execOnName(currentName: string): string;
+        }
+
+
+        class cdata extends node {
+            constructor(value: string);
+            type: number;
+            writeHtml(writer: basicWriter): void;
+        }
+
+
+        class comment extends node {
+            constructor(value: string);
+            type: number;
+            filter(filter: filter): boolean;
+            writeHtml(writer: basicWriter, filter: filter): void;
+        }
+
+
+        class element extends node {
+            constructor(name: string, attributes: Object);
+            name: string;
+            attributes: Object;
+            children: Object[];
+            type: number;
+            add(node: node): number;
+            clone(): element;
+            filter(filter: filter): boolean;
+            filterChildren(filter: filter): void;
+            writeHtml(writer: basicWriter, filter: filter): void;
+            writeChildrenHtml(writer: basicWriter, filter: filter): void;
+            replaceWithChildren(): void;
+            forEach(callback: (node: node, type?: number) => boolean): void;
+            getFirst(condition: string): node;
+            getFirst(condition: Object): node;
+            getFirst(condition: Function): node;
+            getHtml(): string;
+            setHtml(html: string): void;
+            getOuterHtml(): string;
+            split(index: number): element;
+            removeClass(className: string): void;
+            hasClass(className: string): boolean;
+        }
+
+
+        class fragment {
+            constructor();
+            children: Object[];
+            parent: Object;
+            type: number;
+            fromHtml(fragmentHtml: string, parent?: element, fixingBlock?: string): void;
+            fromHtml(fragmentHtml: string, parent?: string, fixingBlock?: string): void;
+            fromHtml(fragmentHtml: string, parent?: element, fixingBlock?: boolean): void;
+            fromHtml(fragmentHtml: string, parent?: string, fixingBlock?: boolean): void;
+            add(node: node, index?: number): void;
+            filter(filter: filter): void;
+            filterChildren(filter: filter, filterRoot?: boolean): void;
+            writeHtml(writer: basicWriter, filter?: filter): void;
+            writeChildrenHtml(writer: basicWriter, filter?: filter, filterRoot?: boolean): void;
+            forEach(callback: (node: node, type?: number) => boolean, type?: number, skipRoot?: boolean): void;
+        }
+
+
+        class cssStyle {
+            constructor(element: element);
+            constructor(styleText: string);
+            populate(obj: element): void;
+            populate(obj: dom.element): void;
+            populate(obj: Object): void;
+        }
+
+
+        class text extends node {
+            constructor(value: string);
+            type: number;
+            filter(filter: filter): boolean;
+            writeHtml(writer: basicWriter, filter?: filter): void;
+        }
+
+    }
+
+
+    interface dialog {
+        addFocusable(element: CKEDITOR.dom.element, index: number): void;
+    }
+
+}
\ No newline at end of file

From 73747f076ca1593da4fd69d79b993053ddd9bc7d Mon Sep 17 00:00:00 2001
From: Artur Soler <artur.soler@gmail.com>
Date: Fri, 14 Mar 2014 18:44:29 +0100
Subject: [PATCH 102/309] calls is an object (it should probably be defined),
 not an array.

---
 jasmine/jasmine.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/jasmine/jasmine.d.ts b/jasmine/jasmine.d.ts
index 2abc82ceb..794538ec5 100644
--- a/jasmine/jasmine.d.ts
+++ b/jasmine/jasmine.d.ts
@@ -354,7 +354,7 @@ declare module jasmine {
 
         identity: string;
         and: SpyAnd;
-        calls: any[];
+        calls: any;
         mostRecentCall: { args: any[]; };
         argsForCall: any[];
         wasCalled: boolean;

From 5a37274782d3dade8f3525fa59d8bb72c0757057 Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Sat, 15 Mar 2014 19:00:36 +0900
Subject: [PATCH 103/309] remove not required .tscparams

---
 casperjs/casperjs.d.ts.tscparams                       | 1 -
 jquery.jsignature/jquery.jsignature-tests.ts.tscparams | 1 -
 jquery.jsignature/jquery.jsignature.d.ts.tscparams     | 1 -
 phantomjs/phantomjs.d.ts.tscparams                     | 1 -
 phonegap/phonegap.d.ts.tscparams                       | 1 -
 restangular/restangular.d.ts.tscparams                 | 1 -
 socket.io/socket.io.d.ts.tscparams                     | 1 -
 7 files changed, 7 deletions(-)
 delete mode 100644 casperjs/casperjs.d.ts.tscparams
 delete mode 100644 jquery.jsignature/jquery.jsignature-tests.ts.tscparams
 delete mode 100644 jquery.jsignature/jquery.jsignature.d.ts.tscparams
 delete mode 100644 phantomjs/phantomjs.d.ts.tscparams
 delete mode 100644 phonegap/phonegap.d.ts.tscparams
 delete mode 100644 restangular/restangular.d.ts.tscparams
 delete mode 100644 socket.io/socket.io.d.ts.tscparams

diff --git a/casperjs/casperjs.d.ts.tscparams b/casperjs/casperjs.d.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/casperjs/casperjs.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/jquery.jsignature/jquery.jsignature-tests.ts.tscparams b/jquery.jsignature/jquery.jsignature-tests.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/jquery.jsignature/jquery.jsignature-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/jquery.jsignature/jquery.jsignature.d.ts.tscparams b/jquery.jsignature/jquery.jsignature.d.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/jquery.jsignature/jquery.jsignature.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/phantomjs/phantomjs.d.ts.tscparams b/phantomjs/phantomjs.d.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/phantomjs/phantomjs.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/phonegap/phonegap.d.ts.tscparams b/phonegap/phonegap.d.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/phonegap/phonegap.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/restangular/restangular.d.ts.tscparams b/restangular/restangular.d.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/restangular/restangular.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/socket.io/socket.io.d.ts.tscparams b/socket.io/socket.io.d.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/socket.io/socket.io.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""

From 476c4881c61d6bcee85ac976a716bcfc57db9431 Mon Sep 17 00:00:00 2001
From: soywiz <soywiz@gmail.com>
Date: Sat, 15 Mar 2014 12:13:06 +0100
Subject: [PATCH 104/309] - Added urlrouter

---
 README.md                    |  1 +
 urlrouter/urlrouter-tests.ts | 19 ++++++++++
 urlrouter/urlrouter.d.ts     | 69 ++++++++++++++++++++++++++++++++++++
 3 files changed, 89 insertions(+)
 create mode 100644 urlrouter/urlrouter-tests.ts
 create mode 100644 urlrouter/urlrouter.d.ts

diff --git a/README.md b/README.md
index 9bd82091d..aa6a5f7b3 100755
--- a/README.md
+++ b/README.md
@@ -268,6 +268,7 @@ List of Definitions
 * [Underscore.js (Typed)](http://underscorejs.org/) (by [Josh Baldwin](https://github.com/jbaldwin/))
 * [Underscore-ko.js](https://github.com/kamranayub/UnderscoreKO) (by [Maurits Elbers](https://github.com/MagicMau))
 * [universal-analytics](https://github.com/peaksandpies/universal-analytics) (by [Bart van der Schoor](https://github.com/Bartvds))
+* [urlrouter](https://github.com/fengmk2/urlrouter) (by [Carlos Ballesteros Velasco](https://github.com/soywiz))
 * [UUID.js](https://github.com/LiosK/UUID.js) (by [Jason Jarrett](https://github.com/staxmanade))
 * [Valerie](https://github.com/davewatts/valerie) (by [Howard Richards](https://github.com/conficient))
 * [Viewporter](https://github.com/zynga/viewporter) (by [Boris Yankov](https://github.com/borisyankov))
diff --git a/urlrouter/urlrouter-tests.ts b/urlrouter/urlrouter-tests.ts
new file mode 100644
index 000000000..c1411c3a3
--- /dev/null
+++ b/urlrouter/urlrouter-tests.ts
@@ -0,0 +1,19 @@
+/// <reference path="urlrouter.d.ts" />
+
+import http = require("http");
+import urlrouter = require("urlrouter");
+
+var result = urlrouter((app) => {
+	app.get('/', (req, res, next) => {
+		res.end('hello urlrouter');
+	});
+	app.get('/user/:id([0-9]+)', (req, res, next) => {
+		res.end('hello user ' + req.params.id);
+	});
+});
+
+var req: urlrouter.ServerRequest;
+var res: urlrouter.ServerResponse;
+function next() { }
+
+result(req, res, next);
\ No newline at end of file
diff --git a/urlrouter/urlrouter.d.ts b/urlrouter/urlrouter.d.ts
new file mode 100644
index 000000000..925484308
--- /dev/null
+++ b/urlrouter/urlrouter.d.ts
@@ -0,0 +1,69 @@
+// Type definitions for urlrouter
+// Project: https://github.com/fengmk2/urlrouter
+// Definitions by: soywiz <https://github.com/soywiz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "_UrlRouterInternal" {
+    import http = require("http");
+
+    export interface ServerRequest extends http.ServerRequest {
+        params: any;
+    }
+
+    export interface ServerResponse extends http.ServerResponse {
+
+    }
+
+    export interface App {
+        // https://github.com/visionmedia/node-methods/blob/master/index.js
+        get(urlpattern: string, handler: HttpHandler): void;
+        post(urlpattern: string, handler: HttpHandler): void;
+        put(urlpattern: string, handler: HttpHandler): void;
+        head(urlpattern: string, handler: HttpHandler): void;
+        delete(urlpattern: string, handler: HttpHandler): void;
+        options(urlpattern: string, handler: HttpHandler): void;
+        trace(urlpattern: string, handler: HttpHandler): void;
+        copy(urlpattern: string, handler: HttpHandler): void;
+        lock(urlpattern: string, handler: HttpHandler): void;
+        mkcol(urlpattern: string, handler: HttpHandler): void;
+        move(urlpattern: string, handler: HttpHandler): void;
+        propfind(urlpattern: string, handler: HttpHandler): void;
+        proppatch(urlpattern: string, handler: HttpHandler): void;
+        unlock(urlpattern: string, handler: HttpHandler): void;
+        report(urlpattern: string, handler: HttpHandler): void;
+        mkactivity(urlpattern: string, handler: HttpHandler): void;
+        checkout(urlpattern: string, handler: HttpHandler): void;
+        merge(urlpattern: string, handler: HttpHandler): void;
+        "m-search"(urlpattern: string, handler: HttpHandler): void;
+        notify(urlpattern: string, handler: HttpHandler): void;
+        subscribe(urlpattern: string, handler: HttpHandler): void;
+        unsubscribe(urlpattern: string, handler: HttpHandler): void;
+        patch(urlpattern: string, handler: HttpHandler): void;
+        search(urlpattern: string, handler: HttpHandler): void;
+
+        all(urlpattern: string, handler: HttpHandler): void;
+        redirect(urlpattern: string, to: string): void;
+    }
+
+    export interface Options {
+        paramsName?: string;
+        pageNotFound?: (req: ServerRequest, res: ServerResponse) => void;
+        errorHandler?: (err:Error, req: ServerRequest, res: ServerResponse) => void;
+    }
+
+    export function _UrlRouterfunc(handler: (app: App) => void, options?: any): void;
+
+    export interface HttpHandler {
+        (req: ServerRequest, res: ServerResponse, next?: () => void): void;
+    }
+
+}
+
+declare module "urlrouter" {
+    import _UrlRouterInternal = require("_UrlRouterInternal");
+
+    function _UrlRouterInternal(handler: (app: _UrlRouterInternal.App) => void): _UrlRouterInternal.HttpHandler;
+    export = _UrlRouterInternal;
+}
\ No newline at end of file

From ee5fdbf00e8039bfc56f64f506a45eda789586e6 Mon Sep 17 00:00:00 2001
From: Basarat Ali Syed <basaratali@gmail.com>
Date: Sat, 15 Mar 2014 22:41:09 +1100
Subject: [PATCH 105/309] Corrected location of `current`

Reference : http://gruntjs.com/api/inside-tasks
---
 gruntjs/gruntjs.d.ts | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/gruntjs/gruntjs.d.ts b/gruntjs/gruntjs.d.ts
index cfe2825e4..94ec7b533 100644
--- a/gruntjs/gruntjs.d.ts
+++ b/gruntjs/gruntjs.d.ts
@@ -809,6 +809,12 @@ declare module grunt {
              * This method is used internally by the multi task system this.files / grunt.task.current.files property.
              */
             normalizeMultiTaskFiles(data: grunt.config.IProjectConfig, targetname?: string): Array<grunt.file.IFileMap>
+
+            /**
+             * The currently running task or multitask.
+             * @see http://gruntjs.com/api/inside-tasks
+             */
+            current: grunt.task.IMultiTask<any>
         }
 
         interface AsyncResultCatcher {
@@ -1232,13 +1238,6 @@ declare module grunt {
     }
 
     interface ITaskComponents extends grunt.task.CommonTaskModule {
-
-        /**
-         * The currently running task or multitask.
-         * @see IMultiTask for when to cast
-         */
-        current: grunt.task.ITask
-
         /**
          * Load task-related files from the specified directory, relative to the Gruntfile.
          * This method can be used to load task-related files from a local Grunt plugin by

From 418438f064aa3a2b8b9e13a05c990b24ba947230 Mon Sep 17 00:00:00 2001
From: Santi Albo <santialbo@gmail.com>
Date: Sat, 15 Mar 2014 13:12:19 +0100
Subject: [PATCH 106/309] Fix typo on test

---
 restify/restify-tests.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/restify/restify-tests.ts b/restify/restify-tests.ts
index 79a56f578..329f1e8c3 100644
--- a/restify/restify-tests.ts
+++ b/restify/restify-tests.ts
@@ -98,7 +98,7 @@ server.get( /(.*)/, send);
 server.head(/(.*)/, send);
 
 new restify.ConflictError("test");
-new restify.InvalidArguementError("message");
+new restify.InvalidArgumentError("message");
 new restify.RestError("message");
 new restify.BadDigestError("message");
 new restify.BadMethodError("message");

From 1693c24110c906904a0514dc6fd6344a0c8b8356 Mon Sep 17 00:00:00 2001
From: Basarat Ali Syed <basaratali@gmail.com>
Date: Sun, 16 Mar 2014 00:03:28 +1100
Subject: [PATCH 107/309] Added missing write signature

This is also consistent with the doc comments already there.
---
 gruntjs/gruntjs.d.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/gruntjs/gruntjs.d.ts b/gruntjs/gruntjs.d.ts
index 94ec7b533..f646bcbf2 100644
--- a/gruntjs/gruntjs.d.ts
+++ b/gruntjs/gruntjs.d.ts
@@ -393,7 +393,8 @@ declare module grunt {
              * @param contents If `contents` is a Buffer, encoding is ignored.
              * @param options If an encoding is not specified, default to grunt.file.defaultEncoding.
              */
-            write(filepath: string, contents: NodeBuffer, options?: IFileEncodedOption): void
+            write(filepath: string, contents: string, options?: IFileEncodedOption): void
+            write(filepath: string, contents: NodeBuffer): void
 
             /**
              * Copy a source file to a destination path, creating intermediate directories if necessary.

From eba4473728c0fd5d0014e7cb44c59a64bb4c76f8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gy=C3=B6rgy=20Bal=C3=A1ssy?= <balassy@aut.bme.hu>
Date: Sun, 16 Mar 2014 01:33:02 +0100
Subject: [PATCH 108/309] AMD support

Added AMD support as the original ZeroClipboard.js has direct built-in support for AMD as well.
---
 zeroclipboard/zeroclipboard.d.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/zeroclipboard/zeroclipboard.d.ts b/zeroclipboard/zeroclipboard.d.ts
index 44c6423ed..5c4e22328 100644
--- a/zeroclipboard/zeroclipboard.d.ts
+++ b/zeroclipboard/zeroclipboard.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/jonrohan/ZeroClipboard
 // Definitions by: Eric J. Smith <https://github.com/ejsmith>
 // Definitions by: Blake Niemyjski <https://github.com/niemyjski>
+// Definitions by: György Balássy <https://github.com/balassy>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 declare class ZeroClipboard {
@@ -35,3 +36,6 @@ interface ZeroClipboardOptions {
     hoverClass?: string;
     activeClass?: string;
 }
+
+// Support AMD.
+declare module "zeroclipboard" { export = ZeroClipboard; }

From 0e7474da9e658b55157e33ec118effb600e55953 Mon Sep 17 00:00:00 2001
From: pkaul <peter@girino.de>
Date: Sun, 16 Mar 2014 18:06:16 +0100
Subject: [PATCH 109/309] Enabling 'when.d.ts' to be also usable as an external
 module so that is can be included like 'import When = require(../when/when);'

---
 when/when.d.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/when/when.d.ts b/when/when.d.ts
index 859618852..2af3fba9d 100644
--- a/when/when.d.ts
+++ b/when/when.d.ts
@@ -78,3 +78,5 @@ declare module When {
         reason?: any;
     }
 }
+
+export = When;

From f8d7eee419e88a7f20c1144fef1843e8b71801dc Mon Sep 17 00:00:00 2001
From: Scott McArthur <github@scottmcarthur.co.uk>
Date: Sun, 16 Mar 2014 17:15:47 +0000
Subject: [PATCH 110/309] Added new() to IResourceClass

Added `new(dataOrParams? : any) : T;` to `IResourceClass<T>` to allow creation of a new instance of the resource using the `new` keyword, which is required to create a new resource object of type `T`.

In the [AngularJS documentation example](http://docs.angularjs.org/api/ngResource/service/$resource) this change would allow for line 27 `new CreditCard({number:'0123'});` where `CreditCard` is `IResourceClass<CreditCard>`. Without this change we get `error TS2083: Invalid 'new' expression.` when new-ing the resource.
---
 angularjs/angular-resource.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/angularjs/angular-resource.d.ts b/angularjs/angular-resource.d.ts
index 0317e17b7..a0cd4ab85 100644
--- a/angularjs/angular-resource.d.ts
+++ b/angularjs/angular-resource.d.ts
@@ -51,6 +51,7 @@ declare module ng.resource {
     // to be considered as parameters to the request.
     // https://github.com/angular/angular.js/blob/v1.2.0/src/ngResource/resource.js#L461-L465
     interface IResourceClass<T> {
+        new(dataOrParams? : any) : T;
         get(): T;
         get(dataOrParams: any): T;
         get(dataOrParams: any, success: Function): T;

From a5e6460613f138de522206dc1eb9ec5a2211e95a Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Sun, 16 Mar 2014 18:48:56 +0100
Subject: [PATCH 111/309] small API updates for highland 1.19.0

---
 highland/highland-tests.ts | 31 +++++++++++------
 highland/highland.d.ts     | 69 ++++++++++++++++++++++++++++++++++++--
 2 files changed, 87 insertions(+), 13 deletions(-)

diff --git a/highland/highland-tests.ts b/highland/highland-tests.ts
index 7acc6c50b..3625b3f81 100644
--- a/highland/highland-tests.ts
+++ b/highland/highland-tests.ts
@@ -73,15 +73,15 @@ var barArr: Bar[];
 var fooStream: Highland.Stream<Foo>;
 var barStream: Highland.Stream<Bar>;
 
+var fooStreamStream: Highland.Stream<Highland.Stream<Foo>>;
+var barStreamStream: Highland.Stream<Highland.Stream<Bar>>;
+
 var fooArrStream: Highland.Stream<Foo[]>;
 var barArrStream: Highland.Stream<Bar[]>;
 
 var fooStreamArr: Highland.Stream<Foo>[];
 var barStreamArr: Highland.Stream<Bar>[];
 
-var fooStreamArr: Highland.Stream<Foo>[];
-var barStreamArr: Highland.Stream<Bar>[];
-
 var strFooArrMapStream: Highland.Stream<StrFooArrMap>;
 var strBarArrMapStream: Highland.Stream<StrBarArrMap>;
 
@@ -184,13 +184,13 @@ strStream = _.keys(obj);
 anyArrStream = _.pairs(obj);
 anyArrStream = _.pairs(fooArr);
 
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 obj = _.extend(obj, obj);
 
 objCurObj = _.extend(obj);
 
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 x = _.get(str, obj);
 
@@ -200,26 +200,26 @@ obj = _.set(str, foo, obj);
 
 objCurAny = _.set(str, foo);
 
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 _.log(str);
 _.log(str, num, foo);
 
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 f = _.wrapCallback(func);
 
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 num = _.add(num, num);
 
 numCurNum = _.add(num);
 
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 // instance methods
 
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 fooStream.pause();
 fooStream.resume();
@@ -323,6 +323,10 @@ fooStream = fooStream.flatFilter((x: Foo) => {
 	return boolStream;
 });
 
+fooStream = fooStream.reject((x: Foo) => {
+	return bool;
+});
+
 fooStream = fooStream.find((x: Foo) => {
 	return bool;
 });
@@ -343,6 +347,7 @@ fooStream = fooStream.where(obj);
 fooStream = fooStream.zip(fooStream);
 fooStream = fooStream.zip([foo, foo]);
 
+fooStream = fooStream.head();
 fooStream = fooStream.take(num);
 
 fooStream = fooStream.last();
@@ -383,6 +388,10 @@ fooStream = fooStream.concat(fooArr);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
+fooStream = fooStream.merge(fooStreamStream);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
 barStream = fooStream.invoke<Bar>(str, anyArr);
 
 fooStream = fooStream.throttle(num);
@@ -393,4 +402,4 @@ fooStream = fooStream.debounce(num);
 
 fooStream = fooStream.latest();
 
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
diff --git a/highland/highland.d.ts b/highland/highland.d.ts
index 252c617ea..8760a5c2d 100644
--- a/highland/highland.d.ts
+++ b/highland/highland.d.ts
@@ -8,6 +8,7 @@
 // TODO export the top-level functions
 
 // TODO figure out curry arguments
+// TODO create more overloads for nested data, like streams-of-streams or streams-of-array-of-streams etc
 // TODO use externalised Thenable
 // TODO use externalised Readable/Writable (not node's)
 
@@ -19,7 +20,6 @@
  * Copyright (c) Caolan McMahon
  *
  */
-
 interface HighlandStatic {
 	/**
 	 * The Stream constructor, accepts an array of values or a generator function
@@ -320,8 +320,9 @@ interface HighlandStatic {
 	 * @api public
 	 */
 	add(a: number, b: number): number;
-
 	add(a: number): (b: number) => number;
+
+	not<R>(a: any): boolean;
 }
 
 declare module Highland {
@@ -660,6 +661,21 @@ declare module Highland {
 		 */
 		flatFilter(f: (x: R) => Stream<boolean>): Stream<R>;
 
+		/**
+		 * The inverse of [filter](#filter).
+		 *
+		 * @id reject
+		 * @section Streams
+		 * @name Stream.reject(f)
+		 * @param {Function} f - the truth test function
+		 * @api public
+		 *
+		 * var odds = _([1, 2, 3, 4]).reject(function (x) {
+		 *     return x % 2 === 0;
+		 * });
+		 */
+		reject(f: (x: R) => boolean): Stream<R>;
+
 		/**
 		 * A convenient form of filter, which returns the first object from a
 		 * Stream that passes the provided truth test
@@ -733,6 +749,18 @@ declare module Highland {
 		 */
 		take(n: number): Stream<R>;
 
+		/**
+		 * Creates a new Stream with only the first value from the source.
+		 *
+		 * @id head
+		 * @section Streams
+		 * @name Stream.head()
+		 * @api public
+		 *
+		 * _([1, 2, 3, 4]).head() // => 1
+		 */
+		head(): Stream<R>;
+
 		/**
 		 * Drops all values from the Stream apart from the last one (if any).
 		 *
@@ -871,6 +899,20 @@ declare module Highland {
 		 */
 		scan<U>(memo: U, x: (memo: U, x: R) => U): Stream<U>;
 
+		/**
+		 * Same as [scan](#scan), but uses the first element as the initial
+		 * state instead of passing in a `memo` value.
+		 *
+		 * @id scan1
+		 * @section Streams
+		 * @name Stream.scan1(iterator)
+		 * @param {Function} iterator - the function which reduces the values
+		 * @api public
+		 *
+		 * _([1, 2, 3, 4]).scan1(add) // => 1, 3, 6, 10
+		 */
+		scan1<U>(memo: U, x: (memo: U, x: R) => U): Stream<U>;
+
 		// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 		/**
@@ -889,6 +931,29 @@ declare module Highland {
 		concat(ys: Stream<R>): Stream<R>;
 		concat(ys: R[]): Stream<R>;
 
+		/**
+		 * Takes a Stream of Streams and merges their values and errors into a
+		 * single new Stream. The merged stream ends when all source streams have
+		 * ended.
+		 *
+		 * Note that no guarantee is made with respect to the order in which
+		 * values for each stream end up in the merged stream. Values in the
+		 * merged stream will, however, respect the order they were emitted from
+		 * their respective streams.
+		 *
+		 * @id merge
+		 * @section Streams
+		 * @name Stream.merge()
+		 * @api public
+		 *
+		 * var txt = _(['foo.txt', 'bar.txt']).map(readFile)
+		 * var md = _(['baz.md']).map(readFile)
+		 *
+		 * _([txt, md]).merge();
+		 * // => contents of foo.txt, bar.txt and baz.txt in the order they were read
+		 */
+		merge (ys: Stream<Stream<R>>): Stream<R>;
+
 		// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 		/**

From d40e2530fd0ce44e0d3f959d2a72fe04410f5e60 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Sun, 16 Mar 2014 00:01:32 +0100
Subject: [PATCH 112/309] improved bluebird definitions

changed part of module to static class members
- enables Promise.try()
various small fixes and tweaks
---
 bluebird/bluebird-tests.ts | 149 +++++-----
 bluebird/bluebird.d.ts     | 574 +++++++++++++++++++------------------
 2 files changed, 368 insertions(+), 355 deletions(-)

diff --git a/bluebird/bluebird-tests.ts b/bluebird/bluebird-tests.ts
index e5d83db7a..abead4237 100644
--- a/bluebird/bluebird-tests.ts
+++ b/bluebird/bluebird-tests.ts
@@ -149,17 +149,17 @@ barThen = barProm;
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 fooProm = new Promise((resolve: (value: Foo) => void, reject: (reason: any) => void) => {
-    if (bool) {
-        resolve(foo);
-    }
-    else {
-        reject(new Error(str));
-    }
+	if (bool) {
+		resolve(foo);
+	}
+	else {
+		reject(new Error(str));
+	}
 });
 fooProm = new Promise((resolve: (value: Foo) => void) => {
-    if (bool) {
-        resolve(foo);
-    }
+	if (bool) {
+		resolve(foo);
+	}
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - -
@@ -181,11 +181,11 @@ fooProm = new Promise<Foo>((resolve) => {
 
 fooResolver.resolve(foo);
 
-fooResolver.reject(foo);
+fooResolver.reject(err);
 
-fooResolver.progress(foo);
+fooResolver.progress(bar);
 
-fooResolver.callback = () => {
+fooResolver.callback = (err: any, value: Foo) => {
 
 };
 
@@ -204,9 +204,9 @@ x = fooInspection.error();
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 barProm = fooProm.then((value: Foo) => {
-    return bar;
+	return bar;
 }, (reason: any) => {
-    return bar;
+	return bar;
 }, (note: any) => {
 	return bar;
 });
@@ -216,42 +216,42 @@ barProm = fooProm.then((value: Foo) => {
 	return bar;
 });
 barProm = fooProm.then((value: Foo) => {
-    return bar;
+	return bar;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 barProm = fooProm.catch((reason: any) => {
-    return bar;
+	return bar;
 });
 barProm = fooProm.caught((reason: any) => {
-    return bar;
+	return bar;
 });
 
 barProm = fooProm.catch((reason: any) => {
-    return bar;
+	return bar;
 }, (reason: any) => {
-    return bar;
+	return bar;
 });
 barProm = fooProm.caught((reason: any) => {
-    return bar;
+	return bar;
 }, (reason: any) => {
-    return bar;
+	return bar;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 barProm = fooProm.catch(Error, (reason: any) => {
-    return bar;
+	return bar;
 });
 barProm = fooProm.caught(Error, (reason: any) => {
-    return bar;
+	return bar;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 barProm = fooProm.error((reason: any) => {
-    return bar;
+	return bar;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -295,43 +295,43 @@ fooProm = fooProm.bind(obj);
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 barProm = fooProm.done((value: Foo) => {
-    return bar;
+	return bar;
 }, (reason: any) => {
-    return bar;
+	return bar;
 }, (note: any) => {
 
 });
 barProm = fooProm.done((value: Foo) => {
-    return bar;
+	return bar;
 }, (reason: any) => {
-    return bar;
+	return bar;
 });
 barProm = fooProm.done((value: Foo) => {
-    return bar;
+	return bar;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 barProm = fooProm.done((value: Foo) => {
-    return barThen;
+	return barThen;
 }, (reason: any) => {
-    return barThen;
+	return barThen;
 }, (note: any) => {
 
 });
 barProm = fooProm.done((value: Foo) => {
-    return barThen;
+	return barThen;
 }, (reason: any) => {
-    return barThen;
+	return barThen;
 });
 barProm = fooProm.done((value: Foo) => {
-    return barThen;
+	return barThen;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 fooProm = fooProm.progressed((note: any) => {
-    return foo;
+	return foo;
 });
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
@@ -355,37 +355,37 @@ fooProm = fooProm.nodeify((err: any, foo?: Foo) => {
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 barProm = fooProm.fork((value: Foo) => {
-    return bar;
+	return bar;
 }, (reason: any) => {
-    return bar;
+	return bar;
 }, (note: any) => {
 
 });
 barProm = fooProm.fork((value: Foo) => {
-    return bar;
+	return bar;
 }, (reason: any) => {
-    return bar;
+	return bar;
 });
 barProm = fooProm.fork((value: Foo) => {
-    return bar;
+	return bar;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 barProm = fooProm.fork((value: Foo) => {
-    return barThen;
+	return barThen;
 }, (reason: any) => {
-    return barThen;
+	return barThen;
 }, (note: any) => {
 
 });
 barProm = fooProm.fork((value: Foo) => {
-    return barThen;
+	return barThen;
 }, (reason: any) => {
-    return barThen;
+	return barThen;
 });
 barProm = fooProm.fork((value: Foo) => {
-    return barThen;
+	return barThen;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -438,23 +438,23 @@ obj = fooProm.toJSON();
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 barProm = fooArrProm.spread<Bar>((one: Foo, two: Bar) => {
-    return bar;
+	return bar;
 }, (reason: any) => {
-    return bar;
+	return bar;
 });
 barProm = fooArrProm.spread<Bar>((one: Foo, two: Bar, twotwo: Foo) => {
-    return bar;
+	return bar;
 });
 
 // - - - - - - - - - - - - - - - - -
 
 barProm = fooArrProm.spread<Bar>((one: Foo, two: Bar) => {
-    return barThen;
+	return barThen;
 }, (reason: any) => {
-    return barThen;
+	return barThen;
 });
 barProm = fooArrProm.spread<Bar>((one: Foo, two: Bar, twotwo: Foo) => {
-    return barThen;
+	return barThen;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -504,8 +504,7 @@ fooProm = fooProm.filter<Foo>((item: Foo) => {
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-///TODO enable try tests
-/*
+
 fooProm = Promise.try(() => {
 	return foo;
 });
@@ -527,7 +526,7 @@ fooProm = Promise.try(() => {
 fooProm = Promise.try(() => {
 	return fooThen;
 }, arr, x);
-*/
+
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 fooProm = Promise.attempt(() => {
@@ -707,16 +706,16 @@ barArrProm = Promise.map(fooArrThen, (item: Foo, index: number, arrayLength: num
 // fooThenArr
 
 barArrProm = Promise.map(fooThenArr, (item: Foo) => {
-    return bar;
+	return bar;
 });
 barArrProm = Promise.map(fooThenArr, (item: Foo) => {
-    return barThen;
+	return barThen;
 });
 barArrProm = Promise.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
-    return bar;
+	return bar;
 });
 barArrProm = Promise.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
-    return barThen;
+	return barThen;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -724,16 +723,16 @@ barArrProm = Promise.map(fooThenArr, (item: Foo, index: number, arrayLength: num
 // fooArr
 
 barArrProm = Promise.map(fooArr, (item: Foo) => {
-    return bar;
+	return bar;
 });
 barArrProm = Promise.map(fooArr, (item: Foo) => {
-    return barThen;
+	return barThen;
 });
 barArrProm = Promise.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
-    return bar;
+	return bar;
 });
 barArrProm = Promise.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
-    return barThen;
+	return barThen;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -779,16 +778,16 @@ barProm = Promise.reduce(fooArrThen, (memo: Bar, item: Foo, index: number, array
 // fooThenArr
 
 barProm = Promise.reduce(fooThenArr, (memo: Bar, item: Foo) => {
-    return memo;
+	return memo;
 }, bar);
 barProm = Promise.reduce(fooThenArr, (memo: Bar, item: Foo) => {
-    return barThen;
+	return barThen;
 }, bar);
 barProm = Promise.reduce(fooThenArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
-    return memo;
+	return memo;
 }, bar);
 barProm = Promise.reduce(fooThenArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
-    return barThen;
+	return barThen;
 }, bar);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -796,7 +795,7 @@ barProm = Promise.reduce(fooThenArr, (memo: Bar, item: Foo, index: number, array
 // fooArr
 
 barProm = Promise.reduce(fooArr, (memo: Bar, item: Foo) => {
-    return memo;
+	return memo;
 }, bar);
 barProm = Promise.reduce(fooArr, (memo: Bar, item: Foo) => {
 	return barThen;
@@ -851,16 +850,16 @@ fooArrProm = Promise.filter(fooArrThen, (item: Foo, index: number, arrayLength:
 // fooThenArr
 
 fooArrProm = Promise.filter(fooThenArr, (item: Foo) => {
-    return bool;
+	return bool;
 });
 fooArrProm = Promise.filter(fooThenArr, (item: Foo) => {
-    return boolThen;
+	return boolThen;
 });
 fooArrProm = Promise.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
-    return bool;
+	return bool;
 });
 fooArrProm = Promise.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
-    return boolThen;
+	return boolThen;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -868,16 +867,16 @@ fooArrProm = Promise.filter(fooThenArr, (item: Foo, index: number, arrayLength:
 // fooArr
 
 fooArrProm = Promise.filter(fooArr, (item: Foo) => {
-    return bool;
+	return bool;
 });
 fooArrProm = Promise.filter(fooArr, (item: Foo) => {
-    return boolThen;
+	return boolThen;
 });
 fooArrProm = Promise.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
-    return bool;
+	return bool;
 });
 fooArrProm = Promise.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
-    return boolThen;
+	return boolThen;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
diff --git a/bluebird/bluebird.d.ts b/bluebird/bluebird.d.ts
index 0d57e49b0..8912ebb88 100644
--- a/bluebird/bluebird.d.ts
+++ b/bluebird/bluebird.d.ts
@@ -213,10 +213,10 @@ declare class Promise<R> implements Promise.Thenable<R> {
 	 *
 	 * Alias `.thenReturn();` for compatibility with earlier ECMAScript version.
 	 */
+	return(): Promise<any>;
+	thenReturn(): Promise<any>;
 	return<U>(value: U): Promise<U>;
 	thenReturn<U>(value: U): Promise<U>;
-	return(): Promise<void>;
-	thenReturn(): Promise<void>;
 
 	/**
 	 * Convenience method for:
@@ -250,12 +250,12 @@ declare class Promise<R> implements Promise.Thenable<R> {
 	spread<U>(onFulfill: Function, onReject?: (reason: any) => Promise.Thenable<U>): Promise<U>;
 	spread<U>(onFulfill: Function, onReject?: (reason: any) => U): Promise<U>;
 	/*
-	// TODO or something like this?
-	spread<U, W>(onFulfill: (...values: W[]) => Promise.Thenable<U>, onReject?: (reason: any) => Promise.Thenable<U>): Promise<U>;
-	spread<U, W>(onFulfill: (...values: W[]) => Promise.Thenable<U>, onReject?: (reason: any) => U): Promise<U>;
-	spread<U, W>(onFulfill: (...values: W[]) => U, onReject?: (reason: any) => Promise.Thenable<U>): Promise<U>;
-	spread<U, W>(onFulfill: (...values: W[]) => U, onReject?: (reason: any) => U): Promise<U>;
-	*/
+	 // TODO or something like this?
+	 spread<U, W>(onFulfill: (...values: W[]) => Promise.Thenable<U>, onReject?: (reason: any) => Promise.Thenable<U>): Promise<U>;
+	 spread<U, W>(onFulfill: (...values: W[]) => Promise.Thenable<U>, onReject?: (reason: any) => U): Promise<U>;
+	 spread<U, W>(onFulfill: (...values: W[]) => U, onReject?: (reason: any) => Promise.Thenable<U>): Promise<U>;
+	 spread<U, W>(onFulfill: (...values: W[]) => U, onReject?: (reason: any) => U): Promise<U>;
+	 */
 	/**
 	 * Same as calling `Promise.all(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
 	 */
@@ -312,9 +312,288 @@ declare class Promise<R> implements Promise.Thenable<R> {
 	// TODO type inference from array-resolving promise?
 	filter<U>(filterer: (item: U, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<U>;
 	filter<U>(filterer: (item: U, index: number, arrayLength: number) => boolean): Promise<U>;
+
+	/**
+	 * Start the chain of promises with `Promise.try`. Any synchronous exceptions will be turned into rejections on the returned promise.
+	 *
+	 * Note about second argument: if it's specifically a true array, its values become respective arguments for the function call. Otherwise it is passed as is as the first argument for the function call.
+	 *
+	 * Alias for `attempt();` for compatibility with earlier ECMAScript version.
+	 */
+	static try<R>(fn: () => Promise.Thenable<R>, args?: any[], ctx?: any): Promise<R>;
+	static try<R>(fn: () => R, args?: any[], ctx?: any): Promise<R>;
+
+	static attempt<R>(fn: () => Promise.Thenable<R>, args?: any[], ctx?: any): Promise<R>;
+	static attempt<R>(fn: () => R, args?: any[], ctx?: any): Promise<R>;
+
+	/**
+	 * Returns a new function that wraps the given function `fn`. The new function will always return a promise that is fulfilled with the original functions return values or rejected with thrown exceptions from the original function.
+	 * This method is convenient when a function can sometimes return synchronously or throw synchronously.
+	 */
+	static method(fn: Function): Function;
+
+	/**
+	 * Create a promise that is resolved with the given `value`. If `value` is a thenable or promise, the returned promise will assume its state.
+	 */
+	static resolve(): Promise<void>;
+	static resolve<R>(value: Promise.Thenable<R>): Promise<R>;
+	static resolve<R>(value: R): Promise<R>;
+
+	/**
+	 * Create a promise that is rejected with the given `reason`.
+	 */
+	static reject(reason: any): Promise<any>;
+	static reject<R>(reason: any): Promise<R>;
+
+	/**
+	 * Create a promise with undecided fate and return a `PromiseResolver` to control it. See resolution?: Promise(#promise-resolution).
+	 */
+	static defer<R>(): Promise.Resolver<R>;
+
+	/**
+	 * Cast the given `value` to a trusted promise. If `value` is already a trusted `Promise`, it is returned as is. If `value` is not a thenable, a fulfilled is: Promise returned with `value` as its fulfillment value. If `value` is a thenable (Promise-like object, like those returned by jQuery's `$.ajax`), returns a trusted that: Promise assimilates the state of the thenable.
+	 */
+	static cast<R>(value: Promise.Thenable<R>): Promise<R>;
+	static cast<R>(value: R): Promise<R>;
+
+	/**
+	 * Sugar for `Promise.resolve(undefined).bind(thisArg);`. See `.bind()`.
+	 */
+	static bind(thisArg: any): Promise<void>;
+
+	/**
+	 * See if `value` is a trusted Promise.
+	 */
+	static is(value: any): boolean;
+
+	/**
+	 * Call this right after the library is loaded to enabled long stack traces. Long stack traces cannot be disabled after being enabled, and cannot be enabled after promises have alread been created. Long stack traces imply a substantial performance penalty, around 4-5x for throughput and 0.5x for latency.
+	 */
+	static longStackTraces(): void;
+
+	/**
+	 * Returns a promise that will be fulfilled with `value` (or `undefined`) after given `ms` milliseconds. If `value` is a promise, the delay will start counting down when it is fulfilled and the returned promise will be fulfilled with the fulfillment value of the `value` promise.
+	 */
+	// TODO enable more overloads
+	static delay<R>(value: Promise.Thenable<R>, ms: number): Promise<R>;
+	static delay<R>(value: R, ms: number): Promise<R>;
+	static delay(ms: number): Promise<void>;
+
+	/**
+	 * Returns a function that will wrap the given `nodeFunction`. Instead of taking a callback, the returned function will return a promise whose fate is decided by the callback behavior of the given node function. The node function should conform to node.js convention of accepting a callback as last argument and calling that callback with error as the first argument and success value on the second argument.
+	 *
+	 * If the `nodeFunction` calls its callback with multiple success values, the fulfillment value will be an array of them.
+	 *
+	 * If you pass a `receiver`, the `nodeFunction` will be called as a method on the `receiver`.
+	 */
+	// TODO how to model promisify?
+	static promisify(nodeFunction: Function, receiver?: any): Function;
+
+	/**
+	 * Promisifies the entire object by going through the object's properties and creating an async equivalent of each function on the object and its prototype chain. The promisified method name will be the original method name postfixed with `Async`. Returns the input object.
+	 *
+	 * Note that the original methods on the object are not overwritten but new methods are created with the `Async`-postfix. For example, if you `promisifyAll()` the node.js `fs` object use `fs.statAsync()` to call the promisified `stat` method.
+	 */
+	// TODO how to model promisifyAll?
+	static promisifyAll(target: Object): Object;
+
+	/**
+	 * Returns a function that can use `yield` to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch.
+	 */
+	// TODO fix coroutine GeneratorFunction
+	static coroutine<R>(generatorFunction: Function): Function;
+
+	/**
+	 * Spawn a coroutine which may yield promises to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch.
+	 */
+	// TODO fix spawn GeneratorFunction
+	static spawn<R>(generatorFunction: Function): Promise<R>;
+
+	/**
+	 * This is relevant to browser environments with no module loader.
+	 *
+	 * Release control of the `Promise` namespace to whatever it was before this library was loaded. Returns a reference to the library namespace so you can attach it to something else.
+	 */
+	static noConflict(): typeof Promise;
+
+	/**
+	 * Add `handler` as the handler to call when there is a possibly unhandled rejection. The default handler logs the error stack to stderr or `console.error` in browsers.
+	 *
+	 * Passing no value or a non-function will have the effect of removing any kind of handling for possibly unhandled rejections.
+	 */
+	static onPossiblyUnhandledRejection(handler: (reason: any) => any): void;
+
+	/**
+	 * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are fulfilled. The promise's fulfillment value is an array with fulfillment values at respective positions to the original array. If any promise in the array rejects, the returned promise is rejected with the rejection reason.
+	 */
+	// TODO enable more overloads
+	// promise of array with promises of value
+	static all<R>(values: Promise.Thenable<Promise.Thenable<R>[]>): Promise<R[]>;
+	// promise of array with values
+	static all<R>(values: Promise.Thenable<R[]>): Promise<R[]>;
+	// array with promises of value
+	static all<R>(values: Promise.Thenable<R>[]): Promise<R[]>;
+	// array with values
+	static all<R>(values: R[]): Promise<R[]>;
+
+	/**
+	 * Like ``Promise.all`` but for object properties instead of array items. Returns a promise that is fulfilled when all the properties of the object are fulfilled. The promise's fulfillment value is an object with fulfillment values at respective keys to the original object. If any promise in the object rejects, the returned promise is rejected with the rejection reason.
+	 *
+	 * If `object` is a trusted `Promise`, then it will be treated as a promise for object rather than for its properties. All other objects are treated for their properties as is returned by `Object.keys` - the object's own enumerable properties.
+	 *
+	 * *The original object is not modified.*
+	 */
+	// TODO verify this is correct
+	// trusted promise for object
+	static props(object: Promise<Object>): Promise<Object>;
+	// object
+	static props(object: Object): Promise<Object>;
+
+	/**
+	 * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are either fulfilled or rejected. The fulfillment value is an array of ``PromiseInspection`` instances at respective positions in relation to the input array.
+	 *
+	 * *original: The array is not modified. The input array sparsity is retained in the resulting array.*
+	 */
+	// promise of array with promises of value
+	static settle<R>(values: Promise.Thenable<Promise.Thenable<R>[]>): Promise<Promise.Inspection<R>[]>;
+	// promise of array with values
+	static settle<R>(values: Promise.Thenable<R[]>): Promise<Promise.Inspection<R>[]>;
+	// array with promises of value
+	static settle<R>(values: Promise.Thenable<R>[]): Promise<Promise.Inspection<R>[]>;
+	// array with values
+	static settle<R>(values: R[]): Promise<Promise.Inspection<R>[]>;
+
+	/**
+	 * Like `Promise.some()`, with 1 as `count`. However, if the promise fulfills, the fulfillment value is not an array of 1 but the value directly.
+	 */
+	// promise of array with promises of value
+	static any<R>(values: Promise.Thenable<Promise.Thenable<R>[]>): Promise<R>;
+	// promise of array with values
+	static any<R>(values: Promise.Thenable<R[]>): Promise<R>;
+	// array with promises of value
+	static any<R>(values: Promise.Thenable<R>[]): Promise<R>;
+	// array with values
+	static any<R>(values: R[]): Promise<R>;
+
+	/**
+	 * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled or rejected as soon as a promise in the array is fulfilled or rejected with the respective rejection reason or fulfillment value.
+	 *
+	 * **Note** If you pass empty array or a sparse array with no values, or a promise/thenable for such, it will be forever pending.
+	 */
+	// promise of array with promises of value
+	static race<R>(values: Promise.Thenable<Promise.Thenable<R>[]>): Promise<R>;
+	// promise of array with values
+	static race<R>(values: Promise.Thenable<R[]>): Promise<R>;
+	// array with promises of value
+	static race<R>(values: Promise.Thenable<R>[]): Promise<R>;
+	// array with values
+	static race<R>(values: R[]): Promise<R>;
+
+	/**
+	 * Initiate a competetive race between multiple promises or values (values will become immediately fulfilled promises). When `count` amount of promises have been fulfilled, the returned promise is fulfilled with an array that contains the fulfillment values of the winners in order of resolution.
+	 *
+	 * If too many promises are rejected so that the promise can never become fulfilled, it will be immediately rejected with an array of rejection reasons in the order they were thrown in.
+	 *
+	 * *The original array is not modified.*
+	 */
+	// promise of array with promises of value
+	static some<R>(values: Promise.Thenable<Promise.Thenable<R>[]>, count: number): Promise<R[]>;
+	// promise of array with values
+	static some<R>(values: Promise.Thenable<R[]>, count: number): Promise<R[]>;
+	// array with promises of value
+	static some<R>(values: Promise.Thenable<R>[], count: number): Promise<R[]>;
+	// array with values
+	static some<R>(values: R[], count: number): Promise<R[]>;
+
+	/**
+	 * Like `Promise.all()` but instead of having to pass an array, the array is generated from the passed variadic arguments.
+	 */
+	// variadic array with promises of value
+	static join<R>(...values: Promise.Thenable<R>[]): Promise<R[]>;
+	// variadic array with values
+	static join<R>(...values: R[]): Promise<R[]>;
+
+	/**
+	 * Map an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `mapper` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
+	 *
+	 * If the `mapper` function returns promises or thenables, the returned promise will wait for all the mapped results to be resolved as well.
+	 *
+	 * *The original array is not modified.*
+	 */
+	// promise of array with promises of value
+	static map<R, U>(values: Promise.Thenable<Promise.Thenable<R>[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable<U>): Promise<U[]>;
+	static map<R, U>(values: Promise.Thenable<Promise.Thenable<R>[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
+
+	// promise of array with values
+	static map<R, U>(values: Promise.Thenable<R[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable<U>): Promise<U[]>;
+	static map<R, U>(values: Promise.Thenable<R[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
+
+	// array with promises of value
+	static map<R, U>(values: Promise.Thenable<R>[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable<U>): Promise<U[]>;
+	static map<R, U>(values: Promise.Thenable<R>[], mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
+
+	// array with values
+	static map<R, U>(values: R[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable<U>): Promise<U[]>;
+	static map<R, U>(values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
+
+	/**
+	 * Reduce an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `reducer` function with the signature `(total, current, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
+	 *
+	 * If the reducer function returns a promise or a thenable, the result for the promise is awaited for before continuing with next iteration.
+	 *
+	 * *The original array is not modified. If no `intialValue` is given and the array doesn't contain at least 2 items, the callback will not be called and `undefined` is returned. If `initialValue` is given and the array doesn't have at least 1 item, `initialValue` is returned.*
+	 */
+	// promise of array with promises of value
+	static reduce<R, U>(values: Promise.Thenable<Promise.Thenable<R>[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable<U>, initialValue?: U): Promise<U>;
+	static reduce<R, U>(values: Promise.Thenable<Promise.Thenable<R>[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
+
+	// promise of array with values
+	static reduce<R, U>(values: Promise.Thenable<R[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable<U>, initialValue?: U): Promise<U>;
+	static reduce<R, U>(values: Promise.Thenable<R[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
+
+	// array with promises of value
+	static reduce<R, U>(values: Promise.Thenable<R>[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable<U>, initialValue?: U): Promise<U>;
+	static reduce<R, U>(values: Promise.Thenable<R>[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
+
+	// array with values
+	static reduce<R, U>(values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable<U>, initialValue?: U): Promise<U>;
+	static reduce<R, U>(values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
+
+	/**
+	 * Filter an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `filterer` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
+	 *
+	 * The return values from the filtered functions are coerced to booleans, with the exception of promises and thenables which are awaited for their eventual result.
+	 *
+	 * *The original array is not modified.
+	 */
+	// promise of array with promises of value
+	static filter<R>(values: Promise.Thenable<Promise.Thenable<R>[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R[]>;
+	static filter<R>(values: Promise.Thenable<Promise.Thenable<R>[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
+
+	// promise of array with values
+	static filter<R>(values: Promise.Thenable<R[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R[]>;
+	static filter<R>(values: Promise.Thenable<R[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
+
+	// array with promises of value
+	static filter<R>(values: Promise.Thenable<R>[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R[]>;
+	static filter<R>(values: Promise.Thenable<R>[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
+
+	// array with values
+	static filter<R>(values: R[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R[]>;
+	static filter<R>(values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
 }
 
 declare module Promise {
+	export interface RangeError extends Error {
+	}
+	export interface CancellationError extends Error {
+	}
+	export interface TimeoutError extends Error {
+	}
+	export interface TypeError extends Error {
+	}
+	export interface RejectionError extends Error {
+	}
 
 	export interface Thenable<R> {
 		then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected: (error: any) => Thenable<U>): Thenable<U>;
@@ -324,10 +603,16 @@ declare module Promise {
 	}
 
 	export interface Resolver<R> {
+		/**
+		 * Returns a reference to the controlled promise that can be passed to clients.
+		 */
+		promise: Promise<R>;
+
 		/**
 		 * Resolve the underlying promise with `value` as the resolution value. If `value` is a thenable or a promise, the underlying promise will assume its state.
 		 */
 		resolve(value: R): void;
+		resolve(): void;
 
 		/**
 		 * Reject the underlying promise with `reason` as the rejection reason.
@@ -345,7 +630,7 @@ declare module Promise {
 		 * If the the callback is called with multiple success values, the resolver fullfills its promise with an array of the values.
 		 */
 		// TODO specify resolver callback
-		callback: Function;
+		callback: (err: any, value: R, ...values: R[]) => void;
 	}
 
 	export interface Inspection<R> {
@@ -378,277 +663,6 @@ declare module Promise {
 		 */
 		error(): any;
 	}
-
-	/**
-	 * Start the chain of promises with `Promise.try`. Any synchronous exceptions will be turned into rejections on the returned promise.
-	 *
-	 * Note about second argument: if it's specifically a true array, its values become respective arguments for the function call. Otherwise it is passed as is as the first argument for the function call.
-	 *
-	 * Alias for `attempt();` for compatibility with earlier ECMAScript version.
-	 */
-	// TODO find way to enable try() without tsc borking
-	// see also: https://typescript.codeplex.com/workitem/2194
-	/*
-	export function try<R>(fn: () => Promise.Thenable<R>, args?: any[], ctx?: any): Promise<R>;
-	export function try<R>(fn: () => R, args?: any[], ctx?: any): Promise<R>;
-	*/
-
-	export function attempt<R>(fn: () => Promise.Thenable<R>, args?: any[], ctx?: any): Promise<R>;
-	export function attempt<R>(fn: () => R, args?: any[], ctx?: any): Promise<R>;
-
-	/**
-	 * Returns a new function that wraps the given function `fn`. The new function will always return a promise that is fulfilled with the original functions return values or rejected with thrown exceptions from the original function.
-	 * This method is convenient when a function can sometimes return synchronously or throw synchronously.
-	 */
-	export function method(fn: Function): Function;
-
-	/**
-	 * Create a promise that is resolved with the given `value`. If `value` is a thenable or promise, the returned promise will assume its state.
-	 */
-	export function resolve<R>(value: Promise.Thenable<R>): Promise<R>;
-	export function resolve<R>(value: R): Promise<R>;
-
-	/**
-	 * Create a promise that is rejected with the given `reason`.
-	 */
-	export function reject(reason: any): Promise<void>;
-
-	/**
-	 * Create a promise with undecided fate and return a `PromiseResolver` to control it. See resolution?: Promise(#promise-resolution).
-	 */
-	export function defer<R>(): Promise.Resolver<R>;
-
-	/**
-	 * Cast the given `value` to a trusted promise. If `value` is already a trusted `Promise`, it is returned as is. If `value` is not a thenable, a fulfilled is: Promise returned with `value` as its fulfillment value. If `value` is a thenable (Promise-like object, like those returned by jQuery's `$.ajax`), returns a trusted that: Promise assimilates the state of the thenable.
-	 */
-	export function cast<R>(value: Promise.Thenable<R>): Promise<R>;
-	export function cast<R>(value: R): Promise<R>;
-
-	/**
-	 * Sugar for `Promise.resolve(undefined).bind(thisArg);`. See `.bind()`.
-	 */
-	export function bind(thisArg: any): Promise<void>;
-
-	/**
-	 * See if `value` is a trusted Promise.
-	 */
-	export function is(value: any): boolean;
-
-	/**
-	 * Call this right after the library is loaded to enabled long stack traces. Long stack traces cannot be disabled after being enabled, and cannot be enabled after promises have alread been created. Long stack traces imply a substantial performance penalty, around 4-5x for throughput and 0.5x for latency.
-	 */
-	export function longStackTraces(): void;
-
-	/**
-	 * Returns a promise that will be fulfilled with `value` (or `undefined`) after given `ms` milliseconds. If `value` is a promise, the delay will start counting down when it is fulfilled and the returned promise will be fulfilled with the fulfillment value of the `value` promise.
-	 */
-	// TODO enable more overloads
-	export function delay<R>(value: Promise.Thenable<R>, ms: number): Promise<R>;
-	export function delay<R>(value: R, ms: number): Promise<R>;
-	export function delay(ms: number): Promise<void>;
-
-	/**
-	 * Returns a function that will wrap the given `nodeFunction`. Instead of taking a callback, the returned function will return a promise whose fate is decided by the callback behavior of the given node function. The node function should conform to node.js convention of accepting a callback as last argument and calling that callback with error as the first argument and success value on the second argument.
-	 *
-	 * If the `nodeFunction` calls its callback with multiple success values, the fulfillment value will be an array of them.
-	 *
-	 * If you pass a `receiver`, the `nodeFunction` will be called as a method on the `receiver`.
-	 */
-	// TODO how to model promisify?
-	export function promisify(nodeFunction: Function, receiver?: any): Function;
-
-	/**
-	 * Promisifies the entire object by going through the object's properties and creating an async equivalent of each function on the object and its prototype chain. The promisified method name will be the original method name postfixed with `Async`. Returns the input object.
-	 *
-	 * Note that the original methods on the object are not overwritten but new methods are created with the `Async`-postfix. For example, if you `promisifyAll()` the node.js `fs` object use `fs.statAsync()` to call the promisified `stat` method.
-	 */
-	// TODO how to model promisifyAll?
-	export function promisifyAll(target: Object): Object;
-
-	/**
-	 * Returns a function that can use `yield` to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch.
-	 */
-	// TODO fix coroutine GeneratorFunction
-	export function coroutine<R>(generatorFunction: Function): Function;
-
-	/**
-	 * Spawn a coroutine which may yield promises to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch.
-	 */
-	// TODO fix spawn GeneratorFunction
-	export function spawn<R>(generatorFunction: Function): Promise<R>;
-
-	/**
-	 * This is relevant to browser environments with no module loader.
-	 *
-	 * Release control of the `Promise` namespace to whatever it was before this library was loaded. Returns a reference to the library namespace so you can attach it to something else.
-	 */
-	export function noConflict(): typeof Promise;
-
-	/**
-	 * Add `handler` as the handler to call when there is a possibly unhandled rejection. The default handler logs the error stack to stderr or `console.error` in browsers.
-	 *
-	 * Passing no value or a non-function will have the effect of removing any kind of handling for possibly unhandled rejections.
-	 */
-	export function onPossiblyUnhandledRejection(handler: (reason: any) => any): void;
-
-	/**
-	 * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are fulfilled. The promise's fulfillment value is an array with fulfillment values at respective positions to the original array. If any promise in the array rejects, the returned promise is rejected with the rejection reason.
-	 */
-	// TODO enable more overloads
-	// promise of array with promises of value
-	export function all<R>(values: Thenable<Thenable<R>[]>): Promise<R[]>;
-	// promise of array with values
-	export function all<R>(values: Thenable<R[]>): Promise<R[]>;
-	// array with promises of value
-	export function all<R>(values: Thenable<R>[]): Promise<R[]>;
-	// array with values
-	export function all<R>(values: R[]): Promise<R[]>;
-
-	/**
-	 * Like ``Promise.all`` but for object properties instead of array items. Returns a promise that is fulfilled when all the properties of the object are fulfilled. The promise's fulfillment value is an object with fulfillment values at respective keys to the original object. If any promise in the object rejects, the returned promise is rejected with the rejection reason.
-	 *
-	 * If `object` is a trusted `Promise`, then it will be treated as a promise for object rather than for its properties. All other objects are treated for their properties as is returned by `Object.keys` - the object's own enumerable properties.
-	 *
-	 * *The original object is not modified.*
-	 */
-	// TODO verify this is correct
-	// trusted promise for object
-	export function props(object: Promise<Object>): Promise<Object>;
-	// object
-	export function props(object: Object): Promise<Object>;
-
-	/**
-	 * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are either fulfilled or rejected. The fulfillment value is an array of ``PromiseInspection`` instances at respective positions in relation to the input array.
-	 *
-	 * *original: The array is not modified. The input array sparsity is retained in the resulting array.*
-	 */
-		// promise of array with promises of value
-	export function settle<R>(values: Thenable<Thenable<R>[]>): Promise<Promise.Inspection<R>[]>;
-	// promise of array with values
-	export function settle<R>(values: Thenable<R[]>): Promise<Promise.Inspection<R>[]>;
-	// array with promises of value
-	export function settle<R>(values: Thenable<R>[]): Promise<Promise.Inspection<R>[]>;
-	// array with values
-	export function settle<R>(values: R[]): Promise<Promise.Inspection<R>[]>;
-
-	/**
-	 * Like `Promise.some()`, with 1 as `count`. However, if the promise fulfills, the fulfillment value is not an array of 1 but the value directly.
-	 */
-	// promise of array with promises of value
-	export function any<R>(values: Thenable<Thenable<R>[]>): Promise<R>;
-	// promise of array with values
-	export function any<R>(values: Thenable<R[]>): Promise<R>;
-	// array with promises of value
-	export function any<R>(values: Thenable<R>[]): Promise<R>;
-	// array with values
-	export function any<R>(values: R[]): Promise<R>;
-
-	/**
-	 * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled or rejected as soon as a promise in the array is fulfilled or rejected with the respective rejection reason or fulfillment value.
-	 *
-	 * **Note** If you pass empty array or a sparse array with no values, or a promise/thenable for such, it will be forever pending.
-	 */
-	// promise of array with promises of value
-	export function race<R>(values: Thenable<Thenable<R>[]>): Promise<R>;
-	// promise of array with values
-	export function race<R>(values: Thenable<R[]>): Promise<R>;
-	// array with promises of value
-	export function race<R>(values: Thenable<R>[]): Promise<R>;
-	// array with values
-	export function race<R>(values: R[]): Promise<R>;
-
-	/**
-	 * Initiate a competetive race between multiple promises or values (values will become immediately fulfilled promises). When `count` amount of promises have been fulfilled, the returned promise is fulfilled with an array that contains the fulfillment values of the winners in order of resolution.
-	 *
-	 * If too many promises are rejected so that the promise can never become fulfilled, it will be immediately rejected with an array of rejection reasons in the order they were thrown in.
-	 *
-	 * *The original array is not modified.*
-	 */
-	// promise of array with promises of value
-	export function some<R>(values: Thenable<Thenable<R>[]>, count: number): Promise<R[]>;
-	// promise of array with values
-	export function some<R>(values: Thenable<R[]>, count: number): Promise<R[]>;
-	// array with promises of value
-	export function some<R>(values: Thenable<R>[], count: number): Promise<R[]>;
-	// array with values
-	export function some<R>(values: R[], count: number): Promise<R[]>;
-
-	/**
-	 * Like `Promise.all()` but instead of having to pass an array, the array is generated from the passed variadic arguments.
-	 */
-	// variadic array with promises of value
-	export function join<R>(...values: Thenable<R>[]): Promise<R[]>;
-	// variadic array with values
-	export function join<R>(...values: R[]): Promise<R[]>;
-
-	/**
-	 * Map an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `mapper` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
-	 *
-	 * If the `mapper` function returns promises or thenables, the returned promise will wait for all the mapped results to be resolved as well.
-	 *
-	 * *The original array is not modified.*
-	 */
-	// promise of array with promises of value
-	export function map<R, U>(values: Thenable<Thenable<R>[]>, mapper: (item: R, index: number, arrayLength: number) => Thenable<U>): Promise<U[]>;
-	export function map<R, U>(values: Thenable<Thenable<R>[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
-
-	// promise of array with values
-	export function map<R, U>(values: Thenable<R[]>, mapper: (item: R, index: number, arrayLength: number) => Thenable<U>): Promise<U[]>;
-	export function map<R, U>(values: Thenable<R[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
-
-	// array with promises of value
-	export function map<R, U>(values: Thenable<R>[], mapper: (item: R, index: number, arrayLength: number) => Thenable<U>): Promise<U[]>;
-	export function map<R, U>(values: Thenable<R>[], mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
-
-	// array with values
-	export function map<R, U>(values: R[], mapper: (item: R, index: number, arrayLength: number) => Thenable<U>): Promise<U[]>;
-	export function map<R, U>(values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
-
-	/**
-	 * Reduce an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `reducer` function with the signature `(total, current, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
-	 *
-	 * If the reducer function returns a promise or a thenable, the result for the promise is awaited for before continuing with next iteration.
-	 *
-	 * *The original array is not modified. If no `intialValue` is given and the array doesn't contain at least 2 items, the callback will not be called and `undefined` is returned. If `initialValue` is given and the array doesn't have at least 1 item, `initialValue` is returned.*
-	 */
-	// promise of array with promises of value
-	export function reduce<R, U>(values: Thenable<Thenable<R>[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Thenable<U>, initialValue?: U): Promise<U>;
-	export function reduce<R, U>(values: Thenable<Thenable<R>[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
-
-	// promise of array with values
-	export function reduce<R, U>(values: Thenable<R[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Thenable<U>, initialValue?: U): Promise<U>;
-	export function reduce<R, U>(values: Thenable<R[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
-
-	// array with promises of value
-	export function reduce<R, U>(values: Thenable<R>[], reducer: (total: U, current: R, index: number, arrayLength: number) => Thenable<U>, initialValue?: U): Promise<U>;
-	export function reduce<R, U>(values: Thenable<R>[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
-
-	// array with values
-	export function reduce<R, U>(values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Thenable<U>, initialValue?: U): Promise<U>;
-	export function reduce<R, U>(values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
-
-	/**
-	 * Filter an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `filterer` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
-	 *
-	 * The return values from the filtered functions are coerced to booleans, with the exception of promises and thenables which are awaited for their eventual result.
-	 *
-	 * *The original array is not modified.
-	 */
-	// promise of array with promises of value
-	export function filter<R>(values: Thenable<Thenable<R>[]>, filterer: (item: R, index: number, arrayLength: number) => Thenable<boolean>): Promise<R[]>;
-	export function filter<R>(values: Thenable<Thenable<R>[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
-
-	// promise of array with values
-	export function filter<R>(values: Thenable<R[]>, filterer: (item: R, index: number, arrayLength: number) => Thenable<boolean>): Promise<R[]>;
-	export function filter<R>(values: Thenable<R[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
-
-	// array with promises of value
-	export function filter<R>(values: Thenable<R>[], filterer: (item: R, index: number, arrayLength: number) => Thenable<boolean>): Promise<R[]>;
-	export function filter<R>(values: Thenable<R>[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
-
-	// array with values
-	export function filter<R>(values: R[], filterer: (item: R, index: number, arrayLength: number) => Thenable<boolean>): Promise<R[]>;
-	export function filter<R>(values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
 }
 
 declare module 'bluebird' {

From de66a997ffc170969196319aa67048ccc7346f36 Mon Sep 17 00:00:00 2001
From: Mike H Hawley <mikehhawley@gmail.com>
Date: Sun, 16 Mar 2014 21:39:24 +0300
Subject: [PATCH 113/309] smoothie: fix streamTo signature

---
 smoothie/smoothie.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/smoothie/smoothie.d.ts b/smoothie/smoothie.d.ts
index 6267c6e3e..cc0b82d38 100644
--- a/smoothie/smoothie.d.ts
+++ b/smoothie/smoothie.d.ts
@@ -162,10 +162,10 @@ declare module "smoothie"
          * Instructs the <code>SmoothieChart</code> to start rendering to the provided canvas, with specified delay.
          *
          * @param canvas the target canvas element
-         * @param delayMillis an amount of time to wait before a data point is shown. This can prevent the end of the series
+         * @param [delayMillis] an amount of time to wait before a data point is shown. This can prevent the end of the series
          * from appearing on screen, with new values flashing into view, at the expense of some latency.
          */
-        streamTo(canvas: HTMLCanvasElement, delayMillis: number): void;
+        streamTo(canvas: HTMLCanvasElement, delayMillis?: number): void;
 
         /**
          * Starts the animation of this chart. Called by <code>streamTo</code>.

From cd9997d22349eca663d752ed0d0f36ff886e3875 Mon Sep 17 00:00:00 2001
From: studiollama <lahmannm@gmail.com>
Date: Sun, 16 Mar 2014 14:25:14 -0700
Subject: [PATCH 114/309] Update ng-grid.d.ts

Added pinned to IColumnDef, also wondering why under IGridOptions, data isn't a string, any[] doesn't work in my experience.
---
 ng-grid/ng-grid.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ng-grid/ng-grid.d.ts b/ng-grid/ng-grid.d.ts
index f081b362c..94cf900ca 100644
--- a/ng-grid/ng-grid.d.ts
+++ b/ng-grid/ng-grid.d.ts
@@ -176,6 +176,7 @@ declare module ngGrid {
         displayName?: string;
         cellTemplate?: string;
         enableCellEdit?: boolean;
+        pinned?: boolean;
     }
 
     export interface IFilterOptions {

From be638c57f89b42d1474243156980f45e1ddc9039 Mon Sep 17 00:00:00 2001
From: fancyoung <siyang1982@msn.com>
Date: Mon, 17 Mar 2014 12:40:13 +0800
Subject: [PATCH 115/309] fix bootstrap.datepicker type

Param `startDate` and `endDate` are not only Date type.
---
 bootstrap.datepicker/bootstrap.datepicker.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bootstrap.datepicker/bootstrap.datepicker.d.ts b/bootstrap.datepicker/bootstrap.datepicker.d.ts
index 0664b2aa0..40d769b03 100644
--- a/bootstrap.datepicker/bootstrap.datepicker.d.ts
+++ b/bootstrap.datepicker/bootstrap.datepicker.d.ts
@@ -8,8 +8,8 @@
 interface DatepickerOptions {
     format?: string;
     weekStart?: number;
-    startDate?: Date;
-    endDate?: Date;
+    startDate?: any;
+    endDate?: any;
     autoclose?: boolean;
     startView?: number;
     todayBtn?: boolean;

From 38fd3aa269108c5a189bc1a1ab587ed75225a25f Mon Sep 17 00:00:00 2001
From: ondrejsevcik <ondrej.sev@gmail.com>
Date: Mon, 17 Mar 2014 10:38:19 +0100
Subject: [PATCH 116/309] Fix Travis CI build (because of tsc --noImplicitAny
 option)

---
 ckeditor/ckeditor.d.ts | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/ckeditor/ckeditor.d.ts b/ckeditor/ckeditor.d.ts
index ba81a6a1b..8d5b2f815 100644
--- a/ckeditor/ckeditor.d.ts
+++ b/ckeditor/ckeditor.d.ts
@@ -441,7 +441,7 @@ declare module CKEDITOR {
             getTarget(): node;
             getPhase(): number;
             getPhaseOffset(): position;
-            on(eventName: string, listenerFunction: Function, scopeObj?: Object, listenerData?: Object, priority?: number): Object;
+            on(eventName: string, listenerFunction: (eventInfo: eventInfo) => void, scopeObj?: Object, listenerData?: Object, priority?: number): Object;
         }
 
 
@@ -575,7 +575,7 @@ declare module CKEDITOR {
     class menu {
         constructor();
         add(item: any): void;
-        addListener(listenerFn: (startElement: dom.element, selection: dom.selection, path: dom.elementPath) => any);
+        addListener(listenerFn: (startElement: dom.element, selection: dom.selection, path: dom.elementPath) => any): void;
         hide(returnFocus?: boolean): void;
         removeAll(): void;
         show(offsetParent: dom.element, corner?: number, offsetX?: number, offsetY?: number): void;
@@ -587,7 +587,7 @@ declare module CKEDITOR {
         class contextMenu extends menu {
             constructor(editor: editor);
             addTarget(element: dom.element, nativeContextMenuOnCtrl?: boolean): void;
-            open(offsetParent: dom.element, corner?: number, offsetX?: number, offsetY?: number);
+            open(offsetParent: dom.element, corner?: number, offsetX?: number, offsetY?: number): void;
         }
 
 
@@ -740,14 +740,14 @@ declare module CKEDITOR {
         constructor();
         useCapture: boolean;
         capture(): void;
-        define(name: string, meta: Object);
+        define(name: string, meta: Object): void;
         fire(eventName: string, data?: Object, editor?: editor): any;
         fireOnce(eventName: string, data?: Object, editor?: editor): any;
         hasListeners(eventName: string): boolean;
         on(eventName: string, listenerFunction: (eventInfo: eventInfo) => void, scopeObj?: Object, listenerData?: Object, priority?: number): void;
-        once(eventName: string, listenerFunction: Function, scopeObj?: Object, listenerData?: Object, priority?: number): void;
+        once(eventName: string, listenerFunction: (eventInfo: eventInfo) => void, scopeObj?: Object, listenerData?: Object, priority?: number): void;
         removeAllListeners(): void;
-        removeListener(eventName: string, listenerFunction: Function): void;
+        removeListener(eventName: string, listenerFunction: (eventInfo: eventInfo) => void): void;
         static implementOn(targetObject: Object): void;
     }
 

From e3b9fef277e3d7377a1fff8054e099a131defdb8 Mon Sep 17 00:00:00 2001
From: Paul Loyd <pavelko95@gmail.com>
Date: Mon, 17 Mar 2014 14:55:17 +0400
Subject: [PATCH 117/309] node: fix signatures of readFile*

---
 node/node-tests.ts | 18 ++++++++++++++++--
 node/node.d.ts     |  7 +++++--
 2 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/node/node-tests.ts b/node/node-tests.ts
index 49b43302b..397a9dfa4 100644
--- a/node/node-tests.ts
+++ b/node/node-tests.ts
@@ -21,7 +21,9 @@ assert.doesNotThrow(() => {
     if (false) { throw "a hammer at your face"; }
 }, undefined, "What the...*crunch*");
 
-
+////////////////////////////////////////////////////
+/// File system tests : http://nodejs.org/api/fs.html
+////////////////////////////////////////////////////
 fs.writeFile("thebible.txt",
     "Do unto others as you would have them do unto you.",
     assert.ifError);
@@ -33,6 +35,18 @@ fs.writeFile("Harry Potter",
     },
     assert.ifError);
 
+var content: string,
+    buffer: NodeBuffer;
+
+content = fs.readFileSync('testfile', 'utf8');
+content = fs.readFileSync('testfile', {encoding : 'utf8'});
+buffer = fs.readFileSync('testfile');
+buffer = fs.readFileSync('testfile', {flag : 'r'});
+fs.readFile('testfile', 'utf8', (err, data) => content = data);
+fs.readFile('testfile', {encoding : 'utf8'}, (err, data) => content = data);
+fs.readFile('testfile', (err, data) => buffer = data);
+fs.readFile('testfile', {flag : 'r'}, (err, data) => buffer = data);
+
 class Networker extends events.EventEmitter {
     constructor() {
         super();
@@ -65,4 +79,4 @@ function stream_readable_pipe_test() {
     var z = zlib.createGzip();
     var w = fs.createWriteStream('file.txt.gz');
     r.pipe(z).pipe(w);
-}
\ No newline at end of file
+}
diff --git a/node/node.d.ts b/node/node.d.ts
index fe7fbd324..a0473ad8b 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -848,10 +848,13 @@ declare module "fs" {
     export function writeSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
     export function read(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, bytesRead: number, buffer: NodeBuffer) => void): void;
     export function readSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
-    export function readFile(filename: string, options: { encoding?: string; flag?: string; }, callback: (err: ErrnoException, data: any) => void): void;
+    export function readFile(filename: string, encoding: string, callback: (err: ErrnoException, data: string) => void): void;
+    export function readFile(filename: string, options: { encoding: string; flag?: string; }, callback: (err: ErrnoException, data: string) => void): void;
+    export function readFile(filename: string, options: { flag?: string; }, callback: (err: ErrnoException, data: NodeBuffer) => void): void;
     export function readFile(filename: string, callback: (err: ErrnoException, data: NodeBuffer) => void ): void;
-    export function readFileSync(filename: string, options?: { flag?: string; }): NodeBuffer;
+    export function readFileSync(filename: string, encoding: string): string;
     export function readFileSync(filename: string, options: { encoding: string; flag?: string; }): string;
+    export function readFileSync(filename: string, options?: { flag?: string; }): NodeBuffer;
     export function writeFile(filename: string, data: any, callback?: (err: ErrnoException) => void): void;
     export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: ErrnoException) => void): void;
     export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void;

From 2207f80d7fdcc47d910e20588c0e842799a8612a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gy=C3=B6rgy=20Bal=C3=A1ssy?= <balassy@aut.bme.hu>
Date: Mon, 17 Mar 2014 12:47:46 +0100
Subject: [PATCH 118/309] Options updated

Updated the ZeroClipboardObject interface according to the latest spec and extended with JSDoc comments.
---
 zeroclipboard/zeroclipboard.d.ts | 39 +++++++++++++++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/zeroclipboard/zeroclipboard.d.ts b/zeroclipboard/zeroclipboard.d.ts
index 5c4e22328..b8f0ebb92 100644
--- a/zeroclipboard/zeroclipboard.d.ts
+++ b/zeroclipboard/zeroclipboard.d.ts
@@ -31,10 +31,47 @@ declare class ZeroClipboard {
 }
 
 interface ZeroClipboardOptions {
+    /** Setting this to false would allow users to handle calling ZeroClipboard.activate(...); themselves instead of relying on our per-element mouseover handler */
+    autoActivate?: boolean;
+
+    /** Include a "nocache" query parameter on requests for the SWF. */
+    cacheBust?: boolean;
+
+    /** Debug enabled: send console messages with deprecation warnings, etc. */
+    debug?: boolean;
+
+    /** Forcibly set the hand cursor ("pointer") for all clipped elements. */
+    forceHandCursor?: boolean;
+
+    /** URL to the movie. NOTE: For versions >= v1.3.x and < v2.x, you must use swfPath by setting moviePath! */
     moviePath?: string;
+
+    /** URL to the movie, relative to the page. NOTE: For versions >= v1.3.x and < v2.x, you must use swfPath by setting moviePath! */
+    swfPath?: string;
+
+    /** Forcibly set the hand cursor ("pointer") for all clipped elements. */
     trustedDomains?: any;
-    hoverClass?: string;
+
+    /** Sets the title of the div encapsulating the Flash object. */
+    title?: string;
+
+    /** The z-index used by the Flash object. */
+    zIndex?: number;
+
+    /** DEPRECATED. The class used to indicate that a clipped element is active (is being clicked). */
     activeClass?: string;
+
+    /** DEPRECATED. The class used to indicate that a clipped element is being hovered over. */
+    hoverClass?: string;
+
+    /** DEPRECATED. SWF outbound scripting policy. Possible values: "never", "sameDomain", "always". */
+    allowScriptAccess?: string;
+
+    /** DEPRECATED, use trustedDomains instead! SWF inbound scripting policy: page origins that the SWF should trust. (single string or array of strings. */
+    trustedOrigins?: any;
+
+    /** DEPRECATED, use cacheBust instead! Include a "nocache" query parameter on requests for the SWF. */
+    useNoCache?: boolean;
 }
 
 // Support AMD.

From c5865f9043fd95d399e52e92a7251332d80323c6 Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Mon, 17 Mar 2014 14:08:37 +0000
Subject: [PATCH 119/309] jQuery:Lets see if we can be JSDoc complete by v1

---
 jquery/jquery.d.ts | 56 +++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 53 insertions(+), 3 deletions(-)

diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 93cb0b999..a7244c069 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -3363,21 +3363,71 @@ interface JQuery {
      */
     closest(selectors: any, context?: Element): any[];
 
+    /**
+     * Get the children of each element in the set of matched elements, including text and comment nodes.
+     */
     contents(): JQuery;
 
+    /**
+     * End the most recent filtering operation in the current chain and return the set of matched elements to its previous state.
+     */
     end(): JQuery;
 
+    /**
+     * Reduce the set of matched elements to the one at the specified index.
+     * 
+     * @param index An integer indicating the 0-based position of the element. OR An integer indicating the position of the element, counting backwards from the last element in the set.
+     *  
+     */
     eq(index: number): JQuery;
 
+    /**
+     * Reduce the set of matched elements to those that match the selector or pass the function's test.
+     * 
+     * @param selector A string containing a selector expression to match the current set of elements against.
+     */
     filter(selector: string): JQuery;
-    filter(func: (index: any) => any): JQuery;
-    filter(element: any): JQuery;
+    /**
+     * Reduce the set of matched elements to those that match the selector or pass the function's test.
+     * 
+     * @param func A function used as a test for each element in the set. this is the current DOM element.
+     */
+    filter(func: (index: number) => any): JQuery;
+    /**
+     * Reduce the set of matched elements to those that match the selector or pass the function's test.
+     * 
+     * @param element An element to match the current set of elements against.
+     */
+    filter(element: Element): JQuery;
+    /**
+     * Reduce the set of matched elements to those that match the selector or pass the function's test.
+     * 
+     * @param obj An existing jQuery object to match the current set of elements against.
+     */
     filter(obj: JQuery): JQuery;
 
+    /**
+     * Get the descendants of each element in the current set of matched elements, filtered by a selector, jQuery object, or element.
+     * 
+     * @param selector A string containing a selector expression to match elements against.
+     */
     find(selector: string): JQuery;
-    find(element: any): JQuery;
+    /**
+     * Get the descendants of each element in the current set of matched elements, filtered by a selector, jQuery object, or element.
+     * 
+     * @param element An element to match elements against.
+     */
+    find(element: Element): JQuery;
+    /**
+     * Get the descendants of each element in the current set of matched elements, filtered by a selector, jQuery object, or element.
+     * 
+     * @param obj A jQuery object to match elements against.
+     */
     find(obj: JQuery): JQuery;
 
+    /**
+     * Reduce the set of matched elements to the first in the set.
+     */
     first(): JQuery;
 
     has(selector: string): JQuery;

From 09e0ce15f412d99ac645880513d632ba53ed510e Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Mon, 17 Mar 2014 14:16:29 +0000
Subject: [PATCH 120/309] jQuery: JSDoc get's closer

---
 jquery/jquery.d.ts | 44 +++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 41 insertions(+), 3 deletions(-)

diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index a7244c069..0ce282b63 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -3430,17 +3430,55 @@ interface JQuery {
      */
     first(): JQuery;
 
+    /**
+     * Reduce the set of matched elements to those that have a descendant that matches the selector or DOM element.
+     * 
+     * @param selector A string containing a selector expression to match elements against.
+     */
     has(selector: string): JQuery;
+    /**
+     * Reduce the set of matched elements to those that have a descendant that matches the selector or DOM element.
+     * 
+     * @param contained A DOM element to match elements against.
+     */
     has(contained: Element): JQuery;
 
+    /**
+     * Check the current matched set of elements against a selector, element, or jQuery object and return true if at least one of these elements matches the given arguments.
+     * 
+     * @param selector A string containing a selector expression to match elements against.
+     */
     is(selector: string): boolean;
-    is(func: (index: any) => any): boolean;
-    is(element: any): boolean;
+    /**
+     * Check the current matched set of elements against a selector, element, or jQuery object and return true if at least one of these elements matches the given arguments.
+     * 
+     * @param func A function used as a test for the set of elements. It accepts one argument, index, which is the element's index in the jQuery collection.Within the function, this refers to the current DOM element.
+     */
+    is(func: (index: number) => any): boolean;
+    /**
+     * Check the current matched set of elements against a selector, element, or jQuery object and return true if at least one of these elements matches the given arguments.
+     * 
+     * @param obj An existing jQuery object to match the current set of elements against.
+     */
     is(obj: JQuery): boolean;
+    /**
+     * Check the current matched set of elements against a selector, element, or jQuery object and return true if at least one of these elements matches the given arguments.
+     * 
+     * @param elements One or more elements to match the current set of elements against.
+     */
+    is(elements: any): boolean;
 
+    /**
+     * Reduce the set of matched elements to the final one in the set.
+     */
     last(): JQuery;
 
-    map(callback: (index: any, domElement: Element) => any): JQuery;
+    /**
+     * Pass each element in the current matched set through a function, producing a new jQuery object containing the return values.
+     * 
+     * @param callback A function object that will be invoked for each element in the current set.
+     */
+    map(callback: (index: number, domElement: Element) => any): JQuery;
 
     next(selector?: string): JQuery;
 

From f48f188c6c78d6808b505cb902a6a517e6fc5dcb Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Mon, 17 Mar 2014 14:25:38 +0000
Subject: [PATCH 121/309] jQuery: coming on

---
 jquery/jquery-tests.ts | 16 +++++++++++++
 jquery/jquery.d.ts     | 52 ++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 66 insertions(+), 2 deletions(-)

diff --git a/jquery/jquery-tests.ts b/jquery/jquery-tests.ts
index ad7a9444c..f3ba6d82c 100644
--- a/jquery/jquery-tests.ts
+++ b/jquery/jquery-tests.ts
@@ -3169,6 +3169,22 @@ function test_parseHTML() {
 	  .appendTo( $log );
 }
 
+function test_not() {
+    $("li").not(":even").css("background-color", "red");
+
+    $("li").not(document.getElementById("notli"))
+        .css("background-color", "red");
+
+    $("div").not(".green, #blueone")
+        .css("border-color", "red");
+
+    $("p").not($("#selected")[0]);
+
+    $("p").not("#selected");
+
+    $("p").not($("div p.selected"));
+}
+
 function test_EventIsNewable() {
     var ev = new jQuery.Event('click');
 }
diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 0ce282b63..5eb2086fe 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -3480,17 +3480,65 @@ interface JQuery {
      */
     map(callback: (index: number, domElement: Element) => any): JQuery;
 
+    /**
+     * Get the immediately following sibling of each element in the set of matched elements. If a selector is provided, it retrieves the next sibling only if it matches that selector.
+     * 
+     * @param selector A string containing a selector expression to match elements against.
+     */
     next(selector?: string): JQuery;
 
+    /**
+     * Get all following siblings of each element in the set of matched elements, optionally filtered by a selector.
+     * 
+     * @param selector A string containing a selector expression to match elements against.
+     */
     nextAll(selector?: string): JQuery;
 
+    /**
+     * Get all following siblings of each element up to but not including the element matched by the selector, DOM node, or jQuery object passed.
+     * 
+     * @param selector A string containing a selector expression to indicate where to stop matching following sibling elements.
+     * @param filter A string containing a selector expression to match elements against.
+     */
     nextUntil(selector?: string, filter?: string): JQuery;
+    /**
+     * Get all following siblings of each element up to but not including the element matched by the selector, DOM node, or jQuery object passed.
+     * 
+     * @param element A DOM node or jQuery object indicating where to stop matching following sibling elements.
+     * @param filter A string containing a selector expression to match elements against.
+     */
     nextUntil(element?: Element, filter?: string): JQuery;
+    /**
+     * Get all following siblings of each element up to but not including the element matched by the selector, DOM node, or jQuery object passed.
+     * 
+     * @param obj A DOM node or jQuery object indicating where to stop matching following sibling elements.
+     * @param filter A string containing a selector expression to match elements against.
+     */
     nextUntil(obj?: JQuery, filter?: string): JQuery;
 
+    /**
+     * Remove elements from the set of matched elements.
+     * 
+     * @param selector A string containing a selector expression to match elements against.
+     */
     not(selector: string): JQuery;
-    not(func: (index: any) => any): JQuery;
-    not(element: any): JQuery;
+    /**
+     * Remove elements from the set of matched elements.
+     * 
+     * @param func A function used as a test for each element in the set. this is the current DOM element.
+     */
+    not(func: (index: number) => any): JQuery;
+    /**
+     * Remove elements from the set of matched elements.
+     * 
+     * @param elements One or more DOM elements to remove from the matched set.
+     */
+    not(...elements: Element[]): JQuery;
+    /**
+     * Remove elements from the set of matched elements.
+     * 
+     * @param obj An existing jQuery object to match the current set of elements against.
+     */
     not(obj: JQuery): JQuery;
 
     offsetParent(): JQuery;

From b18a971c9a6cfebbe9adb89b372b69135d4465cb Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Mon, 17 Mar 2014 14:39:08 +0000
Subject: [PATCH 122/309] jQuery: are we there yet?

---
 jquery/jquery-tests.ts |  31 ++++++++++++
 jquery/jquery.d.ts     | 105 +++++++++++++++++++++++++++++++++++++++--
 2 files changed, 132 insertions(+), 4 deletions(-)

diff --git a/jquery/jquery-tests.ts b/jquery/jquery-tests.ts
index f3ba6d82c..e4d96fa92 100644
--- a/jquery/jquery-tests.ts
+++ b/jquery/jquery-tests.ts
@@ -2272,6 +2272,37 @@ function test_scrollTop() {
     $("div.demo").scrollTop(300);
 }
 
+function test_parent() {
+    $("*", document.body).each(function () {
+        var parentTag = $(this).parent().get(0).tagName;
+        $(this).prepend(document.createTextNode(parentTag + " > "));
+    });
+    $("p").parent(".selected").css("background", "yellow");
+}
+
+function test_parents() {
+    var parentEls = $("b").parents()
+        .map(function () {
+            return this.tagName;
+        })
+        .get()
+        .join(", ");
+    $("b").append("<strong>" + parentEls + "</strong>");
+
+    function showParents() {
+        $("div").css("border-color", "white");
+        var len = $("span.selected")
+            .parents("div")
+            .css("border", "2px red solid")
+            .length;
+        $("b").text("Unique div parents: " + len);
+    }
+    $("span").click(function () {
+        $(this).toggleClass("selected");
+        showParents();
+    });
+}
+
 function test_param() {
 
     function test1() {
diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 5eb2086fe..7661edc8e 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -3541,33 +3541,130 @@ interface JQuery {
      */
     not(obj: JQuery): JQuery;
 
+    /**
+     * Get the closest ancestor element that is positioned.
+     */
     offsetParent(): JQuery;
 
+    /**
+     * Get the parent of each element in the current set of matched elements, optionally filtered by a selector.
+     * 
+     * @param selector A string containing a selector expression to match elements against.
+     */
     parent(selector?: string): JQuery;
 
+    /**
+     * Get the ancestors of each element in the current set of matched elements, optionally filtered by a selector.
+     * 
+     * @param selector A string containing a selector expression to match elements against.
+     */
     parents(selector?: string): JQuery;
 
+    /**
+     * Get the ancestors of each element in the current set of matched elements, up to but not including the element matched by the selector, DOM node, or jQuery object.
+     * 
+     * @param selector A string containing a selector expression to indicate where to stop matching ancestor elements.
+     * @param filter A string containing a selector expression to match elements against.
+     */
     parentsUntil(selector?: string, filter?: string): JQuery;
+    /**
+     * Get the ancestors of each element in the current set of matched elements, up to but not including the element matched by the selector, DOM node, or jQuery object.
+     * 
+     * @param element A DOM node or jQuery object indicating where to stop matching ancestor elements.
+     * @param filter A string containing a selector expression to match elements against.
+     */
     parentsUntil(element?: Element, filter?: string): JQuery;
+    /**
+     * Get the ancestors of each element in the current set of matched elements, up to but not including the element matched by the selector, DOM node, or jQuery object.
+     * 
+     * @param obj A DOM node or jQuery object indicating where to stop matching ancestor elements.
+     * @param filter A string containing a selector expression to match elements against.
+     */
     parentsUntil(obj?: JQuery, filter?: string): JQuery;
 
+    /**
+     * Get the immediately preceding sibling of each element in the set of matched elements, optionally filtered by a selector.
+     * 
+     * @param selector A string containing a selector expression to match elements against.
+     */
     prev(selector?: string): JQuery;
 
+    /**
+     * Get all preceding siblings of each element in the set of matched elements, optionally filtered by a selector.
+     * 
+     * @param selector A string containing a selector expression to match elements against.
+     */
     prevAll(selector?: string): JQuery;
 
+    /**
+     * Get all preceding siblings of each element up to but not including the element matched by the selector, DOM node, or jQuery object.
+     * 
+     * @param selector A string containing a selector expression to indicate where to stop matching preceding sibling elements.
+     * @param filter A string containing a selector expression to match elements against.
+     */
     prevUntil(selector?: string, filter?: string): JQuery;
+    /**
+     * Get all preceding siblings of each element up to but not including the element matched by the selector, DOM node, or jQuery object.
+     * 
+     * @param element A DOM node or jQuery object indicating where to stop matching preceding sibling elements.
+     * @param filter A string containing a selector expression to match elements against.
+     */
     prevUntil(element?: Element, filter?: string): JQuery;
+    /**
+     * Get all preceding siblings of each element up to but not including the element matched by the selector, DOM node, or jQuery object.
+     * 
+     * @param obj A DOM node or jQuery object indicating where to stop matching preceding sibling elements.
+     * @param filter A string containing a selector expression to match elements against.
+     */
     prevUntil(obj?: JQuery, filter?: string): JQuery;
 
+    /**
+     * Get the siblings of each element in the set of matched elements, optionally filtered by a selector.
+     * 
+     * @param selector A string containing a selector expression to match elements against.
+     */
     siblings(selector?: string): JQuery;
 
+    /**
+     * Reduce the set of matched elements to a subset specified by a range of indices.
+     * 
+     * @param start An integer indicating the 0-based position at which the elements begin to be selected. If negative, it indicates an offset from the end of the set.
+     * @param end An integer indicating the 0-based position at which the elements stop being selected. If negative, it indicates an offset from the end of the set. If omitted, the range continues until the end of the set.
+     */
     slice(start: number, end?: number): JQuery;
 
-    // Utilities
-
+    /**
+     * Show the queue of functions to be executed on the matched elements.
+     * 
+     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
+     */
     queue(queueName?: string): any[];
-    queue(queueName: string, newQueueOrCallback: any): JQuery;
-    queue(newQueueOrCallback: any): JQuery;
+    /**
+     * Manipulate the queue of functions to be executed, once for each matched element.
+     * 
+     * @param newQueue An array of functions to replace the current queue contents.
+     */
+    queue(newQueue: Function[]): JQuery;
+    /**
+     * Manipulate the queue of functions to be executed, once for each matched element.
+     * 
+     * @param callback The new function to add to the queue, with a function to call that will dequeue the next item.
+     */
+    queue(callback: Function): JQuery;
+    /**
+     * Manipulate the queue of functions to be executed, once for each matched element.
+     * 
+     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
+     * @param newQueue An array of functions to replace the current queue contents.
+     */
+    queue(queueName: string, newQueue: Function[]): JQuery;
+    /**
+     * Manipulate the queue of functions to be executed, once for each matched element.
+     * 
+     * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue.
+     * @param callback The new function to add to the queue, with a function to call that will dequeue the next item.
+     */
+    queue(queueName: string, callback: Function): JQuery;
 }
 declare module "jquery" {
     export = $;

From 0ad019b0067a263ab6c85f38df22b48b9d1c90e5 Mon Sep 17 00:00:00 2001
From: Mike H Hawley <mikehhawley@gmail.com>
Date: Mon, 17 Mar 2014 17:53:12 +0300
Subject: [PATCH 123/309] smoothie: fix streamTo comment

---
 smoothie/smoothie.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/smoothie/smoothie.d.ts b/smoothie/smoothie.d.ts
index cc0b82d38..3353c3dbf 100644
--- a/smoothie/smoothie.d.ts
+++ b/smoothie/smoothie.d.ts
@@ -162,7 +162,7 @@ declare module "smoothie"
          * Instructs the <code>SmoothieChart</code> to start rendering to the provided canvas, with specified delay.
          *
          * @param canvas the target canvas element
-         * @param [delayMillis] an amount of time to wait before a data point is shown. This can prevent the end of the series
+         * @param delayMillis an amount of time to wait before a data point is shown. This can prevent the end of the series
          * from appearing on screen, with new values flashing into view, at the expense of some latency.
          */
         streamTo(canvas: HTMLCanvasElement, delayMillis?: number): void;

From 23c057e2431b24c1504add5c1083648ed05ca485 Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Mon, 17 Mar 2014 15:00:39 +0000
Subject: [PATCH 124/309] jQuery: Promises promises

---
 jquery/jquery.d.ts | 86 ++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 72 insertions(+), 14 deletions(-)

diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 7661edc8e..81600af7f 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -297,35 +297,93 @@ interface JQueryPromise<T> {
     Interface for the JQuery deferred, part of callbacks
 */
 interface JQueryDeferred<T> extends JQueryPromise<T> {
-    // Generic versions of callbacks
-    always(...alwaysCallbacks: T[]): JQueryDeferred<T>;
-    done(...doneCallbacks: T[]): JQueryDeferred<T>;
-    fail(...failCallbacks: T[]): JQueryDeferred<T>;
+    /**
+     * Add handlers to be called when the Deferred object is either resolved or rejected.
+     * 
+     * @param alwaysCallbacks1 A function, or array of functions, that is called when the Deferred is resolved or rejected.
+     * @param alwaysCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved or rejected.
+     */
+    always(alwaysCallbacks1: T, ...alwaysCallbacks2: T[]): JQueryDeferred<T>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved.
+     * 
+     * @param doneCallbacks1 A function, or array of functions, that are called when the Deferred is resolved.
+     * @param doneCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved.
+     */
+    done(doneCallbacks1: T, ...doneCallbacks2: T[]): JQueryDeferred<T>;
+    /**
+     * Add handlers to be called when the Deferred object is rejected.
+     * 
+     * @param failCallbacks1 A function, or array of functions, that are called when the Deferred is rejected.
+     * @param failCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is rejected.
+     */
+    fail(failCallbacks1: T, ...failCallbacks2: T[]): JQueryDeferred<T>;
+    /**
+     * Add handlers to be called when the Deferred object generates progress notifications.
+     * 
+     * @param progressCallbacks A function, or array of functions, to be called when the Deferred generates progress notifications.
+     */
     progress(...progressCallbacks: T[]): JQueryDeferred<T>;
 
-    always(...alwaysCallbacks: any[]): JQueryDeferred<T>;
-    done(...doneCallbacks: any[]): JQueryDeferred<T>;
-    fail(...failCallbacks: any[]): JQueryDeferred<T>;
-    progress(...progressCallbacks: any[]): JQueryDeferred<T>;
-
+    /**
+     * Call the progressCallbacks on a Deferred object with the given args.
+     * 
+     * @param args Optional arguments that are passed to the progressCallbacks.
+     */
     notify(...args: any[]): JQueryDeferred<T>;
+
+    /**
+     * Call the progressCallbacks on a Deferred object with the given context and args.
+     * 
+     * @param context Context passed to the progressCallbacks as the this object.
+     * @param args Optional arguments that are passed to the progressCallbacks.
+     */
     notifyWith(context: any, ...args: any[]): JQueryDeferred<T>;
 
+    /**
+     * Reject a Deferred object and call any failCallbacks with the given args.
+     * 
+     * @param args Optional arguments that are passed to the failCallbacks.
+     */
     reject(...args: any[]): JQueryDeferred<T>;
+    /**
+     * Reject a Deferred object and call any failCallbacks with the given context and args.
+     * 
+     * @param context Context passed to the failCallbacks as the this object.
+     * @param args An optional array of arguments that are passed to the failCallbacks.
+     */
     rejectWith(context: any, ...args: any[]): JQueryDeferred<T>;
 
-    resolve(val: T): JQueryDeferred<T>;
+    /**
+     * Resolve a Deferred object and call any doneCallbacks with the given args.
+     * 
+     * @param args Optional arguments that are passed to the doneCallbacks.
+     */
     resolve(...args: any[]): JQueryDeferred<T>;
+
+    /**
+     * Resolve a Deferred object and call any doneCallbacks with the given context and args.
+     * 
+     * @param context Context passed to the doneCallbacks as the this object.
+     * @param args An optional array of arguments that are passed to the doneCallbacks.
+     */
     resolveWith(context: any, ...args: any[]): JQueryDeferred<T>;
+    /**
+     * Determine the current state of a Deferred object.
+     */
     state(): string;
 
+    /**
+     * Return a Deferred's Promise object.
+     * 
+     * @param target Object onto which the promise methods have to be attached
+     */
     promise(target?: any): JQueryPromise<T>;
 }
 
-/*
-    Interface of the JQuery extension of the W3C event object
-*/
-
+/**
+ * Interface of the JQuery extension of the W3C event object
+ */
 interface BaseJQueryEventObject extends Event {
     data: any;
     delegateTarget: Element;

From ee580ff30389949110cdf192ada091e244355540 Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Mon, 17 Mar 2014 15:26:53 +0000
Subject: [PATCH 125/309] jQuery: As promised

---
 jquery/jquery.d.ts | 174 ++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 148 insertions(+), 26 deletions(-)

diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 81600af7f..7e6c79cb3 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -253,49 +253,171 @@ interface JQueryCallback {
     remove(callbacks: Function[]): JQueryCallback;
 }
 
-/*
-    Allows jQuery Promises to interop with non-jQuery promises
-*/
+/**
+ * Allows jQuery Promises to interop with non-jQuery promises
+ */
 interface JQueryGenericPromise<T> {
-    then<U>(onFulfill: (value: T) => U, onReject?: (reason: any) => U): JQueryGenericPromise<U>;
-    then<U>(onFulfill: (value: T) => JQueryGenericPromise<U>, onReject?: (reason: any) => U): JQueryGenericPromise<U>;
-    then<U>(onFulfill: (value: T) => U, onReject?: (reason: any) => JQueryGenericPromise<U>): JQueryGenericPromise<U>;
-    then<U>(onFulfill: (value: T) => JQueryGenericPromise<U>, onReject?: (reason: any) => JQueryGenericPromise<U>): JQueryGenericPromise<U>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+     * 
+     * @param doneFilter A function that is called when the Deferred is resolved.
+     * @param failFilter An optional function that is called when the Deferred is rejected.
+     */
+    then<U>(doneFilter: (value: T) => U, failFilter?: (reason: any) => U): JQueryGenericPromise<U>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+     * 
+     * @param doneFilter A function that is called when the Deferred is resolved.
+     * @param failFilter An optional function that is called when the Deferred is rejected.
+     */
+    then<U>(doneFilter: (value: T) => JQueryGenericPromise<U>, failFilter?: (reason: any) => U): JQueryGenericPromise<U>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+     * 
+     * @param doneFilter A function that is called when the Deferred is resolved.
+     * @param failFilter An optional function that is called when the Deferred is rejected.
+     */
+    then<U>(doneFilter: (value: T) => U, failFilter?: (reason: any) => JQueryGenericPromise<U>): JQueryGenericPromise<U>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+     * 
+     * @param doneFilter A function that is called when the Deferred is resolved.
+     * @param failFilter An optional function that is called when the Deferred is rejected.
+     */
+    then<U>(doneFilter: (value: T) => JQueryGenericPromise<U>, failFilter?: (reason: any) => JQueryGenericPromise<U>): JQueryGenericPromise<U>;
 }
 
-/*
-    Interface for the JQuery promise, part of callbacks
-*/
+/**
+ * Interface for the JQuery promise, part of callbacks
+ */
 interface JQueryPromise<T> {
-    // Generic versions of callbacks
-    always(...alwaysCallbacks: T[]): JQueryPromise<T>;
-    done(...doneCallbacks: T[]): JQueryPromise<T>;
-    fail(...failCallbacks: T[]): JQueryPromise<T>;
-    progress(...progressCallbacks: T[]): JQueryPromise<T>;
+    /**
+     * Add handlers to be called when the Deferred object is either resolved or rejected.
+     * 
+     * @param alwaysCallbacks1 A function, or array of functions, that is called when the Deferred is resolved or rejected.
+     * @param alwaysCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved or rejected.
+     */
+    always(alwaysCallbacks1: T, ...alwaysCallbacks2: T[]): JQueryDeferred<T>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved.
+     * 
+     * @param doneCallbacks1 A function, or array of functions, that are called when the Deferred is resolved.
+     * @param doneCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved.
+     */
+    done(doneCallbacks1: T, ...doneCallbacks2: T[]): JQueryDeferred<T>;
+    /**
+     * Add handlers to be called when the Deferred object is rejected.
+     * 
+     * @param failCallbacks1 A function, or array of functions, that are called when the Deferred is rejected.
+     * @param failCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is rejected.
+     */
+    fail(failCallbacks1: T, ...failCallbacks2: T[]): JQueryDeferred<T>;
+    /**
+     * Add handlers to be called when the Deferred object generates progress notifications.
+     * 
+     * @param progressCallbacks A function, or array of functions, to be called when the Deferred generates progress notifications.
+     */
+    progress(...progressCallbacks: T[]): JQueryDeferred<T>;
 
+    /**
+     * Add handlers to be called when the Deferred object is either resolved or rejected.
+     * 
+     * @param alwaysCallbacks A function, or array of functions, that is called when the Deferred is resolved or rejected.
+     */
     always(...alwaysCallbacks: any[]): JQueryPromise<T>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved.
+     * 
+     * @param doneCallbacks A function, or array of functions, that are called when the Deferred is resolved.
+     */
     done(...doneCallbacks: any[]): JQueryPromise<T>;
+    /**
+     * Add handlers to be called when the Deferred object is rejected.
+     * 
+     * @param failCallbacks A function, or array of functions, that are called when the Deferred is rejected.
+     */
     fail(...failCallbacks: any[]): JQueryPromise<T>;
+    /**
+     * Add handlers to be called when the Deferred object generates progress notifications.
+     * 
+     * @param progressCallbacks A function, or array of functions, to be called when the Deferred generates progress notifications.
+     */
     progress(...progressCallbacks: any[]): JQueryPromise<T>;
 
     // Deprecated - given no typings
     pipe(doneFilter?: (x: any) => any, failFilter?: (x: any) => any, progressFilter?: (x: any) => any): JQueryPromise<any>;
 
-    then<U>(onFulfill: (value: T) => U, onReject?: (...reasons: any[]) => U, onProgress?: (...progression: any[]) => any): JQueryPromise<U>;
-    then<U>(onFulfill: (value: T) => JQueryGenericPromise<U>, onReject?: (...reasons: any[]) => U, onProgress?: (...progression: any[]) => any): JQueryPromise<U>;
-    then<U>(onFulfill: (value: T) => U, onReject?: (...reasons: any[]) => JQueryGenericPromise<U>, onProgress?: (...progression: any[]) => any): JQueryPromise<U>;
-    then<U>(onFulfill: (value: T) => JQueryGenericPromise<U>, onReject?: (...reasons: any[]) => JQueryGenericPromise<U>, onProgress?: (...progression: any[]) => any): JQueryPromise<U>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+     * 
+     * @param doneFilter A function that is called when the Deferred is resolved.
+     * @param failFilter An optional function that is called when the Deferred is rejected.
+     * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+     */
+    then<U>(doneFilter: (value: T) => U, failFilter?: (...reasons: any[]) => U, progressFilter?: (...progression: any[]) => any): JQueryPromise<U>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+     * 
+     * @param doneFilter A function that is called when the Deferred is resolved.
+     * @param failFilter An optional function that is called when the Deferred is rejected.
+     * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+     */
+    then<U>(doneFilter: (value: T) => JQueryGenericPromise<U>, failFilter?: (...reasons: any[]) => U, progressFilter?: (...progression: any[]) => any): JQueryPromise<U>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+     * 
+     * @param doneFilter A function that is called when the Deferred is resolved.
+     * @param failFilter An optional function that is called when the Deferred is rejected.
+     * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+     */
+    then<U>(doneFilter: (value: T) => U, failFilter?: (...reasons: any[]) => JQueryGenericPromise<U>, progressFilter?: (...progression: any[]) => any): JQueryPromise<U>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+     * 
+     * @param doneFilter A function that is called when the Deferred is resolved.
+     * @param failFilter An optional function that is called when the Deferred is rejected.
+     * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+     */
+    then<U>(doneFilter: (value: T) => JQueryGenericPromise<U>, failFilter?: (...reasons: any[]) => JQueryGenericPromise<U>, progressFilter?: (...progression: any[]) => any): JQueryPromise<U>;
 
     // Because JQuery Promises Suck
-    then<U>(onFulfill: (...values: any[]) => U, onReject?: (...reasons: any[]) => U, onProgress?: (...progression: any[]) => any): JQueryPromise<U>;
-    then<U>(onFulfill: (...values: any[]) => JQueryGenericPromise<U>, onReject?: (...reasons: any[]) => U, onProgress?: (...progression: any[]) => any): JQueryPromise<U>;
-    then<U>(onFulfill: (...values: any[]) => U, onReject?: (...reasons: any[]) => JQueryGenericPromise<U>, onProgress?: (...progression: any[]) => any): JQueryPromise<U>;
-    then<U>(onFulfill: (...values: any[]) => JQueryGenericPromise<U>, onReject?: (...reasons: any[]) => JQueryGenericPromise<U>, onProgress?: (...progression: any[]) => any): JQueryPromise<U>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+     * 
+     * @param doneFilter A function that is called when the Deferred is resolved.
+     * @param failFilter An optional function that is called when the Deferred is rejected.
+     * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+     */
+    then<U>(doneFilter: (...values: any[]) => U, failFilter?: (...reasons: any[]) => U, progressFilter?: (...progression: any[]) => any): JQueryPromise<U>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+     * 
+     * @param doneFilter A function that is called when the Deferred is resolved.
+     * @param failFilter An optional function that is called when the Deferred is rejected.
+     * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+     */
+    then<U>(doneFilter: (...values: any[]) => JQueryGenericPromise<U>, failFilter?: (...reasons: any[]) => U, progressFilter?: (...progression: any[]) => any): JQueryPromise<U>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+     * 
+     * @param doneFilter A function that is called when the Deferred is resolved.
+     * @param failFilter An optional function that is called when the Deferred is rejected.
+     * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+     */
+    then<U>(doneFilter: (...values: any[]) => U, failFilter?: (...reasons: any[]) => JQueryGenericPromise<U>, progressFilter?: (...progression: any[]) => any): JQueryPromise<U>;
+    /**
+     * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress.
+     * 
+     * @param doneFilter A function that is called when the Deferred is resolved.
+     * @param failFilter An optional function that is called when the Deferred is rejected.
+     * @param progressFilter An optional function that is called when progress notifications are sent to the Deferred.
+     */
+    then<U>(doneFilter: (...values: any[]) => JQueryGenericPromise<U>, failFilter?: (...reasons: any[]) => JQueryGenericPromise<U>, progressFilter?: (...progression: any[]) => any): JQueryPromise<U>;
 }
 
-/*
-    Interface for the JQuery deferred, part of callbacks
-*/
+/**
+ * Interface for the JQuery deferred, part of callbacks
+ */
 interface JQueryDeferred<T> extends JQueryPromise<T> {
     /**
      * Add handlers to be called when the Deferred object is either resolved or rejected.

From 0a9851d2ecbca4ae47a1d4a84340863f1183e5e3 Mon Sep 17 00:00:00 2001
From: asaveliev <asaveliev@users.noreply.github.com>
Date: Mon, 17 Mar 2014 12:56:31 -0400
Subject: [PATCH 126/309] Changed IGridOptions.data property to be any type

Curreng ng-grid documentation incorrectly lists out the possible data option values - it's actually either string or object reference. See https://github.com/angular-ui/ng-grid/issues/1033#issuecomment-37218058
---
 ng-grid/ng-grid.d.ts | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/ng-grid/ng-grid.d.ts b/ng-grid/ng-grid.d.ts
index f081b362c..cbb0f62ce 100644
--- a/ng-grid/ng-grid.d.ts
+++ b/ng-grid/ng-grid.d.ts
@@ -36,8 +36,10 @@ declare module ngGrid {
         /** definitions of columns as an array [], if not defined columns are auto-generated. See github wiki for more details. */
         columnDefs?: IColumnDef[];
 
-        /** Data being displayed in the grid. Each item in the array is mapped to a row being displayed. */
-        data?: any[];
+        /** Data being displayed in the grid. This can be either a string of object ID or object reference.
+            Using string is preferred, as this turns on change tracking in ng-grid
+        */
+        data?: any;
 
         /** Data updated callback, fires every time the data is modified from outside the grid. */
         dataUpdated?: Function;

From ec927272fac5ec32b5f7c858b8a5ef72a25e55bb Mon Sep 17 00:00:00 2001
From: Blake Niemyjski <bniemyjski@gmail.com>
Date: Mon, 17 Mar 2014 15:30:00 -0500
Subject: [PATCH 127/309] Please stop changing the todayBtn type...

$('#start').datepicker({
                startDate: new Date(2013, 0, 0),
                endDate: moment().startOf('day').toDate(),
                todayBtn: 'linked'
            })
---
 bootstrap.datepicker/bootstrap.datepicker.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bootstrap.datepicker/bootstrap.datepicker.d.ts b/bootstrap.datepicker/bootstrap.datepicker.d.ts
index 40d769b03..41f2fcd25 100644
--- a/bootstrap.datepicker/bootstrap.datepicker.d.ts
+++ b/bootstrap.datepicker/bootstrap.datepicker.d.ts
@@ -12,7 +12,7 @@ interface DatepickerOptions {
     endDate?: any;
     autoclose?: boolean;
     startView?: number;
-    todayBtn?: boolean;
+    todayBtn?: any;
     todayHighlight?: boolean;
     keyboardNavigation?: boolean;
     language?: string;

From 150c745841a6afc7c2a7c3c6cfbb83c1e026a19a Mon Sep 17 00:00:00 2001
From: satoru kimura <s_kimura@sa.il24.net>
Date: Tue, 18 Mar 2014 11:31:01 +0900
Subject: [PATCH 128/309] corrected the description of elapseTime property in
 the Clock class.

---
 threejs/three.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/threejs/three.d.ts b/threejs/three.d.ts
index c39ff721e..3efef93e4 100644
--- a/threejs/three.d.ts
+++ b/threejs/three.d.ts
@@ -459,7 +459,7 @@ declare module THREE {
 
         /**
          * When the clock is running, It holds the time elapsed btween the start of the clock to the previous update.
-         * This counted from the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC.
+         * This parameter is in seconds of three decimal places.
          */
         elapsedTime: number;
 

From b1c7626cba4f53f87c5fd03086f170d8cfe5f4ad Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 18 Mar 2014 09:51:47 +0400
Subject: [PATCH 129/309] Rx.Internals renamed to internals; Added Rx.config
 module.

---
 rx.js/rx.d.ts             | 8 ++++++--
 rx.js/rx.virtualtime.d.ts | 2 +-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index a0f27b1bb..60c7c8634 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -1,11 +1,11 @@
-// Type definitions for RxJS v2.2.13
+// Type definitions for RxJS v2.2.15
 // Project: http://rx.codeplex.com/
 // Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 declare module Rx {
-	export module Internals {
+	export module internals {
 		function isEqual(left: any, right: any): boolean;
 		function inherits(child: Function, parent: Function): Function;
 		function addProperties(obj: Object, ...sourcces: Object[]): void;
@@ -46,6 +46,10 @@ declare module Rx {
 		}
 	}
 
+	export module config {
+		
+	}
+
 	export interface IDisposable {
 		dispose(): void;
 	}
diff --git a/rx.js/rx.virtualtime.d.ts b/rx.js/rx.virtualtime.d.ts
index 376057964..afa398264 100644
--- a/rx.js/rx.virtualtime.d.ts
+++ b/rx.js/rx.virtualtime.d.ts
@@ -27,7 +27,7 @@ declare module Rx {
 		/* protected abstract */ toDateTimeOffset(duetime: TAbsolute): number;
 		/* protected abstract */ toRelative(duetime: number): TRelative;
 
-		/* protected */ getNext(): Internals.ScheduledItem<TAbsolute>;
+		/* protected */ getNext(): internals.ScheduledItem<TAbsolute>;
 	}
 
 	export class HistoricalScheduler extends VirtualTimeScheduler<number, number> {

From 3e29e44ddb330a33a5592780ef172ae746797a51 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 18 Mar 2014 10:31:19 +0400
Subject: [PATCH 130/309] Promises was moved from rx.async.d.ts to rx.d.ts.

---
 rx.js/rx.async.d.ts | 25 -------------------------
 rx.js/rx.d.ts       | 40 +++++++++++++++++++++++++++++++++++++++-
 2 files changed, 39 insertions(+), 26 deletions(-)

diff --git a/rx.js/rx.async.d.ts b/rx.js/rx.async.d.ts
index ef289aa0f..4ac758257 100644
--- a/rx.js/rx.async.d.ts
+++ b/rx.js/rx.async.d.ts
@@ -83,30 +83,5 @@ declare module Rx {
 		fromEvent<T>(element: NodeList, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
 		fromEvent<T>(element: Node, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
         fromEventPattern<T>(addHandler: (handler: Function) => void, removeHandler: (handler: Function) => void, selector?: (arguments: any[])=>T): Observable<T>;
-
-		fromPromise<T>(promise: IPromise<T>): Observable<T>;
-		fromPromise<T>(promise: any): Observable<T>;
-	}
-
-	interface Observable<T> {
-		/**
-		 * Converts an existing observable sequence to an ES6 Compatible Promise
-		 * @example
-		 * var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);
-		 * @param The constructor of the promise
-		 * @returns An ES6 compatible promise with the last value from the observable sequence.
-		 */
-		toPromise<TPromise extends IPromise<T>>(promiseCtor: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): TPromise; }): TPromise;
-		toPromise(promiseCtor: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; }): IPromise<T>;
-	}
-
-	/**
-	 * Promise A+
-	 */
-	export interface IPromise<T> {
-		then<R>(onFulfilled: (value: T) => IPromise<R>, onRejected: (reason: any) => IPromise<R>): IPromise<R>;
-		then<R>(onFulfilled: (value: T) => IPromise<R>, onRejected?: (reason: any) => R): IPromise<R>;
-		then<R>(onFulfilled: (value: T) => R, onRejected: (reason: any) => IPromise<R>): IPromise<R>;
-		then<R>(onFulfilled?: (value: T) => R, onRejected?: (reason: any) => R): IPromise<R>;
 	}
 }
diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index 60c7c8634..2b9a68dc9 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -47,7 +47,7 @@ declare module Rx {
 	}
 
 	export module config {
-		
+		export var Promise: { new <T>(resolve: (value: T) => void, reject: (reason: any) => void): IPromise<T>; };
 	}
 
 	export interface IDisposable {
@@ -189,6 +189,16 @@ declare module Rx {
 		static createOnCompleted<T>(): Notification<T>;
 	}
 
+	/**
+	 * Promise A+
+	 */
+	export interface IPromise<T> {
+		then<R>(onFulfilled: (value: T) => IPromise<R>, onRejected: (reason: any) => IPromise<R>): IPromise<R>;
+		then<R>(onFulfilled: (value: T) => IPromise<R>, onRejected?: (reason: any) => R): IPromise<R>;
+		then<R>(onFulfilled: (value: T) => R, onRejected: (reason: any) => IPromise<R>): IPromise<R>;
+		then<R>(onFulfilled?: (value: T) => R, onRejected?: (reason: any) => R): IPromise<R>;
+	}
+
 	// Observer
 	export class Observer<T> {
 		onNext(value: T): void;
@@ -283,6 +293,27 @@ declare module Rx {
 		takeWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
 		where(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
 		filter(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>; // alias for where
+
+		/**
+		* Converts an existing observable sequence to an ES6 Compatible Promise
+		* @example
+		* var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);
+		* @param promiseCtor The constructor of the promise.
+		* @returns An ES6 compatible promise with the last value from the observable sequence.
+		*/
+		toPromise<TPromise extends IPromise<T>>(promiseCtor: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): TPromise; }): TPromise;
+		/**
+		* Converts an existing observable sequence to an ES6 Compatible Promise
+		* @example
+		* var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);
+		* 
+		* // With config
+		* Rx.config.Promise = RSVP.Promise;
+		* var promise = Rx.Observable.return(42).toPromise();
+		* @param [promiseCtor] The constructor of the promise. If not provided, it looks for it in Rx.config.Promise.
+		* @returns An ES6 compatible promise with the last value from the observable sequence.
+		*/
+		toPromise(promiseCtor?: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; }): IPromise<T>;
 	}
 
 	interface ObservableStatic {
@@ -325,6 +356,13 @@ declare module Rx {
 		zip<T1, T2, T3, T4, T5, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, source4: Observable<T4>, source5: Observable<T5>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TResult): Observable<TResult>;
 		zipArray<T>(...sources: Observable<T>[]): Observable<T[]>;
 		zipArray<T>(sources: Observable<T>[]): Observable<T[]>;
+
+		/**
+		* Converts a Promise to an Observable sequence
+		* @param promise An ES6 Compliant promise.
+		* @returns An Observable sequence which wraps the existing promise success and failure.
+		*/
+		fromPromise<T>(promise: IPromise<T>): Observable<T>;
 	}
 
 	export var Observable: ObservableStatic;

From 920c290ae36adcea961c6ceac1d93e24e0c80fba Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 18 Mar 2014 10:46:14 +0400
Subject: [PATCH 131/309] Fixed definition for Rx.config.Promise; Added test
 for promises;

---
 rx.js/rx.async-tests.ts | 4 ++++
 rx.js/rx.d.ts           | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/rx.js/rx.async-tests.ts b/rx.js/rx.async-tests.ts
index b71f8bd77..9403c7517 100644
--- a/rx.js/rx.async-tests.ts
+++ b/rx.js/rx.async-tests.ts
@@ -66,8 +66,12 @@ module Rx.Tests.Async {
 			new<T>(resolver: (resolvePromise: (value: T)=> void, rejectPromise: (reason: any)=> void)=> void): Rx.IPromise<T>;
 		};
 
+		Rx.config.Promise = promiseImpl;
+
 		var p: IPromise<number> = obsNum.toPromise(promiseImpl);
 
+		p = obsNum.toPromise();
+
 		p = p.then(x=> x);
 		p = p.then(x=> p);
 		p = p.then(undefined, reason=> 10);
diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index 2b9a68dc9..d0dc1eda3 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -47,7 +47,7 @@ declare module Rx {
 	}
 
 	export module config {
-		export var Promise: { new <T>(resolve: (value: T) => void, reject: (reason: any) => void): IPromise<T>; };
+		export var Promise: { new <T>(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; };
 	}
 
 	export interface IDisposable {

From 35e263318a7cdf56b9e5f99568a4d3cee58539a2 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 18 Mar 2014 10:59:20 +0400
Subject: [PATCH 132/309] Added Observable.fromGenerator method.

---
 rx.js/rx.d.ts | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index d0dc1eda3..6d7cec2dd 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -363,6 +363,19 @@ declare module Rx {
 		* @returns An Observable sequence which wraps the existing promise success and failure.
 		*/
 		fromPromise<T>(promise: IPromise<T>): Observable<T>;
+
+		/**
+		* Converts a generator function to an observable sequence, using an optional scheduler to enumerate the generator.
+		* BUG: it have been defined for Observable instance.
+		*  
+		* @example
+		*  var res = Rx.Observable.fromGenerator(function* () { yield 42; });
+		*  var res = Rx.Observable.fromArray(function* () { yield 42; }, Rx.Scheduler.timeout);
+		* @param genFn Generator function.
+		* @param [scheduler] Scheduler to run the enumeration of the input sequence on.
+		* @returns The observable sequence whose elements are pulled from the given generator sequence.
+		*/
+		fromGenerator<T>(genFn: () => { next(): { done: boolean; value?: T; }; }, scheduler?: IScheduler): Observable<T>;
 	}
 
 	export var Observable: ObservableStatic;

From c3d5120566a8c2ecaac438f122fbae21fb3ca655 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 18 Mar 2014 11:38:53 +0400
Subject: [PATCH 133/309] Added overloads of concat and merge taking promises
 instead of observables.

---
 rx.js/rx.d.ts | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index 6d7cec2dd..1ab2d3574 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -233,11 +233,14 @@ declare module Rx {
 		combineLatest<T2, T3, T4, T5, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, fifth: Observable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
 		combineLatest<TOther, TResult>(souces: Observable<TOther>[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
 		concat(...sources: Observable<T>[]): Observable<T>;
+		concat(...sources: IPromise<T>[]): Observable<T>;
 		concat(sources: Observable<T>[]): Observable<T>;
+		concat(sources: IPromise<T>[]): Observable<T>;
 		concatAll(): T;
 		concatObservable(): T;	// alias for concatAll
-		merge(maxConcurrent: number): Observable<T>;
+		merge(maxConcurrent: number): T;
 		merge(other: Observable<T>): Observable<T>;
+		merge(other: IPromise<T>): Observable<T>;
 		mergeAll(): T;
 		mergeObservable(): T;	// alias for mergeAll
 		onErrorResumeNext(second: Observable<T>): Observable<T>;
@@ -342,11 +345,17 @@ declare module Rx {
 		catch<T>(...sources: Observable<T>[]): Observable<T>;
 		catchException<T>(...sources: Observable<T>[]): Observable<T>;	// alias for catch
 		concat<T>(...sources: Observable<T>[]): Observable<T>;
+		concat<T>(...sources: IPromise<T>[]): Observable<T>;
 		concat<T>(sources: Observable<T>[]): Observable<T>;
+		concat<T>(sources: IPromise<T>[]): Observable<T>;
 		merge<T>(...sources: Observable<T>[]): Observable<T>;
+		merge<T>(...sources: IPromise<T>[]): Observable<T>;
 		merge<T>(sources: Observable<T>[]): Observable<T>;
+		merge<T>(sources: IPromise<T>[]): Observable<T>;
 		merge<T>(scheduler: IScheduler, ...sources: Observable<T>[]): Observable<T>;
+		merge<T>(scheduler: IScheduler, ...sources: IPromise<T>[]): Observable<T>;
 		merge<T>(scheduler: IScheduler, sources: Observable<T>[]): Observable<T>;
+		merge<T>(scheduler: IScheduler, sources: IPromise<T>[]): Observable<T>;
 		onErrorResumeNext<T>(...sources: Observable<T>[]): Observable<T>;
 		onErrorResumeNext<T>(sources: Observable<T>[]): Observable<T>;
 		zip<T1, T2, TResult>(first: Observable<T1>, sources: Observable<T2>[], resultSelector: (item1: T1, right: Observable<T2>) => TResult): Observable<TResult>;

From 9664806862ed7943683fbe749713d49398e65bd3 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 18 Mar 2014 11:46:07 +0400
Subject: [PATCH 134/309] Added overloads of `selectMany`/`flatMap` taking
 promises instead of observables.

---
 rx.js/rx.d.ts | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index 1ab2d3574..640fe8ff7 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -245,7 +245,8 @@ declare module Rx {
 		mergeObservable(): T;	// alias for mergeAll
 		onErrorResumeNext(second: Observable<T>): Observable<T>;
 		skipUntil<T2>(other: Observable<T2>): Observable<T>;
-		switchLatest(): T;
+		switch(): T;
+		switchLatest(): T;	// alias for switch
 		takeUntil<T2>(other: Observable<T2>): Observable<T>;
 		zip<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
 		zip<T2, T3, TResult>(second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
@@ -285,11 +286,17 @@ declare module Rx {
 		select<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;
 		map<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;	// alias for select
 		selectMany<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
+		selectMany<TOther, TResult>(selector: (value: T) => IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
 		selectMany<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;
+		selectMany<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>;
 		selectMany<TResult>(other: Observable<TResult>): Observable<TResult>;
+		selectMany<TResult>(other: IPromise<TResult>): Observable<TResult>;
 		flatMap<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;	// alias for selectMany
+		flatMap<TOther, TResult>(selector: (value: T) => IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;	// alias for selectMany
 		flatMap<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;	// alias for selectMany
+		flatMap<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>;	// alias for selectMany
 		flatMap<TResult>(other: Observable<TResult>): Observable<TResult>;	// alias for selectMany
+		flatMap<TResult>(other: IPromise<TResult>): Observable<TResult>;	// alias for selectMany
 		skip(count: number): Observable<T>;
 		skipWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
 		take(count: number, scheduler?: IScheduler): Observable<T>;

From 5c938e56b08df58771158c4f7ff02f7466a626eb Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 18 Mar 2014 11:51:52 +0400
Subject: [PATCH 135/309] Rx-Async: version bump to 2.2.15; added
 `ObservableStatic.startAsync`.

---
 rx.js/rx.async.d.ts | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/rx.js/rx.async.d.ts b/rx.js/rx.async.d.ts
index 4ac758257..70143ff7e 100644
--- a/rx.js/rx.async.d.ts
+++ b/rx.js/rx.async.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Async package 2.2.11
+// Type definitions for RxJS-Async package 2.2.15
 // Project: http://rx.codeplex.com/
 // Definitions by: zoetrope <https://github.com/zoetrope>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
@@ -10,6 +10,13 @@ declare module Rx {
     interface ObservableStatic {
 		start<T>(func: () => T, scheduler?: IScheduler, context?: any): Observable<T>;
 
+		/**
+		* Invokes the asynchronous function, surfacing the result through an observable sequence.
+		* @param functionAsync Asynchronous function which returns a Promise to run.
+		* @returns An observable sequence exposing the function's result value, or an exception.
+		*/
+		startAsync<T>(functionAsync: () => IPromise<T>): Observable<T>;
+
         toAsync<TResult>(func: () => TResult, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
 		toAsync<T1, TResult>(func: (arg1: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
 		toAsync<T1, TResult>(func: (arg1?: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1) => Observable<TResult>;

From 6c4fcd603514d5664cffd0c32d1025231613b8e9 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 18 Mar 2014 11:53:56 +0400
Subject: [PATCH 136/309] Rx-Async: added test for `startAsync`.

---
 rx.js/rx.async-tests.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/rx.js/rx.async-tests.ts b/rx.js/rx.async-tests.ts
index 9403c7517..9c3bce516 100644
--- a/rx.js/rx.async-tests.ts
+++ b/rx.js/rx.async-tests.ts
@@ -81,4 +81,8 @@ module Rx.Tests.Async {
 		ps = p.then(x=> "");
 		ps = p.then(x=> ps);
 	}
+
+	function startAsync() {
+		var o: Rx.Observable<string> = Rx.Observable.startAsync(() => <Rx.IPromise<string>>null);
+	}
 }
\ No newline at end of file

From 7ae46cf1fd3408fe88737c26e23be8fff2b6caa0 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 18 Mar 2014 12:01:02 +0400
Subject: [PATCH 137/309] Fixed headers of RxJS-Async and RxJS-Time.

---
 rx.js/rx.async.d.ts | 2 +-
 rx.js/rx.time.d.ts  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/rx.js/rx.async.d.ts b/rx.js/rx.async.d.ts
index 70143ff7e..19406e9ae 100644
--- a/rx.js/rx.async.d.ts
+++ b/rx.js/rx.async.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Async package 2.2.15
+// Type definitions for RxJS-Async v2.2.15
 // Project: http://rx.codeplex.com/
 // Definitions by: zoetrope <https://github.com/zoetrope>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
diff --git a/rx.js/rx.time.d.ts b/rx.js/rx.time.d.ts
index 013665517..449cdd7f9 100644
--- a/rx.js/rx.time.d.ts
+++ b/rx.js/rx.time.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS "Aggregates"
+// Type definitions for RxJS-Time v2.2.15
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>

From 3a272478dacb005e79e6cb9ec4f1f417c999ba69 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 18 Mar 2014 12:22:51 +0400
Subject: [PATCH 138/309] Added new `RxJS-BackPressure` module defintion. Fixed
 .gitignore to exclude rx.js from ignoring.

---
 .gitignore                 |  3 +++
 rx.js/rx.backpressure.d.ts | 43 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+)
 create mode 100644 rx.js/rx.backpressure.d.ts

diff --git a/.gitignore b/.gitignore
index 8fc575c21..b09429865 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,4 +34,7 @@ Properties
 *.iml
 *.js.map
 
+#rx.js
+!rx.js
+
 node_modules
diff --git a/rx.js/rx.backpressure.d.ts b/rx.js/rx.backpressure.d.ts
new file mode 100644
index 000000000..d09aa91e7
--- /dev/null
+++ b/rx.js/rx.backpressure.d.ts
@@ -0,0 +1,43 @@
+// Type definitions for RxJS-BackPressure v2.2.15
+// Project: http://rx.codeplex.com/
+// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path="rx.d.ts" />
+
+declare module Rx {
+	export interface Observable<T> {
+		/**
+		* Pauses the underlying observable sequence based upon the observable sequence which yields true/false.
+		* @example
+		* var pauser = new Rx.Subject();
+		* var source = Rx.Observable.interval(100).pausable(pauser);
+		* @param pauser The observable sequence used to pause the underlying sequence.
+		* @returns The observable sequence which is paused based upon the pauser.
+		*/
+		pausable(pauser: Observable<boolean>): Observable<T>;
+
+		/**
+		* Pauses the underlying observable sequence based upon the observable sequence which yields true/false,
+		* and yields the values that were buffered while paused.
+		* @example
+		* var pauser = new Rx.Subject();
+		* var source = Rx.Observable.interval(100).pausableBuffered(pauser);
+		* @param pauser The observable sequence used to pause the underlying sequence.
+		* @returns The observable sequence which is paused based upon the pauser.
+		*/
+		pausableBuffered(pauser: Observable<boolean>): Observable<T>;
+
+		/**
+		* Attaches a controller to the observable sequence with the ability to queue.
+		* @example
+		* var source = Rx.Observable.interval(100).controlled();
+		* source.request(3); // Reads 3 values
+		*/
+		controlled(enableQueue?: boolean): ControlledObservable<T>;
+	}
+
+	export interface ControlledObservable<T> extends Observable<T> {
+		request(numberOfItems?: number): IDisposable;
+	}
+}

From 064bcb14a7a279ba8d9976b2f0cf98b240810ed9 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 18 Mar 2014 12:27:51 +0400
Subject: [PATCH 139/309] RxJS-BackPressure: added tests.

---
 rx.js/rx.backpressure-tests.ts | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 rx.js/rx.backpressure-tests.ts

diff --git a/rx.js/rx.backpressure-tests.ts b/rx.js/rx.backpressure-tests.ts
new file mode 100644
index 000000000..f036a1dc3
--- /dev/null
+++ b/rx.js/rx.backpressure-tests.ts
@@ -0,0 +1,22 @@
+// Tests for RxJS-BackPressure TypeScript definitions
+// Tests by Igor Oleinikov <https://github.com/Igorbek>
+
+///<reference path="rx.d.ts" />
+///<reference path="rx.backpressure.d.ts" />
+
+function testPausable() {
+	var o: Rx.Observable<string>;
+
+	var pauser = new Rx.Subject<boolean>();
+
+	var p = o.pausable(pauser);
+	p = o.pausableBuffered(pauser);
+}
+
+function testControlled() {
+	var o: Rx.Observable<string>;
+	var c = o.controlled();
+
+	var d: Rx.IDisposable = c.request();
+	d = c.request(5);
+}

From 8b0c6cab781418268bcee2fadb454925e0b3b67c Mon Sep 17 00:00:00 2001
From: Santi Albo <santialbo@gmail.com>
Date: Tue, 18 Mar 2014 09:32:20 +0000
Subject: [PATCH 140/309] Add restify pre module

---
 restify/restify.d.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/restify/restify.d.ts b/restify/restify.d.ts
index c7ee5b14a..6bcbb5412 100644
--- a/restify/restify.d.ts
+++ b/restify/restify.d.ts
@@ -211,4 +211,10 @@ declare module "restify" {
   export function fullResponse(): RequestHandler;
   export var defaultResponseHeaders : any;
   export var CORS: CORS;
+  
+  export module pre {
+      export function pause(): RequestHandler;
+      export function sanitizePath(options?: any): RequestHandler;
+      export function userAgentConnection(options?: any): RequestHandler;
+  }
 }

From d50f5e11ef431efe09f2b9318b6968fa8e31dd56 Mon Sep 17 00:00:00 2001
From: Santi Albo <santialbo@gmail.com>
Date: Tue, 18 Mar 2014 09:34:39 +0000
Subject: [PATCH 141/309] Add restify pre example of use on the tests

---
 restify/restify-tests.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/restify/restify-tests.ts b/restify/restify-tests.ts
index 329f1e8c3..3ff16da55 100644
--- a/restify/restify-tests.ts
+++ b/restify/restify-tests.ts
@@ -28,6 +28,8 @@ server = restify.createServer({
     responseTimeFormatter : (durationInMilliseconds: number) => {}
 });
 
+server.pre(restify.pre.sanitizePath());
+
 server.on('someEvent', ()=>{});
 
 

From 2102001feaff7d7b80fba35bbc121a88106a7489 Mon Sep 17 00:00:00 2001
From: AbubakerB <abubaker_bashir@hotmail.com>
Date: Tue, 18 Mar 2014 16:37:09 +0000
Subject: [PATCH 142/309] Added signature_pad.d.ts definitions

---
 signature_pad/signature_pad.d.ts | 120 +++++++++++++++++++++++++++++++
 1 file changed, 120 insertions(+)
 create mode 100644 signature_pad/signature_pad.d.ts

diff --git a/signature_pad/signature_pad.d.ts b/signature_pad/signature_pad.d.ts
new file mode 100644
index 000000000..5782b94f0
--- /dev/null
+++ b/signature_pad/signature_pad.d.ts
@@ -0,0 +1,120 @@
+// Type definitions for signature_pad
+// Project: https://github.com/szimek/signature_pad
+// Definitions by: Abubaker Bashir <https://github.com/AbubakerB>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+// Project by: Szymon Nowak <https://github.com/szimek>
+
+declare class Point {
+    x: number;
+    y: number;
+    time: number;
+    constructor(x: number, y: number, time: number);
+    velocityFrom(start: Point): number;
+    distanceTo(start: Point): number;
+}
+
+declare class CurveControl {
+    c1: Point;
+    c2: Point;
+    constructor(c1: Point, c2: Point);
+}
+
+declare class Bezier {
+    startPoint: Point;
+    control1: CurveControl;
+    control2: CurveControl;
+    endPoint: Point;
+    constructor(startPoint, control1, control2, endPoint);
+    length(): number;
+    _point(t: number, start: number, c1: number, c2: number, end: number): number;
+}
+
+declare class SignaturePadOptions {
+    /**
+    *   (float) Weight used to modify new velocity based on the previous velocity. Defaults to 0.7.
+    */
+    velocityFilterWeight: number;
+    /**
+    *   (float) Minimum width of a line. Defaults to 0.5.
+    */
+    minWidth: number;
+    /**
+    *   (float) Maximum width of a line. Defaults to 2.5.
+    */
+    maxWidth: number;
+    /**
+    *   (float or function) Radius of a single dot.
+    */
+    dotSize: Function;
+    /**
+    *   (string) Color used to draw the lines. Can be any color format accepted by context.fillStyle.
+    *   Defaults to "black".
+    */
+    penColor: string;
+    /**
+    *   (string) Color used to clear the background. Can be any color format accepted by context.fillStyle.
+    *   Defaults to "rgba(0,0,0,0)" (transparent black). Use a non-transparent color e.g. "rgb(255,255,255)"
+    *   (opaque white) if you'd like to save signatures as JPEG images.
+    */
+    backgroundColor: string;
+    /**
+    *   (function) Callback when stroke begin.
+    */
+    onEnd: Function;
+    /**
+    *   (function) Callback when stroke end.
+    */
+    onBegin: Function;
+}
+
+declare class SignaturePad {
+    points: Array<Point>;
+    _lastVelocity: number;
+    _lastWidth: number;
+    _isEmpty: boolean;
+    _mouseButtonDown: boolean;
+    _ctx: CanvasRenderingContext2D;
+    _canvas: HTMLCanvasElement;
+    velocityFilterWeight: number;
+    minWidth: number;
+    maxWidth: number;
+    dotSize: Function;
+    penColor: string;
+    backgroundColor: string;
+    onEnd: Function;
+    onBegin: Function;
+
+    constructor(canvas: Element, options?: SignaturePadOptions);
+    /**
+    *   Clears the canvas
+    */
+    clear(): void;
+    /**
+    *   Returns true if canvas is empty, otherwise returns false
+    */
+    isEmpty(): boolean;
+    /**
+    *   Draws signature image from data URL
+    */
+    fromDataURL(dataUrl: string);
+    /**
+    *   Returns signature image as data URL
+    */
+    toDataURL(): string;
+
+    _strokeBegin(event: Event): void;
+    _strokeUpdate(event: Event): void;
+    _strokeDraw(point: Point): void;
+    _strokeEnd(event: Event): void;
+    _handleMouseEvents(): void;
+    _handleTouchEvents(): void;
+    _reset(): void;
+    _createPoint(event: Event): Point;
+    _addPoint(point: Point): void;
+    _calculateCurveControlPoints(point1: Point, point2: Point, point3: Point): void;
+
+    _addCurve(curve: Bezier): void;
+    _drawPoint(x: number, y: number, size: number): void;
+    _drawCurve(curve: Bezier, startWidth: number, endWidth: number): void;
+    _strokeWidth(velocity: number): void;
+}

From 824be6c9bb0e3e9c3e64da6e0376722193db4de1 Mon Sep 17 00:00:00 2001
From: AbubakerB <abubaker_bashir@hotmail.com>
Date: Tue, 18 Mar 2014 17:17:31 +0000
Subject: [PATCH 143/309] Test file for signature_pad

---
 signature_pad/signature_pad-tests.ts | 39 ++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 signature_pad/signature_pad-tests.ts

diff --git a/signature_pad/signature_pad-tests.ts b/signature_pad/signature_pad-tests.ts
new file mode 100644
index 000000000..57c42e7d4
--- /dev/null
+++ b/signature_pad/signature_pad-tests.ts
@@ -0,0 +1,39 @@
+/// <reference path='signature_pad.d.ts'/>
+
+/* TEST 1 - Basic structure and usage */
+function BasicTest() {
+    var canvas = document.querySelector("canvas");
+
+    var signaturePad = new SignaturePad(canvas);
+
+    // Returns signature image as data URL
+    signaturePad.toDataURL();
+
+    // Draws signature image from data URL
+    signaturePad.fromDataURL("data:image/png;base64,iVBORw0K...");
+
+    // Clears the canvas
+    signaturePad.clear();
+
+    // Returns true if canvas is empty, otherwise returns false
+    signaturePad.isEmpty();
+}
+
+/* TEST 2 - You can set options during initialization: */
+function SetDuringInit() {
+    var canvas = document.querySelector("canvas");
+    var signaturePad = new SignaturePad(canvas, {
+        minWidth: 5,
+        maxWidth: 10,
+        penColor: "rgb(66, 133, 244)"
+    });
+}
+
+/* TEST 3 - or during runtime: */
+function RuntimeChange() {
+    var canvas = document.querySelector("canvas");
+    var signaturePad = new SignaturePad(canvas);
+    signaturePad.minWidth = 5;
+    signaturePad.maxWidth = 10;
+    signaturePad.penColor = "rgb(66, 133, 244)";
+}

From ee22143b5746c2a7f1f10ab8fc9bc5d00a170280 Mon Sep 17 00:00:00 2001
From: Dasa Paddock <dpaddock@esri.com>
Date: Tue, 18 Mar 2014 11:38:14 -0700
Subject: [PATCH 144/309] Add definitions for 'parallelLimit'.

Doc: https://github.com/caolan/async#parallellimittasks-limit-callback
---
 async/async.d.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/async/async.d.ts b/async/async.d.ts
index 12aa4123f..68f2f192f 100644
--- a/async/async.d.ts
+++ b/async/async.d.ts
@@ -53,6 +53,8 @@ interface Async {
     series<T>(tasks: T, callback?: AsyncMultipleResultsCallback<T>): void;
     parallel<T>(tasks: T[], callback?: AsyncMultipleResultsCallback<T>): void;
     parallel<T>(tasks: T, callback?: AsyncMultipleResultsCallback<T>): void;
+    parallelLimit<T>(tasks: T[], limit: number, callback?: AsyncMultipleResultsCallback<T>): void;
+    parallelLimit<T>(tasks: T, limit: number, callback?: AsyncMultipleResultsCallback<T>): void;
     whilst(test: Function, fn: Function, callback: Function): void;
     until(test: Function, fn: Function, callback: Function): void;
     waterfall<T>(tasks: T[], callback?: AsyncMultipleResultsCallback<T>): void;

From 0c2d2f07a7e171483479e882bf88639f2ca07595 Mon Sep 17 00:00:00 2001
From: Abubaker Bashir <abubaker_bashir@hotmail.com>
Date: Tue, 18 Mar 2014 20:51:55 +0000
Subject: [PATCH 145/309] Updated signature_pad.d.ts file

---
 signature_pad/signature_pad.d.ts | 138 ++++++++++++++++---------------
 1 file changed, 70 insertions(+), 68 deletions(-)

diff --git a/signature_pad/signature_pad.d.ts b/signature_pad/signature_pad.d.ts
index 5782b94f0..10d6a03d6 100644
--- a/signature_pad/signature_pad.d.ts
+++ b/signature_pad/signature_pad.d.ts
@@ -4,71 +4,73 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 // Project by: Szymon Nowak <https://github.com/szimek>
 
-declare class Point {
-    x: number;
-    y: number;
-    time: number;
-    constructor(x: number, y: number, time: number);
-    velocityFrom(start: Point): number;
-    distanceTo(start: Point): number;
-}
+declare module SignaturePad {
+	class Point {
+	    x: number;
+	    y: number;
+	    time: number;
+	    constructor(x: number, y: number, time: number);
+	    velocityFrom(start: Point): number;
+	    distanceTo(start: Point): number;
+	}
 
-declare class CurveControl {
-    c1: Point;
-    c2: Point;
-    constructor(c1: Point, c2: Point);
-}
+	class CurveControl {
+	    c1: Point;
+	    c2: Point;
+	    constructor(c1: Point, c2: Point);
+	}
 
-declare class Bezier {
-    startPoint: Point;
-    control1: CurveControl;
-    control2: CurveControl;
-    endPoint: Point;
-    constructor(startPoint, control1, control2, endPoint);
-    length(): number;
-    _point(t: number, start: number, c1: number, c2: number, end: number): number;
-}
+ 	class Bezier {
+	    startPoint: Point;
+	    control1: CurveControl;
+	    control2: CurveControl;
+	    endPoint: Point;
+	    constructor(startPoint: Point, control1: Point, control2: Point, endPoint: Point);
+	    length(): number;
+	    _point(t: number, start: number, c1: number, c2: number, end: number): number;
+	}
 
-declare class SignaturePadOptions {
-    /**
-    *   (float) Weight used to modify new velocity based on the previous velocity. Defaults to 0.7.
-    */
-    velocityFilterWeight: number;
-    /**
-    *   (float) Minimum width of a line. Defaults to 0.5.
-    */
-    minWidth: number;
-    /**
-    *   (float) Maximum width of a line. Defaults to 2.5.
-    */
-    maxWidth: number;
-    /**
-    *   (float or function) Radius of a single dot.
-    */
-    dotSize: Function;
-    /**
-    *   (string) Color used to draw the lines. Can be any color format accepted by context.fillStyle.
-    *   Defaults to "black".
-    */
-    penColor: string;
-    /**
-    *   (string) Color used to clear the background. Can be any color format accepted by context.fillStyle.
-    *   Defaults to "rgba(0,0,0,0)" (transparent black). Use a non-transparent color e.g. "rgb(255,255,255)"
-    *   (opaque white) if you'd like to save signatures as JPEG images.
-    */
-    backgroundColor: string;
-    /**
-    *   (function) Callback when stroke begin.
-    */
-    onEnd: Function;
-    /**
-    *   (function) Callback when stroke end.
-    */
-    onBegin: Function;
+ 	interface SignaturePadOptions {
+	    /**
+	    *   (float) Weight used to modify new velocity based on the previous velocity. Defaults to 0.7.
+	    */
+	    velocityFilterWeight?: number;
+	    /**
+	    *   (float) Minimum width of a line. Defaults to 0.5.
+	    */
+	    minWidth?: number;
+	    /**
+	    *   (float) Maximum width of a line. Defaults to 2.5.
+	    */
+	    maxWidth?: number;
+	    /**
+	    *   (float or function) Radius of a single dot.
+	    */
+	    dotSize?: Function;
+	    /**
+	    *   (string) Color used to draw the lines. Can be any color format accepted by context.fillStyle.
+	    *   Defaults to "black".
+	    */
+	    penColor?: string;
+	    /**
+	    *   (string) Color used to clear the background. Can be any color format accepted by context.fillStyle.
+	    *   Defaults to "rgba(0,0,0,0)" (transparent black). Use a non-transparent color e.g. "rgb(255,255,255)"
+	    *   (opaque white) if you'd like to save signatures as JPEG images.
+	    */
+	    backgroundColor?: string;
+	    /**
+	    *   (function) Callback when stroke begin.
+	    */
+	    onEnd?: Function;
+	    /**
+	    *   (function) Callback when stroke end.
+	    */
+	    onBegin?: Function;
+	}
 }
 
 declare class SignaturePad {
-    points: Array<Point>;
+    points: Array<SignaturePad.Point>;
     _lastVelocity: number;
     _lastWidth: number;
     _isEmpty: boolean;
@@ -84,7 +86,7 @@ declare class SignaturePad {
     onEnd: Function;
     onBegin: Function;
 
-    constructor(canvas: Element, options?: SignaturePadOptions);
+    constructor(canvas: Element, options?: SignaturePad.SignaturePadOptions);
     /**
     *   Clears the canvas
     */
@@ -96,7 +98,7 @@ declare class SignaturePad {
     /**
     *   Draws signature image from data URL
     */
-    fromDataURL(dataUrl: string);
+    fromDataURL(dataUrl: string): void;
     /**
     *   Returns signature image as data URL
     */
@@ -104,17 +106,17 @@ declare class SignaturePad {
 
     _strokeBegin(event: Event): void;
     _strokeUpdate(event: Event): void;
-    _strokeDraw(point: Point): void;
+    _strokeDraw(point: SignaturePad.Point): void;
     _strokeEnd(event: Event): void;
     _handleMouseEvents(): void;
     _handleTouchEvents(): void;
     _reset(): void;
-    _createPoint(event: Event): Point;
-    _addPoint(point: Point): void;
-    _calculateCurveControlPoints(point1: Point, point2: Point, point3: Point): void;
+    _createPoint(event: Event): SignaturePad.Point;
+    _addPoint(point: SignaturePad.Point): void;
+    _calculateCurveControlPoints(point1: SignaturePad.Point, point2: SignaturePad.Point, point3: SignaturePad.Point): void;
 
-    _addCurve(curve: Bezier): void;
+    _addCurve(curve: SignaturePad.Bezier): void;
     _drawPoint(x: number, y: number, size: number): void;
-    _drawCurve(curve: Bezier, startWidth: number, endWidth: number): void;
+    _drawCurve(curve: SignaturePad.Bezier, startWidth: number, endWidth: number): void;
     _strokeWidth(velocity: number): void;
-}
+}
\ No newline at end of file

From 98a0894dffe42cbb37a8ccb39eb7e9efb4fb66ad Mon Sep 17 00:00:00 2001
From: pkaul <peter@girino.de>
Date: Tue, 18 Mar 2014 22:17:58 +0100
Subject: [PATCH 146/309] Adjusting test after changing when.d.ts.

Note: In opposite to other Promise implementation such as" promise-es6" or"Q" the implementation "when.js" is AMD/CommonJS aware und therefore needs to be loaded as an module (e.g. using "requirejs").
---
 promises-a-plus/promises-a-plus-tests.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/promises-a-plus/promises-a-plus-tests.ts b/promises-a-plus/promises-a-plus-tests.ts
index fa1453645..29ca0989b 100644
--- a/promises-a-plus/promises-a-plus-tests.ts
+++ b/promises-a-plus/promises-a-plus-tests.ts
@@ -2,7 +2,8 @@
 /// <reference path="../rx.js/rx.async.d.ts"/>
 /// <reference path="../es6-promises/es6-promises.d.ts"/>
 /// <reference path="../q/Q.d.ts"/>
-/// <reference path="../when/when.d.ts"/>
+import When = require("../when/when");
+
 
 var thenNum: PromisesAPlus.Thenable<number>; 
 var thenStr: PromisesAPlus.Thenable<string>; 

From b6a08def3bc87d24241ae26baf2a2fc6441256a7 Mon Sep 17 00:00:00 2001
From: Scott McArthur <github@scottmcarthur.co.uk>
Date: Tue, 18 Mar 2014 22:36:53 +0000
Subject: [PATCH 147/309] angular.d.ts IDocumentService extends
 IAugmentedJQuery

Updated IDocumentService to extend IAugmentedJQuery rather than Document. As per the API (http://docs.angularjs.org/api/ng.$document) it provides "A jQuery or jqLite wrapper for the browser's window.document object."
---
 angularjs/angular.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/angularjs/angular.d.ts b/angularjs/angular.d.ts
index b7a258be6..4a9f12822 100755
--- a/angularjs/angular.d.ts
+++ b/angularjs/angular.d.ts
@@ -430,7 +430,7 @@ declare module ng {
     // DocumentService
     // see http://docs.angularjs.org/api/ng.$document
     ///////////////////////////////////////////////////////////////////////////
-    interface IDocumentService extends Document {}
+    interface IDocumentService extends IAugmentedJQuery {}
 
     ///////////////////////////////////////////////////////////////////////////
     // ExceptionHandlerService

From dcfb6c9ab4b37886263f6912659fc8fba5430d2c Mon Sep 17 00:00:00 2001
From: satoru kimura <s_kimura@sa.il24.net>
Date: Wed, 19 Mar 2014 13:59:20 +0900
Subject: [PATCH 148/309] corrected some descriptions of the Clock class.

---
 threejs/three.d.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/threejs/three.d.ts b/threejs/three.d.ts
index 3efef93e4..687bb8123 100644
--- a/threejs/three.d.ts
+++ b/threejs/three.d.ts
@@ -458,7 +458,7 @@ declare module THREE {
         oldTime: number;
 
         /**
-         * When the clock is running, It holds the time elapsed btween the start of the clock to the previous update.
+         * When the clock is running, It holds the time elapsed between the start of the clock to the previous update.
          * This parameter is in seconds of three decimal places.
          */
         elapsedTime: number;
@@ -479,12 +479,12 @@ declare module THREE {
         stop(): void;
 
         /**
-         * Get milliseconds passed since the clock started.
+         * Get the seconds passed since the clock started.
          */
         getElapsedTime(): number;
 
         /**
-         * Get the milliseconds passed since the last call to this method.
+         * Get the seconds passed since the last call to this method.
          */
         getDelta(): number;
     }

From 33f2f1440507a19ce61ad43e09dac2614674c75e Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 11:07:17 +0400
Subject: [PATCH 149/309] Renamed Observable.fromGenerator to fromIterable and
 added overload to take iterable. Updated header.

---
 rx.js/rx.d.ts | 26 +++++++++++++++++++-------
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index 640fe8ff7..1100bc618 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS v2.2.15
+// Type definitions for RxJS v2.2.17
 // Project: http://rx.codeplex.com/
 // Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
@@ -381,17 +381,29 @@ declare module Rx {
 		fromPromise<T>(promise: IPromise<T>): Observable<T>;
 
 		/**
-		* Converts a generator function to an observable sequence, using an optional scheduler to enumerate the generator.
-		* BUG: it have been defined for Observable instance.
+		*  Converts an iterable into an Observable sequence
 		*  
 		* @example
-		*  var res = Rx.Observable.fromGenerator(function* () { yield 42; });
-		*  var res = Rx.Observable.fromArray(function* () { yield 42; }, Rx.Scheduler.timeout);
-		* @param genFn Generator function.
+		*  var res = Rx.Observable.fromIterable(new Map());
+		*  var res = Rx.Observable.fromIterable(function* () { yield 42; });
+		*  var res = Rx.Observable.fromIterable(new Set(), Rx.Scheduler.timeout);
+		* @param generator Generator to convert from.
 		* @param [scheduler] Scheduler to run the enumeration of the input sequence on.
 		* @returns The observable sequence whose elements are pulled from the given generator sequence.
 		*/
-		fromGenerator<T>(genFn: () => { next(): { done: boolean; value?: T; }; }, scheduler?: IScheduler): Observable<T>;
+		fromItreable<T>(generator: () => { next(): { done: boolean; value?: T; }; }, scheduler?: IScheduler): Observable<T>;
+
+		/**
+		*  Converts an iterable into an Observable sequence
+		*  
+		* @example
+		*  var res = Rx.Observable.fromIterable(new Map());
+		*  var res = Rx.Observable.fromIterable(new Set(), Rx.Scheduler.timeout);
+		* @param iterable Iterable to convert from.
+		* @param [scheduler] Scheduler to run the enumeration of the input sequence on.
+		* @returns The observable sequence whose elements are pulled from the given generator sequence.
+		*/
+		fromItreable<T>(iterable: {}, scheduler?: IScheduler): Observable<T>;	// todo: can't describe ES6 Iterable via TypeScript type system
 	}
 
 	export var Observable: ObservableStatic;

From 20c02becb7ecc57714c5b0f154d778141c5cf845 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 12:32:38 +0400
Subject: [PATCH 150/309] Removed private functions `inherits` and
 `addProperties` from `Rx.internals`.

---
 rx.js/rx.d.ts | 2 --
 1 file changed, 2 deletions(-)

diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index 1100bc618..c8966bade 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -7,8 +7,6 @@
 declare module Rx {
 	export module internals {
 		function isEqual(left: any, right: any): boolean;
-		function inherits(child: Function, parent: Function): Function;
-		function addProperties(obj: Object, ...sourcces: Object[]): void;
 		function addRef<T>(xs: Observable<T>, r: { getDisposable(): IDisposable; }): Observable<T>;
 
 		// Priority Queue for Scheduling

From 99fa7392f382fe04a4e22255e17d7e357babe997 Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Wed, 19 Mar 2014 09:55:21 +0000
Subject: [PATCH 151/309] jQuery: Promises - made first arg optional

---
 jquery/jquery-tests.ts | 194 +++++++++++++++++++++++------------------
 jquery/jquery.d.ts     |  23 +++--
 2 files changed, 126 insertions(+), 91 deletions(-)

diff --git a/jquery/jquery-tests.ts b/jquery/jquery-tests.ts
index e4d96fa92..37e03aa88 100644
--- a/jquery/jquery-tests.ts
+++ b/jquery/jquery-tests.ts
@@ -1097,90 +1097,6 @@ function test_dblclick() {
 	$('#target').dblclick();
 }
 
-function test_deferred() {
-
-    function returnPromise(): JQueryPromise<(data: { MyString: string; MyNumber: number; }, textStatus: string, jqXHR: JQueryXHR) => any> {
-        return $.ajax("test.php");
-    }
-    var x = returnPromise();
-    x.done((data, textStatus, jqXHR) => {
-        var myNumber: number = data.MyNumber;
-        var myString: string = data.MyString;
-        var theTextStatus: string = textStatus;
-        var thejqXHR: JQueryXHR = jqXHR;
-    });
-
-    $.get("test.php").always(function () {
-        alert("$.get completed with success or error callback arguments");
-    });
-    $.get("test.php").done(function () {
-        alert("$.get succeeded");
-    });
-    function fn1() {
-        $("p").append(" 1 ");
-    }
-    function fn2() {
-        $("p").append(" 2 ");
-    }
-    function fn3(n) {
-        $("p").append(n + " 3 " + n);
-    }
-    var dfd = $.Deferred();
-    dfd
-        .done([fn1, fn2], fn3, [fn2, fn1])
-        .done(function (n) {
-            $("p").append(n + " we're done.");
-        });
-    $("button").bind("click", function () {
-        dfd.resolve("and");
-    });
-    $.get("test.php")
-        .done(function () { alert("$.get succeeded"); })
-        .fail(function () { alert("$.get failed!"); });
-    dfd.state();
-    var defer = $.Deferred(),
-    filtered = defer.pipe(function (value) {
-        return value * 2;
-    });
-    defer.resolve(5);
-    filtered.done(function (value) {
-        alert("Value is ( 2*5 = ) 10: " + value);
-    });
-    filtered.fail(function (value) {
-        alert("Value is ( 3*6 = ) 18: " + value);
-    });
-    filtered.done(function (data) { });
-
-    function asyncEvent() {
-        var dfd: JQueryDeferred<string> = $.Deferred<string>();
-        setTimeout(function () {
-            dfd.resolve("hurray");
-        }, Math.floor(400 + Math.random() * 2000));
-        setTimeout(function () {
-            dfd.reject("sorry");
-        }, Math.floor(400 + Math.random() * 2000));
-        setTimeout(function working() {
-            if (dfd.state() === "pending") {
-                dfd.notify("working... ");
-                setTimeout(null, 500);
-            }
-        }, 1);
-        return dfd.promise();
-    }
-    var obj = {
-        hello: function (name) {
-            alert("Hello " + name);
-        }
-    },
-    defer = $.Deferred();
-    defer.promise(obj);
-    defer.resolve("John");
-    $.get("test.php").then(
-        function () { alert("$.get succeeded"); },
-        function () { alert("$.get failed!"); }
-    );
-}
-
 function test_delay() {
     $('#foo').slideUp(300).delay(800).fadeIn(400);
     $("button").click(function () {
@@ -3245,3 +3161,113 @@ $.ajax({
         alert(data);
     }
 });
+
+function test_deferred() {
+
+    function returnPromise(): JQueryPromise<(data: { MyString: string; MyNumber: number; }, textStatus: string, jqXHR: JQueryXHR) => any> {
+        return $.ajax("test.php");
+    }
+    var x = returnPromise();
+    x.done((data, textStatus, jqXHR) => {
+        var myNumber: number = data.MyNumber;
+        var myString: string = data.MyString;
+        var theTextStatus: string = textStatus;
+        var thejqXHR: JQueryXHR = jqXHR;
+    });
+
+    $.get("test.php").always(function () {
+        alert("$.get completed with success or error callback arguments");
+    });
+    $.get("test.php").done(function () {
+        alert("$.get succeeded");
+    });
+    function fn1() {
+        $("p").append(" 1 ");
+    }
+    function fn2() {
+        $("p").append(" 2 ");
+    }
+    function fn3(n) {
+        $("p").append(n + " 3 " + n);
+    }
+    var dfd = $.Deferred();
+    dfd
+        .done([fn1, fn2], fn3, [fn2, fn1])
+        .done(function (n) {
+            $("p").append(n + " we're done.");
+        });
+    $("button").bind("click", function () {
+        dfd.resolve("and");
+    });
+    $.get("test.php")
+        .done(function () { alert("$.get succeeded"); })
+        .fail(function () { alert("$.get failed!"); });
+    dfd.state();
+    var defer = $.Deferred(),
+        filtered = defer.pipe(function (value) {
+            return value * 2;
+        });
+    defer.resolve(5);
+    filtered.done(function (value) {
+        alert("Value is ( 2*5 = ) 10: " + value);
+    });
+    filtered.fail(function (value) {
+        alert("Value is ( 3*6 = ) 18: " + value);
+    });
+    filtered.done(function (data) { });
+
+    var obj = {
+        hello: function (name) {
+            alert("Hello " + name);
+        }
+    },
+        defer = $.Deferred();
+    defer.promise(obj);
+    defer.resolve("John");
+    $.get("test.php").then(
+        function () { alert("$.get succeeded"); },
+        function () { alert("$.get failed!"); }
+        );
+}
+
+function test_deferred_promise() {
+
+    function asyncEvent() {
+        var dfd = $.Deferred<string>();
+
+        // Resolve after a random interval
+        setTimeout(function () {
+            dfd.resolve("hurray");
+        }, Math.floor(400 + Math.random() * 2000));
+
+        // Reject after a random interval
+        setTimeout(function () {
+            dfd.reject("sorry");
+        }, Math.floor(400 + Math.random() * 2000));
+
+        // Show a "working..." message every half-second
+        setTimeout(function working() {
+            if (dfd.state() === "pending") {
+                dfd.notify("working... ");
+                setTimeout(working, 500);
+            }
+        }, 1);
+
+        // Return the Promise so caller can't change the Deferred
+        return dfd.promise();
+    }
+
+    // Attach a done, fail, and progress handler for the asyncEvent
+    $.when(asyncEvent()).then(
+        function (status) {
+            alert(status + ", things are going well");
+        },
+        function (status) {
+            alert(status + ", you fail this time");
+        },
+        function (status) {
+            $("body").append(status);
+        }
+        );
+}
+
diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 7e6c79cb3..558453ab3 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -297,21 +297,21 @@ interface JQueryPromise<T> {
      * @param alwaysCallbacks1 A function, or array of functions, that is called when the Deferred is resolved or rejected.
      * @param alwaysCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved or rejected.
      */
-    always(alwaysCallbacks1: T, ...alwaysCallbacks2: T[]): JQueryDeferred<T>;
+    always(alwaysCallbacks1?: T, ...alwaysCallbacks2: T[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object is resolved.
      * 
      * @param doneCallbacks1 A function, or array of functions, that are called when the Deferred is resolved.
      * @param doneCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved.
      */
-    done(doneCallbacks1: T, ...doneCallbacks2: T[]): JQueryDeferred<T>;
+    done(doneCallbacks1?: T, ...doneCallbacks2: T[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object is rejected.
      * 
      * @param failCallbacks1 A function, or array of functions, that are called when the Deferred is rejected.
      * @param failCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is rejected.
      */
-    fail(failCallbacks1: T, ...failCallbacks2: T[]): JQueryDeferred<T>;
+    fail(failCallbacks1?: T, ...failCallbacks2: T[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object generates progress notifications.
      * 
@@ -425,21 +425,21 @@ interface JQueryDeferred<T> extends JQueryPromise<T> {
      * @param alwaysCallbacks1 A function, or array of functions, that is called when the Deferred is resolved or rejected.
      * @param alwaysCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved or rejected.
      */
-    always(alwaysCallbacks1: T, ...alwaysCallbacks2: T[]): JQueryDeferred<T>;
+    always(alwaysCallbacks1?: T, ...alwaysCallbacks2: T[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object is resolved.
      * 
      * @param doneCallbacks1 A function, or array of functions, that are called when the Deferred is resolved.
      * @param doneCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved.
      */
-    done(doneCallbacks1: T, ...doneCallbacks2: T[]): JQueryDeferred<T>;
+    done(doneCallbacks1?: T, ...doneCallbacks2: T[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object is rejected.
      * 
      * @param failCallbacks1 A function, or array of functions, that are called when the Deferred is rejected.
      * @param failCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is rejected.
      */
-    fail(failCallbacks1: T, ...failCallbacks2: T[]): JQueryDeferred<T>;
+    fail(failCallbacks1?: T, ...failCallbacks2: T[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object generates progress notifications.
      * 
@@ -476,12 +476,21 @@ interface JQueryDeferred<T> extends JQueryPromise<T> {
      */
     rejectWith(context: any, ...args: any[]): JQueryDeferred<T>;
 
+    /**
+     * Resolve a Deferred object and call any doneCallbacks with the given args.
+     * 
+     * @param value First argument passed to doneCallbacks.
+     * @param args Optional subsequent arguments that are passed to the doneCallbacks.
+     */
+    resolve(value: T, ...args: any[]): JQueryDeferred<T>;
+
+    // COMMENTED OUT AS MAKES resolve LESS USEFUL - PERHAPS REMOVE ENTIRELY LATER
     /**
      * Resolve a Deferred object and call any doneCallbacks with the given args.
      * 
      * @param args Optional arguments that are passed to the doneCallbacks.
      */
-    resolve(...args: any[]): JQueryDeferred<T>;
+    //resolve(...args: any[]): JQueryDeferred<T>;
 
     /**
      * Resolve a Deferred object and call any doneCallbacks with the given context and args.

From 67186ede616c34b961e6a76c976231ed100e0af7 Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Wed, 19 Mar 2014 19:14:35 +0900
Subject: [PATCH 152/309] sort List of Definitions

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 8cb390306..1ead84bb8 100755
--- a/README.md
+++ b/README.md
@@ -54,6 +54,7 @@ List of Definitions
 * [Chosen](http://harvesthq.github.com/chosen/) (by [Boris Yankov](https://github.com/borisyankov))
 * [Chrome](http://developer.chrome.com/extensions/) (by [Matthew Kimber](https://github.com/matthewkimber))
 * [Chrome App](http://developer.chrome.com/apps/) (by [Adam Lay](https://github.com/AdamLay))
+* [CKEditor](https://github.com/ckeditor/ckeditor-dev) (by [Ondrej Sevcik](https://github.com/ondrejsevcik))
 * [CodeMirror](http://codemirror.net) (by [François de Campredon](https://github.com/fdecampredon))
 * [Commander](http://github.com/visionmedia/commander.js) (by [Marcelo Dezem](https://github.com/mdezem))
 * [Couchbase / Couchnode](https://github.com/couchbase/couchnode) (by [Basarat Ali Syed](https://github.com/basarat))
@@ -284,7 +285,6 @@ List of Definitions
 * [Zepto.js](http://zeptojs.com/) (by [Josh Baldwin](https://github.com/jbaldwin))
 * [Zynga Scroller](https://github.com/zynga/scroller) (by [Boris Yankov](https://github.com/borisyankov))
 * [ZeroClipboard](https://github.com/jonrohan/ZeroClipboard) (by [Eric J. Smith](https://github.com/ejsmith))
-* [CKEditor](https://github.com/ckeditor/ckeditor-dev) (by [Ondrej Sevcik](https://github.com/ondrejsevcik))
 
 Requested Definitions
 ---------------------

From 1d167082e9d9d3223b0967a976434b44a46643ef Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 14:24:17 +0400
Subject: [PATCH 153/309] Extracted common part of definitions with `rx.lite`
 from `rx.d.ts` into `rx-lite.d.ts`.

---
 rx.js/rx-lite.d.ts | 372 +++++++++++++++++++++++++++++++++++++++++++++
 rx.js/rx.d.ts      | 356 ++-----------------------------------------
 2 files changed, 382 insertions(+), 346 deletions(-)
 create mode 100644 rx.js/rx-lite.d.ts

diff --git a/rx.js/rx-lite.d.ts b/rx.js/rx-lite.d.ts
new file mode 100644
index 000000000..e6f60c5de
--- /dev/null
+++ b/rx.js/rx-lite.d.ts
@@ -0,0 +1,372 @@
+// This file contains common part of defintions for rx.d.ts and rx.lite.d.ts
+// Do not include the file separately.
+
+declare module Rx {
+	export module internals {
+		function isEqual(left: any, right: any): boolean;
+		function addRef<T>(xs: Observable<T>, r: { getDisposable(): IDisposable; }): Observable<T>;
+
+		// Priority Queue for Scheduling
+		export class PriorityQueue<TTime> {
+			constructor(capacity: number);
+
+			length: number;
+
+			isHigherPriority(left: number, right: number): boolean;
+			percolate(index: number): void;
+			heapify(index: number): void;
+			peek(): ScheduledItem<TTime>;
+			removeAt(index: number): void;
+			dequeue(): ScheduledItem<TTime>;
+			enqueue(item: ScheduledItem<TTime>): void;
+			remove(item: ScheduledItem<TTime>): boolean;
+
+			static count: number;
+		}
+
+		export class ScheduledItem<TTime> {
+			constructor(scheduler: IScheduler, state: any, action: (scheduler: IScheduler, state: any) => IDisposable, dueTime: TTime, comparer?: (x: TTime, y: TTime) => number);
+
+			scheduler: IScheduler;
+			state: TTime;
+			action: (scheduler: IScheduler, state: any) => IDisposable;
+			dueTime: TTime;
+			comparer: (x: TTime, y: TTime) => number;
+			disposable: SingleAssignmentDisposable;
+
+			invoke(): void;
+			compareTo(other: ScheduledItem<TTime>): number;
+			isCancelled(): boolean;
+			invokeCore(): IDisposable;
+		}
+	}
+
+	export module config {
+		export var Promise: { new <T>(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; };
+	}
+
+	export interface IDisposable {
+		dispose(): void;
+	}
+
+	export class CompositeDisposable implements IDisposable {
+		constructor (...disposables: IDisposable[]);
+		constructor (disposables: IDisposable[]);
+
+		isDisposed: boolean;
+		length: number;
+
+		dispose(): void;
+		add(item: IDisposable): void;
+		remove(item: IDisposable): boolean;
+		clear(): void;
+		contains(item: IDisposable): boolean;
+		toArray(): IDisposable[];
+	}
+
+	export class Disposable implements IDisposable {
+		constructor(action: () => void);
+
+		static create(action: () => void): IDisposable;
+		static empty: IDisposable;
+
+		dispose(): void;
+	}
+
+	// Single assignment
+	export class SingleAssignmentDisposable implements IDisposable {
+		constructor();
+
+		isDisposed: boolean;
+		current: IDisposable;
+
+		dispose(): void ;
+		getDisposable(): IDisposable;
+		setDisposable(value: IDisposable): void ;
+	}
+
+	// Multiple assignment disposable
+	export class SerialDisposable implements IDisposable {
+		constructor();
+
+		isDisposed: boolean;
+
+		dispose(): void;
+		getDisposable(): IDisposable;
+		setDisposable(value: IDisposable): void;
+	}
+
+	export class RefCountDisposable implements IDisposable {
+		constructor(disposable: IDisposable);
+
+		dispose(): void;
+
+		isDisposed: boolean;
+		getDisposable(): IDisposable;
+	}
+
+	export interface IScheduler {
+		now(): number;
+
+		schedule(action: () => void): IDisposable;
+		scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+		scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
+		scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable;
+		scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
+		scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable;
+
+		scheduleRecursive(action: (action: () =>void ) =>void ): IDisposable;
+		scheduleRecursiveWithState<TState>(state: TState, action: (state: TState, action: (state: TState) =>void ) =>void ): IDisposable;
+		scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
+		scheduleRecursiveWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
+		scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): IDisposable;
+		scheduleRecursiveWithRelativeAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) =>void ) =>void ): IDisposable;
+
+		schedulePeriodic(period: number, action: () => void): IDisposable;
+		schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
+	}
+
+	// Current Thread IScheduler
+	interface ICurrentThreadScheduler extends IScheduler {
+		scheduleRequired(): boolean;
+	}
+
+	// Notifications
+	export class Notification<T> {
+		accept(observer: Observer<T>): void;
+		accept<TResult>(onNext: (value: T) => TResult, onError?: (exception: any) => TResult, onCompleted?: () => TResult): TResult;
+		toObservable(scheduler?: IScheduler): Observable<T>;
+		hasValue: boolean;
+		equals(other: Notification<T>): boolean;
+		kind: string;
+		value: T;
+		exception: any;
+
+		static createOnNext<T>(value: T): Notification<T>;
+		static createOnError<T>(exception: any): Notification<T>;
+		static createOnCompleted<T>(): Notification<T>;
+	}
+
+	/**
+	 * Promise A+
+	 */
+	export interface IPromise<T> {
+		then<R>(onFulfilled: (value: T) => IPromise<R>, onRejected: (reason: any) => IPromise<R>): IPromise<R>;
+		then<R>(onFulfilled: (value: T) => IPromise<R>, onRejected?: (reason: any) => R): IPromise<R>;
+		then<R>(onFulfilled: (value: T) => R, onRejected: (reason: any) => IPromise<R>): IPromise<R>;
+		then<R>(onFulfilled?: (value: T) => R, onRejected?: (reason: any) => R): IPromise<R>;
+	}
+
+	// Observer
+	export interface IObserver<T> {
+		onNext(value: T): void;
+		onError(exception: any): void;
+		onCompleted(): void;
+	}
+
+	export interface IObservable<T> {
+		subscribe(observer: Observer<T>): IDisposable;
+		subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;
+	}
+
+	export interface Observable<T> extends IObservable<T> {
+		forEach(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;	// alias for subscribe
+		finalValue(): Observable<T>;
+		toArray(): Observable<T[]>;
+
+		catch(handler: (exception: any) => Observable<T>): Observable<T>;
+		catchException(handler: (exception: any) => Observable<T>): Observable<T>;	// alias for catch
+		catch(second: Observable<T>): Observable<T>;
+		catchException(second: Observable<T>): Observable<T>;	// alias for catch
+		combineLatest<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, TResult>(second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, T4, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, T4, T5, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, fifth: Observable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
+		combineLatest<TOther, TResult>(souces: Observable<TOther>[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
+		concat(...sources: Observable<T>[]): Observable<T>;
+		concat(...sources: IPromise<T>[]): Observable<T>;
+		concat(sources: Observable<T>[]): Observable<T>;
+		concat(sources: IPromise<T>[]): Observable<T>;
+		concatAll(): T;
+		concatObservable(): T;	// alias for concatAll
+		merge(maxConcurrent: number): T;
+		merge(other: Observable<T>): Observable<T>;
+		merge(other: IPromise<T>): Observable<T>;
+		mergeAll(): T;
+		mergeObservable(): T;	// alias for mergeAll
+		skipUntil<T2>(other: Observable<T2>): Observable<T>;
+		switch(): T;
+		switchLatest(): T;	// alias for switch
+		takeUntil<T2>(other: Observable<T2>): Observable<T>;
+		zip<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		zip<T2, T3, TResult>(second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		zip<T2, T3, T4, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		zip<T2, T3, T4, T5, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, fifth: Observable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
+		zip<TOther, TResult>(second: Observable<TOther>[], resultSelector: (left: T, right: Observable<TOther>) => TResult): Observable<TResult>;
+
+		asObservable(): Observable<T>;
+		dematerialize<TOrigin>(): Observable<TOrigin>;
+		distinctUntilChanged(skipParameter: boolean, comparer: (x: T, y: T) => boolean): Observable<T>;
+		distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable<T>;
+		do(observer: Observer<T>): Observable<T>;
+		doAction(observer: Observer<T>): Observable<T>;	// alias for do
+		do(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;
+		doAction(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;	// alias for do
+		finally(action: () => void): Observable<T>;
+		finallyAction(action: () => void): Observable<T>;	// alias for finally
+		ignoreElements(): Observable<T>;
+		materialize(): Observable<Notification<T>>;
+		repeat(repeatCount?: number): Observable<T>;
+		retry(retryCount?: number): Observable<T>;
+		scan<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
+		scan(accumulator: (acc: T, value: T) => T): Observable<T>;
+		skipLast(count: number): Observable<T>;
+		startWith(...values: T[]): Observable<T>;
+		startWith(scheduler: IScheduler, ...values: T[]): Observable<T>;
+		takeLast(count: number, scheduler?: IScheduler): Observable<T>;
+		takeLastBuffer(count: number): Observable<T[]>;
+
+		select<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;
+		map<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;	// alias for select
+		selectMany<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
+		selectMany<TOther, TResult>(selector: (value: T) => IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
+		selectMany<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;
+		selectMany<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>;
+		selectMany<TResult>(other: Observable<TResult>): Observable<TResult>;
+		selectMany<TResult>(other: IPromise<TResult>): Observable<TResult>;
+		flatMap<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;	// alias for selectMany
+		flatMap<TOther, TResult>(selector: (value: T) => IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;	// alias for selectMany
+		flatMap<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;	// alias for selectMany
+		flatMap<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>;	// alias for selectMany
+		flatMap<TResult>(other: Observable<TResult>): Observable<TResult>;	// alias for selectMany
+		flatMap<TResult>(other: IPromise<TResult>): Observable<TResult>;	// alias for selectMany
+
+		/**
+		*  Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then 
+		*  transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
+		* @param selector A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
+		* @param [thisArg] Object to use as this when executing callback.
+		* @returns An observable sequence whose elements are the result of invoking the transform function on each element of source producing an Observable of Observable sequences 
+		*  and that at any point in time produces the elements of the most recent inner observable sequence that has been received.
+		*/
+		selectSwitch<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;
+		/**
+		*  Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then 
+		*  transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
+		* @param selector A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
+		* @param [thisArg] Object to use as this when executing callback.
+		* @returns An observable sequence whose elements are the result of invoking the transform function on each element of source producing an Observable of Observable sequences 
+		*  and that at any point in time produces the elements of the most recent inner observable sequence that has been received.
+		*/
+		flatMapLatest<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;	// alias for selectSwitch
+
+		skip(count: number): Observable<T>;
+		skipWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		take(count: number, scheduler?: IScheduler): Observable<T>;
+		takeWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		where(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		filter(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>; // alias for where
+	}
+
+	interface ObservableStatic {
+		create<T>(subscribe: (observer: Observer<T>) => void): Observable<T>;
+		create<T>(subscribe: (observer: Observer<T>) => () => void): Observable<T>;
+		create<T>(subscribe: (observer: Observer<T>) => IDisposable): Observable<T>;
+		createWithDisposable<T>(subscribe: (observer: Observer<T>) => IDisposable): Observable<T>;
+		defer<T>(observableFactory: () => Observable<T>): Observable<T>;
+		empty<T>(scheduler?: IScheduler): Observable<T>;
+		fromArray<T>(array: T[], scheduler?: IScheduler): Observable<T>;
+		fromArray<T>(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): Observable<T>;
+
+		/**
+		*  Converts an iterable into an Observable sequence
+		*  
+		* @example
+		*  var res = Rx.Observable.fromIterable(new Map());
+		*  var res = Rx.Observable.fromIterable(function* () { yield 42; });
+		*  var res = Rx.Observable.fromIterable(new Set(), Rx.Scheduler.timeout);
+		* @param generator Generator to convert from.
+		* @param [scheduler] Scheduler to run the enumeration of the input sequence on.
+		* @returns The observable sequence whose elements are pulled from the given generator sequence.
+		*/
+		fromItreable<T>(generator: () => { next(): { done: boolean; value?: T; }; }, scheduler?: IScheduler): Observable<T>;
+
+		/**
+		*  Converts an iterable into an Observable sequence
+		*  
+		* @example
+		*  var res = Rx.Observable.fromIterable(new Map());
+		*  var res = Rx.Observable.fromIterable(new Set(), Rx.Scheduler.timeout);
+		* @param iterable Iterable to convert from.
+		* @param [scheduler] Scheduler to run the enumeration of the input sequence on.
+		* @returns The observable sequence whose elements are pulled from the given generator sequence.
+		*/
+		fromItreable<T>(iterable: {}, scheduler?: IScheduler): Observable<T>;	// todo: can't describe ES6 Iterable via TypeScript type system
+		generate<TState, TResult>(initialState: TState, condition: (state: TState) => boolean, iterate: (state: TState) => TState, resultSelector: (state: TState) => TResult, scheduler?: IScheduler): Observable<TResult>;
+		never<T>(): Observable<T>;
+		range(start: number, count: number, scheduler?: IScheduler): Observable<number>;
+		repeat<T>(value: T, repeatCount?: number, scheduler?: IScheduler): Observable<T>;
+		return<T>(value: T, scheduler?: IScheduler): Observable<T>;
+		returnValue<T>(value: T, scheduler?: IScheduler): Observable<T>;	// alias for return
+		throw<T>(exception: Error, scheduler?: IScheduler): Observable<T>;
+		throw<T>(exception: any, scheduler?: IScheduler): Observable<T>;
+		throwException<T>(exception: Error, scheduler?: IScheduler): Observable<T>;	// alias for throw
+		throwException<T>(exception: any, scheduler?: IScheduler): Observable<T>;	// alias for throw
+
+		catch<T>(sources: Observable<T>[]): Observable<T>;
+		catchException<T>(sources: Observable<T>[]): Observable<T>;	// alias for catch
+		catch<T>(...sources: Observable<T>[]): Observable<T>;
+		catchException<T>(...sources: Observable<T>[]): Observable<T>;	// alias for catch
+		concat<T>(...sources: Observable<T>[]): Observable<T>;
+		concat<T>(...sources: IPromise<T>[]): Observable<T>;
+		concat<T>(sources: Observable<T>[]): Observable<T>;
+		concat<T>(sources: IPromise<T>[]): Observable<T>;
+		merge<T>(...sources: Observable<T>[]): Observable<T>;
+		merge<T>(...sources: IPromise<T>[]): Observable<T>;
+		merge<T>(sources: Observable<T>[]): Observable<T>;
+		merge<T>(sources: IPromise<T>[]): Observable<T>;
+		merge<T>(scheduler: IScheduler, ...sources: Observable<T>[]): Observable<T>;
+		merge<T>(scheduler: IScheduler, ...sources: IPromise<T>[]): Observable<T>;
+		merge<T>(scheduler: IScheduler, sources: Observable<T>[]): Observable<T>;
+		merge<T>(scheduler: IScheduler, sources: IPromise<T>[]): Observable<T>;
+		zip<T1, T2, TResult>(first: Observable<T1>, sources: Observable<T2>[], resultSelector: (item1: T1, right: Observable<T2>) => TResult): Observable<TResult>;
+		zip<T1, T2, TResult>(source1: Observable<T1>, source2: Observable<T2>, resultSelector: (item1: T1, item2: T2) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, source4: Observable<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, T5, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, source4: Observable<T4>, source5: Observable<T5>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TResult): Observable<TResult>;
+		zipArray<T>(...sources: Observable<T>[]): Observable<T[]>;
+		zipArray<T>(sources: Observable<T>[]): Observable<T[]>;
+
+		/**
+		* Converts a Promise to an Observable sequence
+		* @param promise An ES6 Compliant promise.
+		* @returns An Observable sequence which wraps the existing promise success and failure.
+		*/
+		fromPromise<T>(promise: IPromise<T>): Observable<T>;
+	}
+
+	export var Observable: ObservableStatic;
+
+	interface ISubject<T> extends Observable<T>, Observer<T>, IDisposable {
+		hasObservers(): boolean;
+	}
+
+    export interface Subject<T> extends ISubject<T> {
+    }
+
+    interface SubjectStatic {
+        new <T>(): Subject<T>;
+		create<T>(observer?: Observer<T>, observable?: Observable<T>): ISubject<T>;
+	}
+
+	export var Subject: SubjectStatic;
+
+	export interface AsyncSubject<T> extends Subject<T> {
+	}
+
+	interface AsyncSubjectStatic {
+		new <T>(): AsyncSubject<T>;
+	}
+
+	export var AsyncSubject: AsyncSubjectStatic;
+}
diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index c8966bade..0b3b3cdf7 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -4,131 +4,12 @@
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
+///<reference path="rx-lite.d.ts"/>
+
 declare module Rx {
-	export module internals {
-		function isEqual(left: any, right: any): boolean;
-		function addRef<T>(xs: Observable<T>, r: { getDisposable(): IDisposable; }): Observable<T>;
-
-		// Priority Queue for Scheduling
-		export class PriorityQueue<TTime> {
-			constructor(capacity: number);
-
-			length: number;
-
-			isHigherPriority(left: number, right: number): boolean;
-			percolate(index: number): void;
-			heapify(index: number): void;
-			peek(): ScheduledItem<TTime>;
-			removeAt(index: number): void;
-			dequeue(): ScheduledItem<TTime>;
-			enqueue(item: ScheduledItem<TTime>): void;
-			remove(item: ScheduledItem<TTime>): boolean;
-
-			static count: number;
-		}
-
-		export class ScheduledItem<TTime> {
-			constructor(scheduler: IScheduler, state: any, action: (scheduler: IScheduler, state: any) => IDisposable, dueTime: TTime, comparer?: (x: TTime, y: TTime) => number);
-
-			scheduler: IScheduler;
-			state: TTime;
-			action: (scheduler: IScheduler, state: any) => IDisposable;
-			dueTime: TTime;
-			comparer: (x: TTime, y: TTime) => number;
-			disposable: SingleAssignmentDisposable;
-
-			invoke(): void;
-			compareTo(other: ScheduledItem<TTime>): number;
-			isCancelled(): boolean;
-			invokeCore(): IDisposable;
-		}
-	}
-
-	export module config {
-		export var Promise: { new <T>(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; };
-	}
-
-	export interface IDisposable {
-		dispose(): void;
-	}
-
-	export class CompositeDisposable implements IDisposable {
-		constructor (...disposables: IDisposable[]);
-		constructor (disposables: IDisposable[]);
-
-		isDisposed: boolean;
-		length: number;
-
-		dispose(): void;
-		add(item: IDisposable): void;
-		remove(item: IDisposable): boolean;
-		clear(): void;
-		contains(item: IDisposable): boolean;
-		toArray(): IDisposable[];
-	}
-
-	export class Disposable implements IDisposable {
-		constructor(action: () => void);
-
-		static create(action: () => void): IDisposable;
-		static empty: IDisposable;
-
-		dispose(): void;
-	}
-
-	// Single assignment
-	export class SingleAssignmentDisposable implements IDisposable {
-		constructor();
-
-		isDisposed: boolean;
-		current: IDisposable;
-
-		dispose(): void ;
-		getDisposable(): IDisposable;
-		setDisposable(value: IDisposable): void ;
-	}
-
-	// Multiple assignment disposable
-	export class SerialDisposable implements IDisposable {
-		constructor();
-
-		isDisposed: boolean;
-
-		dispose(): void;
-		getDisposable(): IDisposable;
-		setDisposable(value: IDisposable): void;
-	}
-
-	export class RefCountDisposable implements IDisposable {
-		constructor(disposable: IDisposable);
-
-		dispose(): void;
-
-		isDisposed: boolean;
-		getDisposable(): IDisposable;
-	}
-
 	export interface IScheduler {
-		now(): number;
 		catch(handler: (exception: any) => boolean): IScheduler;
 		catchException(handler: (exception: any) => boolean): IScheduler;
-
-		schedule(action: () => void): IDisposable;
-		scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
-		scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
-		scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable;
-		scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
-		scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable;
-
-		scheduleRecursive(action: (action: () =>void ) =>void ): IDisposable;
-		scheduleRecursiveWithState<TState>(state: TState, action: (state: TState, action: (state: TState) =>void ) =>void ): IDisposable;
-		scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
-		scheduleRecursiveWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
-		scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): IDisposable;
-		scheduleRecursiveWithRelativeAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) =>void ) =>void ): IDisposable;
-
-		schedulePeriodic(period: number, action: () => void): IDisposable;
-		schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
 	}
 
 	export class Scheduler implements IScheduler {
@@ -166,39 +47,8 @@ declare module Rx {
 		schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
 	}
 
-	// Current Thread IScheduler
-	interface ICurrentThreadScheduler extends IScheduler {
-		scheduleRequired(): boolean;
-	}
-
-	// Notifications
-	export class Notification<T> {
-		accept(observer: Observer<T>): void;
-		accept<TResult>(onNext: (value: T) => TResult, onError?: (exception: any) => TResult, onCompleted?: () => TResult): TResult;
-		toObservable(scheduler?: IScheduler): Observable<T>;
-		hasValue: boolean;
-		equals(other: Notification<T>): boolean;
-		kind: string;
-		value: T;
-		exception: any;
-
-		static createOnNext<T>(value: T): Notification<T>;
-		static createOnError<T>(exception: any): Notification<T>;
-		static createOnCompleted<T>(): Notification<T>;
-	}
-
-	/**
-	 * Promise A+
-	 */
-	export interface IPromise<T> {
-		then<R>(onFulfilled: (value: T) => IPromise<R>, onRejected: (reason: any) => IPromise<R>): IPromise<R>;
-		then<R>(onFulfilled: (value: T) => IPromise<R>, onRejected?: (reason: any) => R): IPromise<R>;
-		then<R>(onFulfilled: (value: T) => R, onRejected: (reason: any) => IPromise<R>): IPromise<R>;
-		then<R>(onFulfilled?: (value: T) => R, onRejected?: (reason: any) => R): IPromise<R>;
-	}
-
 	// Observer
-	export class Observer<T> {
+	export class Observer<T> implements IObserver<T> {
 		onNext(value: T): void;
 		onError(exception: any): void;
 		onCompleted(): void;
@@ -209,70 +59,22 @@ declare module Rx {
 
 		static create<T>(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observer<T>;
 		static fromNotifier<T>(handler: (notification: Notification<T>) => void): Observer<T>;
+		
+		/**
+		* Schedules the invocation of observer methods on the given scheduler.
+		* @param scheduler Scheduler to schedule observer messages on.
+		* @returns Observer whose messages are scheduled on the given scheduler.
+		*/
+		static notifyOn<T>(scheduler: IScheduler): Observer<T>;
 	}
 
 	export interface Observable<T> {
-		subscribe(observer: Observer<T>): IDisposable;
-		subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;
-
-		toArray(): Observable<T[]>;
-
 		observeOn(scheduler: IScheduler): Observable<T>;
 		subscribeOn(scheduler: IScheduler): Observable<T>;
 
 		amb(rightSource: Observable<T>): Observable<T>;
-		catch(handler: (exception: any) => Observable<T>): Observable<T>;
-		catchException(handler: (exception: any) => Observable<T>): Observable<T>;	// alias for catch
-		catch(second: Observable<T>): Observable<T>;
-		catchException(second: Observable<T>): Observable<T>;	// alias for catch
-		combineLatest<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
-		combineLatest<T2, T3, TResult>(second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-		combineLatest<T2, T3, T4, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
-		combineLatest<T2, T3, T4, T5, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, fifth: Observable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
-		combineLatest<TOther, TResult>(souces: Observable<TOther>[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
-		concat(...sources: Observable<T>[]): Observable<T>;
-		concat(...sources: IPromise<T>[]): Observable<T>;
-		concat(sources: Observable<T>[]): Observable<T>;
-		concat(sources: IPromise<T>[]): Observable<T>;
-		concatAll(): T;
-		concatObservable(): T;	// alias for concatAll
-		merge(maxConcurrent: number): T;
-		merge(other: Observable<T>): Observable<T>;
-		merge(other: IPromise<T>): Observable<T>;
-		mergeAll(): T;
-		mergeObservable(): T;	// alias for mergeAll
 		onErrorResumeNext(second: Observable<T>): Observable<T>;
-		skipUntil<T2>(other: Observable<T2>): Observable<T>;
-		switch(): T;
-		switchLatest(): T;	// alias for switch
-		takeUntil<T2>(other: Observable<T2>): Observable<T>;
-		zip<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
-		zip<T2, T3, TResult>(second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-		zip<T2, T3, T4, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
-		zip<T2, T3, T4, T5, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, fifth: Observable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
-		zip<TOther, TResult>(second: Observable<TOther>[], resultSelector: (left: T, right: Observable<TOther>) => TResult): Observable<TResult>;
-		asObservable(): Observable<T>;
 		bufferWithCount(count: number, skip?: number): Observable<T[]>;
-		dematerialize<TOrigin>(): Observable<TOrigin>;
-		distinctUntilChanged(skipParameter: boolean, comparer: (x: T, y: T) => boolean): Observable<T>;
-		distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable<T>;
-		do(observer: Observer<T>): Observable<T>;
-		doAction(observer: Observer<T>): Observable<T>;	// alias for do
-		do(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;
-		doAction(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;	// alias for do
-		finally(action: () => void): Observable<T>;
-		finallyAction(action: () => void): Observable<T>;	// alias for finally
-		ignoreElements(): Observable<T>;
-		materialize(): Observable<Notification<T>>;
-		repeat(repeatCount?: number): Observable<T>;
-		retry(retryCount?: number): Observable<T>;
-		scan<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
-		scan(accumulator: (acc: T, value: T) => T): Observable<T>;
-		skipLast(count: number): Observable<T>;
-		startWith(...values: T[]): Observable<T>;
-		startWith(scheduler: IScheduler, ...values: T[]): Observable<T>;
-		takeLast(count: number, scheduler?: IScheduler): Observable<T>;
-		takeLastBuffer(count: number): Observable<T[]>;
 		windowWithCount(count: number, skip?: number): Observable<Observable<T>>;
 		defaultIfEmpty(defaultValue?: T): Observable<T>;
 		distinct(skipParameter: boolean, valueSerializer: (value: T) => string): Observable<T>;
@@ -281,156 +83,18 @@ declare module Rx {
 		groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
 		groupByUntil<TKey, TDuration>(keySelector: (value: T) => TKey, skipElementSelector: boolean, durationSelector: (group: GroupedObservable<TKey, T>) => Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
 		groupByUntil<TKey, TElement, TDuration>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: GroupedObservable<TKey, TElement>) => Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, TElement>>;
-		select<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;
-		map<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;	// alias for select
-		selectMany<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
-		selectMany<TOther, TResult>(selector: (value: T) => IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
-		selectMany<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;
-		selectMany<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>;
-		selectMany<TResult>(other: Observable<TResult>): Observable<TResult>;
-		selectMany<TResult>(other: IPromise<TResult>): Observable<TResult>;
-		flatMap<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;	// alias for selectMany
-		flatMap<TOther, TResult>(selector: (value: T) => IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;	// alias for selectMany
-		flatMap<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;	// alias for selectMany
-		flatMap<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>;	// alias for selectMany
-		flatMap<TResult>(other: Observable<TResult>): Observable<TResult>;	// alias for selectMany
-		flatMap<TResult>(other: IPromise<TResult>): Observable<TResult>;	// alias for selectMany
-		skip(count: number): Observable<T>;
-		skipWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
-		take(count: number, scheduler?: IScheduler): Observable<T>;
-		takeWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
-		where(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
-		filter(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>; // alias for where
-
-		/**
-		* Converts an existing observable sequence to an ES6 Compatible Promise
-		* @example
-		* var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);
-		* @param promiseCtor The constructor of the promise.
-		* @returns An ES6 compatible promise with the last value from the observable sequence.
-		*/
-		toPromise<TPromise extends IPromise<T>>(promiseCtor: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): TPromise; }): TPromise;
-		/**
-		* Converts an existing observable sequence to an ES6 Compatible Promise
-		* @example
-		* var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);
-		* 
-		* // With config
-		* Rx.config.Promise = RSVP.Promise;
-		* var promise = Rx.Observable.return(42).toPromise();
-		* @param [promiseCtor] The constructor of the promise. If not provided, it looks for it in Rx.config.Promise.
-		* @returns An ES6 compatible promise with the last value from the observable sequence.
-		*/
-		toPromise(promiseCtor?: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; }): IPromise<T>;
 	}
 
 	interface ObservableStatic {
-		create<T>(subscribe: (observer: Observer<T>) => void): Observable<T>;
-		create<T>(subscribe: (observer: Observer<T>) => () => void): Observable<T>;
-		createWithDisposable<T>(subscribe: (observer: Observer<T>) => IDisposable): Observable<T>;
-		defer<T>(observableFactory: () => Observable<T>): Observable<T>;
-		empty<T>(scheduler?: IScheduler): Observable<T>;
-		fromArray<T>(array: T[], scheduler?: IScheduler): Observable<T>;
-		fromArray<T>(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): Observable<T>;
-		generate<TState, TResult>(initialState: TState, condition: (state: TState) => boolean, iterate: (state: TState) => TState, resultSelector: (state: TState) => TResult, scheduler?: IScheduler): Observable<TResult>;
-		never<T>(): Observable<T>;
-		range(start: number, count: number, scheduler?: IScheduler): Observable<number>;
-		repeat<T>(value: T, repeatCount?: number, scheduler?: IScheduler): Observable<T>;
-		return<T>(value: T, scheduler?: IScheduler): Observable<T>;
-		returnValue<T>(value: T, scheduler?: IScheduler): Observable<T>;	// alias for return
-		throw<T>(exception: Error, scheduler?: IScheduler): Observable<T>;
-		throw<T>(exception: any, scheduler?: IScheduler): Observable<T>;
-		throwException<T>(exception: Error, scheduler?: IScheduler): Observable<T>;	// alias for throw
-		throwException<T>(exception: any, scheduler?: IScheduler): Observable<T>;	// alias for throw
 		using<TSource, TResource extends IDisposable>(resourceFactory: () => TResource, observableFactory: (resource: TResource) => Observable<TSource>): Observable<TSource>;
 		amb<T>(...sources: Observable<T>[]): Observable<T>;
 		amb<T>(sources: Observable<T>[]): Observable<T>;
-		catch<T>(sources: Observable<T>[]): Observable<T>;
-		catchException<T>(sources: Observable<T>[]): Observable<T>;	// alias for catch
-		catch<T>(...sources: Observable<T>[]): Observable<T>;
-		catchException<T>(...sources: Observable<T>[]): Observable<T>;	// alias for catch
-		concat<T>(...sources: Observable<T>[]): Observable<T>;
-		concat<T>(...sources: IPromise<T>[]): Observable<T>;
-		concat<T>(sources: Observable<T>[]): Observable<T>;
-		concat<T>(sources: IPromise<T>[]): Observable<T>;
-		merge<T>(...sources: Observable<T>[]): Observable<T>;
-		merge<T>(...sources: IPromise<T>[]): Observable<T>;
-		merge<T>(sources: Observable<T>[]): Observable<T>;
-		merge<T>(sources: IPromise<T>[]): Observable<T>;
-		merge<T>(scheduler: IScheduler, ...sources: Observable<T>[]): Observable<T>;
-		merge<T>(scheduler: IScheduler, ...sources: IPromise<T>[]): Observable<T>;
-		merge<T>(scheduler: IScheduler, sources: Observable<T>[]): Observable<T>;
-		merge<T>(scheduler: IScheduler, sources: IPromise<T>[]): Observable<T>;
 		onErrorResumeNext<T>(...sources: Observable<T>[]): Observable<T>;
 		onErrorResumeNext<T>(sources: Observable<T>[]): Observable<T>;
-		zip<T1, T2, TResult>(first: Observable<T1>, sources: Observable<T2>[], resultSelector: (item1: T1, right: Observable<T2>) => TResult): Observable<TResult>;
-		zip<T1, T2, TResult>(source1: Observable<T1>, source2: Observable<T2>, resultSelector: (item1: T1, item2: T2) => TResult): Observable<TResult>;
-		zip<T1, T2, T3, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable<TResult>;
-		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, source4: Observable<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
-		zip<T1, T2, T3, T4, T5, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, source4: Observable<T4>, source5: Observable<T5>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TResult): Observable<TResult>;
-		zipArray<T>(...sources: Observable<T>[]): Observable<T[]>;
-		zipArray<T>(sources: Observable<T>[]): Observable<T[]>;
-
-		/**
-		* Converts a Promise to an Observable sequence
-		* @param promise An ES6 Compliant promise.
-		* @returns An Observable sequence which wraps the existing promise success and failure.
-		*/
-		fromPromise<T>(promise: IPromise<T>): Observable<T>;
-
-		/**
-		*  Converts an iterable into an Observable sequence
-		*  
-		* @example
-		*  var res = Rx.Observable.fromIterable(new Map());
-		*  var res = Rx.Observable.fromIterable(function* () { yield 42; });
-		*  var res = Rx.Observable.fromIterable(new Set(), Rx.Scheduler.timeout);
-		* @param generator Generator to convert from.
-		* @param [scheduler] Scheduler to run the enumeration of the input sequence on.
-		* @returns The observable sequence whose elements are pulled from the given generator sequence.
-		*/
-		fromItreable<T>(generator: () => { next(): { done: boolean; value?: T; }; }, scheduler?: IScheduler): Observable<T>;
-
-		/**
-		*  Converts an iterable into an Observable sequence
-		*  
-		* @example
-		*  var res = Rx.Observable.fromIterable(new Map());
-		*  var res = Rx.Observable.fromIterable(new Set(), Rx.Scheduler.timeout);
-		* @param iterable Iterable to convert from.
-		* @param [scheduler] Scheduler to run the enumeration of the input sequence on.
-		* @returns The observable sequence whose elements are pulled from the given generator sequence.
-		*/
-		fromItreable<T>(iterable: {}, scheduler?: IScheduler): Observable<T>;	// todo: can't describe ES6 Iterable via TypeScript type system
 	}
 
-	export var Observable: ObservableStatic;
-
 	interface GroupedObservable<TKey, TElement> extends Observable<TElement> {
 		key: TKey;
 		underlyingObservable: Observable<TElement>;
 	}
-
-	interface ISubject<T> extends Observable<T>, Observer<T>, IDisposable {
-		hasObservers(): boolean;
-	}
-
-    export interface Subject<T> extends ISubject<T> {
-    }
-
-    interface SubjectStatic {
-        new <T>(): Subject<T>;
-		create<T>(observer?: Observer<T>, observable?: Observable<T>): ISubject<T>;
-	}
-
-	export var Subject: SubjectStatic;
-
-	export interface AsyncSubject<T> extends Subject<T> {
-	}
-
-	interface AsyncSubjectStatic {
-		new <T>(): AsyncSubject<T>;
-	}
-
-	export var AsyncSubject: AsyncSubjectStatic;
 }

From 2f079e56818a1c6ea8899a9998af89709d0f128f Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 14:41:13 +0400
Subject: [PATCH 154/309] Reverted `toPromise` to rx-lite.d.ts

---
 rx.js/rx-lite.d.ts | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/rx.js/rx-lite.d.ts b/rx.js/rx-lite.d.ts
index e6f60c5de..0c1391c41 100644
--- a/rx.js/rx-lite.d.ts
+++ b/rx.js/rx-lite.d.ts
@@ -266,6 +266,27 @@ declare module Rx {
 		takeWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
 		where(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
 		filter(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>; // alias for where
+
+		/**
+		* Converts an existing observable sequence to an ES6 Compatible Promise
+		* @example
+		* var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);
+		* @param promiseCtor The constructor of the promise.
+		* @returns An ES6 compatible promise with the last value from the observable sequence.
+		*/
+		toPromise<TPromise extends IPromise<T>>(promiseCtor: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): TPromise; }): TPromise;
+		/**
+		* Converts an existing observable sequence to an ES6 Compatible Promise
+		* @example
+		* var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);
+		* 
+		* // With config
+		* Rx.config.Promise = RSVP.Promise;
+		* var promise = Rx.Observable.return(42).toPromise();
+		* @param [promiseCtor] The constructor of the promise. If not provided, it looks for it in Rx.config.Promise.
+		* @returns An ES6 compatible promise with the last value from the observable sequence.
+		*/
+		toPromise(promiseCtor?: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; }): IPromise<T>;
 	}
 
 	interface ObservableStatic {

From d6da8b051fb2647c7250064d5db9343062f17add Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 14:43:50 +0400
Subject: [PATCH 155/309] Extracted common part of definitions of rx.lite and
 rx.async into rx.async-lite.d.ts

---
 rx.js/rx.async-lite.d.ts | 61 ++++++++++++++++++++++++++++++++++++++++
 rx.js/rx.async.d.ts      | 56 +-----------------------------------
 2 files changed, 62 insertions(+), 55 deletions(-)
 create mode 100644 rx.js/rx.async-lite.d.ts

diff --git a/rx.js/rx.async-lite.d.ts b/rx.js/rx.async-lite.d.ts
new file mode 100644
index 000000000..1b5bafd98
--- /dev/null
+++ b/rx.js/rx.async-lite.d.ts
@@ -0,0 +1,61 @@
+// This file contains common part of defintions for rx.async.d.ts and rx.lite.d.ts
+// Do not include the file separately.
+
+declare module Rx {
+    interface ObservableStatic {
+		/**
+		* Invokes the asynchronous function, surfacing the result through an observable sequence.
+		* @param functionAsync Asynchronous function which returns a Promise to run.
+		* @returns An observable sequence exposing the function's result value, or an exception.
+		*/
+		startAsync<T>(functionAsync: () => IPromise<T>): Observable<T>;
+
+		fromCallback: {
+			// with single result callback without selector
+			<TResult>(func: (callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
+			<T1, TResult>(func: (arg1: T1, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
+			<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
+			<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+			// with any callback with selector
+			<TCallbackResult, TResult>(func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): () => Observable<TResult>;
+			<T1, TCallbackResult, TResult>(func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1) => Observable<TResult>;
+			<T1, T2, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2) => Observable<TResult>;
+			<T1, T2, T3, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+			// with any callback without selector
+			<TResult>(func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
+			<T1, TResult>(func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
+			<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
+			<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+			// with any function with selector
+			<TCallbackResult, TResult>(func: Function, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (...args: any[]) => Observable<TResult>;
+			// with any function without selector
+			<TResult>(func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable<TResult>;
+		};
+
+		fromNodeCallback: {
+			// with single result callback without selector
+			<T>(func: (callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): () => Observable<T>;
+			<T1, T>(func: (arg1: T1, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<T>;
+			<T1, T2, T>(func: (arg1: T1, arg2: T2, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<T>;
+			<T1, T2, T3, T>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<T>;
+			// with any callback with selector
+			<TC, TR>(func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): () => Observable<TR>;
+			<T1, TC, TR>(func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1) => Observable<TR>;
+			<T1, T2, TC, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2) => Observable<TR>;
+			<T1, T2, T3, TC, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
+			// with any callback without selector
+			<TR>(func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable<TR>;
+			<T1, TR>(func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TR>;
+			<T1, T2, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TR>;
+			<T1, T2, T3, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
+			// with any function with selector
+			<TC, T>(func: Function, scheduler: IScheduler, context: any, selector: (results: TC[]) => T): (...args: any[]) => Observable<T>;
+			// with any function without selector
+			<T>(func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable<T>;
+		};
+
+		fromEvent<T>(element: NodeList, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
+		fromEvent<T>(element: Node, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
+        fromEventPattern<T>(addHandler: (handler: Function) => void, removeHandler: (handler: Function) => void, selector?: (arguments: any[])=>T): Observable<T>;
+	}
+}
diff --git a/rx.js/rx.async.d.ts b/rx.js/rx.async.d.ts
index 19406e9ae..f345da7d9 100644
--- a/rx.js/rx.async.d.ts
+++ b/rx.js/rx.async.d.ts
@@ -5,18 +5,12 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 ///<reference path="rx.d.ts" />
+///<reference path="rx.async-lite.d.ts" />
 
 declare module Rx {
     interface ObservableStatic {
 		start<T>(func: () => T, scheduler?: IScheduler, context?: any): Observable<T>;
 
-		/**
-		* Invokes the asynchronous function, surfacing the result through an observable sequence.
-		* @param functionAsync Asynchronous function which returns a Promise to run.
-		* @returns An observable sequence exposing the function's result value, or an exception.
-		*/
-		startAsync<T>(functionAsync: () => IPromise<T>): Observable<T>;
-
         toAsync<TResult>(func: () => TResult, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
 		toAsync<T1, TResult>(func: (arg1: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
 		toAsync<T1, TResult>(func: (arg1?: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1) => Observable<TResult>;
@@ -42,53 +36,5 @@ declare module Rx {
 		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
 		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
 		toAsync<T1, T2, T3, T4, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
-
-		fromCallback: {
-			// with single result callback without selector
-			<TResult>(func: (callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
-			<T1, TResult>(func: (arg1: T1, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
-			<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
-			<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
-			// with any callback with selector
-			<TCallbackResult, TResult>(func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): () => Observable<TResult>;
-			<T1, TCallbackResult, TResult>(func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1) => Observable<TResult>;
-			<T1, T2, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2) => Observable<TResult>;
-			<T1, T2, T3, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
-			// with any callback without selector
-			<TResult>(func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
-			<T1, TResult>(func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
-			<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
-			<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
-			// with any function with selector
-			<TCallbackResult, TResult>(func: Function, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (...args: any[]) => Observable<TResult>;
-			// with any function without selector
-			<TResult>(func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable<TResult>;
-		};
-
-		fromNodeCallback: {
-			// with single result callback without selector
-			<T>(func: (callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): () => Observable<T>;
-			<T1, T>(func: (arg1: T1, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<T>;
-			<T1, T2, T>(func: (arg1: T1, arg2: T2, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<T>;
-			<T1, T2, T3, T>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<T>;
-			// with any callback with selector
-			<TC, TR>(func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): () => Observable<TR>;
-			<T1, TC, TR>(func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1) => Observable<TR>;
-			<T1, T2, TC, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2) => Observable<TR>;
-			<T1, T2, T3, TC, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
-			// with any callback without selector
-			<TR>(func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable<TR>;
-			<T1, TR>(func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TR>;
-			<T1, T2, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TR>;
-			<T1, T2, T3, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
-			// with any function with selector
-			<TC, T>(func: Function, scheduler: IScheduler, context: any, selector: (results: TC[]) => T): (...args: any[]) => Observable<T>;
-			// with any function without selector
-			<T>(func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable<T>;
-		};
-
-		fromEvent<T>(element: NodeList, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
-		fromEvent<T>(element: Node, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
-        fromEventPattern<T>(addHandler: (handler: Function) => void, removeHandler: (handler: Function) => void, selector?: (arguments: any[])=>T): Observable<T>;
 	}
 }

From f8031be545df2e96a0665cdc7a254b51a42131cd Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 15:40:10 +0400
Subject: [PATCH 156/309] Added `multicast` and `share` methods in
 rx.binding.d.ts; Fixed defintions of `publish`, `publishLast` and
 `publishValue` methods.

---
 rx.js/rx.binding.d.ts | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/rx.js/rx.binding.d.ts b/rx.js/rx.binding.d.ts
index 6d0f1db3c..b75bc55f4 100644
--- a/rx.js/rx.binding.d.ts
+++ b/rx.js/rx.binding.d.ts
@@ -31,18 +31,30 @@ declare module Rx {
     }
 
     interface ConnectableObservableStatic {
-        new <T>(): ConnectableObservable<T>;
+        new <T>(source: Observable<T>, subject: ISubject<T>): ConnectableObservable<T>;
 	}
 
 	export var ConnectableObservable: ConnectableObservableStatic;
 
 	export interface Observable<T> {
+		multicast(subject: Observable<T>): ConnectableObservable<T>;
+		multicast<TResult>(subjectSelector: () => ISubject<T>, selector: (source: ConnectableObservable<T>) => Observable<T>): Observable<T>;
 		publish(): ConnectableObservable<T>;
-		publish<TResult>(selector: (item: T) => Observable<TResult>): ConnectableObservable<TResult>;
+		publish<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>): Observable<TResult>;
+		/**
+		* Returns an observable sequence that shares a single subscription to the underlying sequence.
+		* This operator is a specialization of publish which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
+		* 
+		* @example
+		* var res = source.share();
+		* 
+		* @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
+		*/
+		share(): Observable<T>;
 		publishLast(): ConnectableObservable<T>;
-		publishLast<TResult>(selector: (item: T) => Observable<TResult>): ConnectableObservable<TResult>;
+		publishLast<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>): Observable<TResult>;
 		publishValue(initialValue: T): ConnectableObservable<T>;
-		publishValue<TResult>(selector: (item: T) => TResult, initialValue: TResult): ConnectableObservable<TResult>;
+		publishValue<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>, initialValue: TResult): Observable<TResult>;
 
 		replay(selector?: (source: Observable<T>) => ReplaySubject<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
 	}

From 1094494b18d329b3d3019af548fb110834d904a3 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 15:52:52 +0400
Subject: [PATCH 157/309] Fixed `publishValue` and `replay` method signatures;
 Added `shareValue` and `replayWhileObserved` methods.

---
 rx.js/rx.binding.d.ts | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/rx.js/rx.binding.d.ts b/rx.js/rx.binding.d.ts
index b75bc55f4..9fd94191a 100644
--- a/rx.js/rx.binding.d.ts
+++ b/rx.js/rx.binding.d.ts
@@ -54,8 +54,20 @@ declare module Rx {
 		publishLast(): ConnectableObservable<T>;
 		publishLast<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>): Observable<TResult>;
 		publishValue(initialValue: T): ConnectableObservable<T>;
-		publishValue<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>, initialValue: TResult): Observable<TResult>;
-
-		replay(selector?: (source: Observable<T>) => ReplaySubject<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
+		publishValue<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>, initialValue: T): Observable<TResult>;
+		/**
+		* Returns an observable sequence that shares a single subscription to the underlying sequence and starts with an initialValue.
+		* This operator is a specialization of publishValue which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
+		* 
+		* @example
+		* var res = source.shareValue(42);
+		* 
+		* @param initialValue Initial value received by observers upon subscription.
+		* @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
+		*/
+		shareValue(initialValue: T): Observable<T>;
+		replay(selector?: boolean, bufferSize?: number, window?: number, scheduler?: IScheduler): ConnectableObservable<T>;	// hack to catch first omitted parameter
+		replay(selector: (source: ConnectableObservable<T>) => Observable<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): Observable<T>;
+		replayWhileObserved(bufferSize?: number, window?: number, scheduler?: IScheduler): Observable<T>;
 	}
 }

From 723779e7c1274539805361306fc24024c2e1b5a8 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 16:05:20 +0400
Subject: [PATCH 158/309] Extracted common part of definitions of
 rx.binding.d.ts and rx.lite.d.ts into rx.binding-lite.d.ts.

---
 rx.js/rx.binding-lite.d.ts | 67 ++++++++++++++++++++++++++++++++++++++
 rx.js/rx.binding.d.ts      | 63 ++---------------------------------
 2 files changed, 69 insertions(+), 61 deletions(-)
 create mode 100644 rx.js/rx.binding-lite.d.ts

diff --git a/rx.js/rx.binding-lite.d.ts b/rx.js/rx.binding-lite.d.ts
new file mode 100644
index 000000000..1ce2b00b9
--- /dev/null
+++ b/rx.js/rx.binding-lite.d.ts
@@ -0,0 +1,67 @@
+// This file contains common part of defintions for rx.binding.d.ts and rx.lite.d.ts
+// Do not include the file separately.
+
+declare module Rx {
+	export interface BehaviorSubject<T> extends Subject<T> {
+	}
+
+	interface BehaviorSubjectStatic {
+		new <T>(initialValue: T): BehaviorSubject<T>;
+	}
+
+	export var BehaviorSubject: BehaviorSubjectStatic;
+
+	export interface ReplaySubject<T> extends Subject<T> {
+	}
+
+	interface ReplaySubjectStatic {
+		new <T>(bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
+	}
+
+	export var ReplaySubject: ReplaySubjectStatic;
+
+	interface ConnectableObservable<T> extends Observable<T> {
+		connect(): IDisposable;
+		refCount(): Observable<T>;
+    }
+
+    interface ConnectableObservableStatic {
+        new <T>(): ConnectableObservable<T>;
+	}
+
+	export var ConnectableObservable: ConnectableObservableStatic;
+
+	export interface Observable<T> {
+		multicast(subject: Observable<T>): ConnectableObservable<T>;
+		multicast<TResult>(subjectSelector: () => ISubject<T>, selector: (source: ConnectableObservable<T>) => Observable<T>): Observable<T>;
+		publish(): ConnectableObservable<T>;
+		publish<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>): Observable<TResult>;
+		/**
+		* Returns an observable sequence that shares a single subscription to the underlying sequence.
+		* This operator is a specialization of publish which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
+		* 
+		* @example
+		* var res = source.share();
+		* 
+		* @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
+		*/
+		share(): Observable<T>;
+		publishLast(): ConnectableObservable<T>;
+		publishLast<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>): Observable<TResult>;
+		publishValue(initialValue: T): ConnectableObservable<T>;
+		publishValue<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>, initialValue: T): Observable<TResult>;
+		/**
+		* Returns an observable sequence that shares a single subscription to the underlying sequence and starts with an initialValue.
+		* This operator is a specialization of publishValue which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
+		* 
+		* @example
+		* var res = source.shareValue(42);
+		* 
+		* @param initialValue Initial value received by observers upon subscription.
+		* @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
+		*/
+		shareValue(initialValue: T): Observable<T>;
+		replay(selector?: boolean, bufferSize?: number, window?: number, scheduler?: IScheduler): ConnectableObservable<T>;	// hack to catch first omitted parameter
+		replay(selector: (source: ConnectableObservable<T>) => Observable<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): Observable<T>;
+	}
+}
diff --git a/rx.js/rx.binding.d.ts b/rx.js/rx.binding.d.ts
index 9fd94191a..d98653719 100644
--- a/rx.js/rx.binding.d.ts
+++ b/rx.js/rx.binding.d.ts
@@ -1,73 +1,14 @@
-// Type definitions for RxJS-Binding package
+// Type definitions for RxJS-Binding v2.2.17
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 ///<reference path="rx.d.ts" />
+///<reference path="rx.binding-lite.d.ts" />
 
 declare module Rx {
-	export interface BehaviorSubject<T> extends Subject<T> {
-	}
-
-	interface BehaviorSubjectStatic {
-		new <T>(initialValue: T): BehaviorSubject<T>;
-	}
-
-	export var BehaviorSubject: BehaviorSubjectStatic;
-
-	export interface ReplaySubject<T> extends Subject<T> {
-	}
-
-	interface ReplaySubjectStatic {
-		new <T>(bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
-	}
-
-	export var ReplaySubject: ReplaySubjectStatic;
-
-	interface ConnectableObservable<T> extends Observable<T> {
-		connect(): IDisposable;
-		refCount(): Observable<T>;
-    }
-
-    interface ConnectableObservableStatic {
-        new <T>(source: Observable<T>, subject: ISubject<T>): ConnectableObservable<T>;
-	}
-
-	export var ConnectableObservable: ConnectableObservableStatic;
-
 	export interface Observable<T> {
-		multicast(subject: Observable<T>): ConnectableObservable<T>;
-		multicast<TResult>(subjectSelector: () => ISubject<T>, selector: (source: ConnectableObservable<T>) => Observable<T>): Observable<T>;
-		publish(): ConnectableObservable<T>;
-		publish<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>): Observable<TResult>;
-		/**
-		* Returns an observable sequence that shares a single subscription to the underlying sequence.
-		* This operator is a specialization of publish which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
-		* 
-		* @example
-		* var res = source.share();
-		* 
-		* @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
-		*/
-		share(): Observable<T>;
-		publishLast(): ConnectableObservable<T>;
-		publishLast<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>): Observable<TResult>;
-		publishValue(initialValue: T): ConnectableObservable<T>;
-		publishValue<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>, initialValue: T): Observable<TResult>;
-		/**
-		* Returns an observable sequence that shares a single subscription to the underlying sequence and starts with an initialValue.
-		* This operator is a specialization of publishValue which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
-		* 
-		* @example
-		* var res = source.shareValue(42);
-		* 
-		* @param initialValue Initial value received by observers upon subscription.
-		* @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
-		*/
-		shareValue(initialValue: T): Observable<T>;
-		replay(selector?: boolean, bufferSize?: number, window?: number, scheduler?: IScheduler): ConnectableObservable<T>;	// hack to catch first omitted parameter
-		replay(selector: (source: ConnectableObservable<T>) => Observable<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): Observable<T>;
 		replayWhileObserved(bufferSize?: number, window?: number, scheduler?: IScheduler): Observable<T>;
 	}
 }

From 2d8a49a676a02e635fc5e712f000b963c724f8a8 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 16:09:01 +0400
Subject: [PATCH 159/309] Added reference of rx-lite.d.ts to
 rx.binding-lite.d.ts.

---
 rx.js/rx.binding-lite.d.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/rx.js/rx.binding-lite.d.ts b/rx.js/rx.binding-lite.d.ts
index 1ce2b00b9..1e5d95eaf 100644
--- a/rx.js/rx.binding-lite.d.ts
+++ b/rx.js/rx.binding-lite.d.ts
@@ -1,6 +1,8 @@
 // This file contains common part of defintions for rx.binding.d.ts and rx.lite.d.ts
 // Do not include the file separately.
 
+///<reference path="rx-lite.d.ts"/>
+
 declare module Rx {
 	export interface BehaviorSubject<T> extends Subject<T> {
 	}

From eea2b04a5a34bed542053f2f6e960adfc3be656a Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 16:16:46 +0400
Subject: [PATCH 160/309] Renamed lighted versions to names without .d.ts to
 exclude from building.

---
 rx.js/{rx-lite.d.ts => rx-lite.ts}                 | 0
 rx.js/{rx.async-lite.d.ts => rx.async-lite.ts}     | 0
 rx.js/rx.async.d.ts                                | 2 +-
 rx.js/{rx.binding-lite.d.ts => rx.binding-lite.ts} | 0
 rx.js/rx.binding.d.ts                              | 2 +-
 rx.js/rx.d.ts                                      | 2 +-
 6 files changed, 3 insertions(+), 3 deletions(-)
 rename rx.js/{rx-lite.d.ts => rx-lite.ts} (100%)
 rename rx.js/{rx.async-lite.d.ts => rx.async-lite.ts} (100%)
 rename rx.js/{rx.binding-lite.d.ts => rx.binding-lite.ts} (100%)

diff --git a/rx.js/rx-lite.d.ts b/rx.js/rx-lite.ts
similarity index 100%
rename from rx.js/rx-lite.d.ts
rename to rx.js/rx-lite.ts
diff --git a/rx.js/rx.async-lite.d.ts b/rx.js/rx.async-lite.ts
similarity index 100%
rename from rx.js/rx.async-lite.d.ts
rename to rx.js/rx.async-lite.ts
diff --git a/rx.js/rx.async.d.ts b/rx.js/rx.async.d.ts
index f345da7d9..45bf45236 100644
--- a/rx.js/rx.async.d.ts
+++ b/rx.js/rx.async.d.ts
@@ -5,7 +5,7 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 ///<reference path="rx.d.ts" />
-///<reference path="rx.async-lite.d.ts" />
+///<reference path="rx.async-lite.ts" />
 
 declare module Rx {
     interface ObservableStatic {
diff --git a/rx.js/rx.binding-lite.d.ts b/rx.js/rx.binding-lite.ts
similarity index 100%
rename from rx.js/rx.binding-lite.d.ts
rename to rx.js/rx.binding-lite.ts
diff --git a/rx.js/rx.binding.d.ts b/rx.js/rx.binding.d.ts
index d98653719..505522e38 100644
--- a/rx.js/rx.binding.d.ts
+++ b/rx.js/rx.binding.d.ts
@@ -5,7 +5,7 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 ///<reference path="rx.d.ts" />
-///<reference path="rx.binding-lite.d.ts" />
+///<reference path="rx.binding-lite.ts" />
 
 declare module Rx {
 	export interface Observable<T> {
diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index 0b3b3cdf7..2cf1d38b8 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -4,7 +4,7 @@
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-///<reference path="rx-lite.d.ts"/>
+///<reference path="rx-lite.ts"/>
 
 declare module Rx {
 	export interface IScheduler {

From 4800dc38a784a92edb6b9f0f724941f4332be2a7 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 16:20:39 +0400
Subject: [PATCH 161/309] Fixed reference in rx.binding-lite.ts

---
 rx.js/rx.binding-lite.ts | 2 --
 1 file changed, 2 deletions(-)

diff --git a/rx.js/rx.binding-lite.ts b/rx.js/rx.binding-lite.ts
index 1e5d95eaf..1ce2b00b9 100644
--- a/rx.js/rx.binding-lite.ts
+++ b/rx.js/rx.binding-lite.ts
@@ -1,8 +1,6 @@
 // This file contains common part of defintions for rx.binding.d.ts and rx.lite.d.ts
 // Do not include the file separately.
 
-///<reference path="rx-lite.d.ts"/>
-
 declare module Rx {
 	export interface BehaviorSubject<T> extends Subject<T> {
 	}

From a837a49c6920a792412de652c3d5b834a12a8c4b Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 16:42:45 +0400
Subject: [PATCH 162/309] Turned `Observer` from class to interfaces.

---
 rx.js/rx-lite.ts         | 14 +++++++++++++-
 rx.js/rx.async.d.ts      |  2 +-
 rx.js/rx.binding-lite.ts |  2 ++
 rx.js/rx.d.ts            | 15 ++++-----------
 4 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/rx.js/rx-lite.ts b/rx.js/rx-lite.ts
index 0c1391c41..1e387af48 100644
--- a/rx.js/rx-lite.ts
+++ b/rx.js/rx-lite.ts
@@ -133,7 +133,7 @@ declare module Rx {
 
 	// Notifications
 	export class Notification<T> {
-		accept(observer: Observer<T>): void;
+		accept(observer: IObserver<T>): void;
 		accept<TResult>(onNext: (value: T) => TResult, onError?: (exception: any) => TResult, onCompleted?: () => TResult): TResult;
 		toObservable(scheduler?: IScheduler): Observable<T>;
 		hasValue: boolean;
@@ -164,6 +164,18 @@ declare module Rx {
 		onCompleted(): void;
 	}
 
+	export interface Observer<T> extends IObserver<T> {
+		toNotifier(): (notification: Notification<T>) => void;
+		asObserver(): Observer<T>;
+	}
+
+	interface ObserverStatic {
+		create<T>(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observer<T>;
+		fromNotifier<T>(handler: (notification: Notification<T>) => void): Observer<T>;
+	}
+
+	export var Observer: ObserverStatic;
+
 	export interface IObservable<T> {
 		subscribe(observer: Observer<T>): IDisposable;
 		subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;
diff --git a/rx.js/rx.async.d.ts b/rx.js/rx.async.d.ts
index 45bf45236..b24191ae4 100644
--- a/rx.js/rx.async.d.ts
+++ b/rx.js/rx.async.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Async v2.2.15
+// Type definitions for RxJS-Async v2.2.17
 // Project: http://rx.codeplex.com/
 // Definitions by: zoetrope <https://github.com/zoetrope>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
diff --git a/rx.js/rx.binding-lite.ts b/rx.js/rx.binding-lite.ts
index 1ce2b00b9..fa1098368 100644
--- a/rx.js/rx.binding-lite.ts
+++ b/rx.js/rx.binding-lite.ts
@@ -1,6 +1,8 @@
 // This file contains common part of defintions for rx.binding.d.ts and rx.lite.d.ts
 // Do not include the file separately.
 
+///<reference path="rx-lite.ts"/>
+
 declare module Rx {
 	export interface BehaviorSubject<T> extends Subject<T> {
 	}
diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index 2cf1d38b8..7b3e1c073 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -48,24 +48,17 @@ declare module Rx {
 	}
 
 	// Observer
-	export class Observer<T> implements IObserver<T> {
-		onNext(value: T): void;
-		onError(exception: any): void;
-		onCompleted(): void;
-
-		toNotifier(): (notification: Notification<T>) =>void;
-		asObserver(): Observer<T>;
+	export interface Observer<T> {
 		checked(): Observer<any>;
+	}
 
-		static create<T>(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observer<T>;
-		static fromNotifier<T>(handler: (notification: Notification<T>) => void): Observer<T>;
-		
+	interface ObserverStatic {
 		/**
 		* Schedules the invocation of observer methods on the given scheduler.
 		* @param scheduler Scheduler to schedule observer messages on.
 		* @returns Observer whose messages are scheduled on the given scheduler.
 		*/
-		static notifyOn<T>(scheduler: IScheduler): Observer<T>;
+		notifyOn<T>(scheduler: IScheduler): Observer<T>;
 	}
 
 	export interface Observable<T> {

From cf83a0f9bff022c98728294d9d9b54f6747985a0 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 16:48:03 +0400
Subject: [PATCH 163/309] Fixed `Observer` derived class in rx.testing.d.ts

---
 rx.js/rx.testing.d.ts | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/rx.js/rx.testing.d.ts b/rx.js/rx.testing.d.ts
index 69fcf2c13..f03b2de08 100644
--- a/rx.js/rx.testing.d.ts
+++ b/rx.js/rx.testing.d.ts
@@ -46,8 +46,13 @@ declare module Rx {
 		equals(other: Subscription): boolean;
 	}
 
-	export class MockObserver<T> extends Observer<T> {
-		constructor(scheduler: IScheduler);
+	export interface MockObserver<T> extends Observer<T> {
 		messages: Recorded[];
 	}
+
+	interface MockObserverStatic extends ObserverStatic {
+		new <T>(scheduler: IScheduler): MockObserver<T>;
+	}
+
+	export var MockObserver: MockObserverStatic;
 }

From d247ddf47b4919552fac636f3ba5f15fe2799e28 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 16:55:41 +0400
Subject: [PATCH 164/309] Removed incorrect methods from rx.time.d.ts and
 updated header;

---
 rx.js/rx.time.d.ts | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/rx.js/rx.time.d.ts b/rx.js/rx.time.d.ts
index 449cdd7f9..7e08c7949 100644
--- a/rx.js/rx.time.d.ts
+++ b/rx.js/rx.time.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Time v2.2.15
+// Type definitions for RxJS-Time v2.2.17
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
@@ -19,10 +19,6 @@ declare module Rx {
 	}
 
 	export interface Observable<T> {
-		ifThen(condition: () => boolean, thenSource: Observable<T>): Observable<T>;
-		ifThen(condition: () => boolean, thenSource: Observable<T>, elseSource: Observable<T>): Observable<T>;
-		ifThen(condition: () => boolean, thenSource: Observable<T>, scheduler: IScheduler): Observable<T>;
-
 		delay(dueTime: number, scheduler?: IScheduler): Observable<T>;
 		throttle(dueTime: number, scheduler?: IScheduler): Observable<T>;
 		windowWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): Observable<Observable<T>>;

From a396155280971964acbcea38d10a6e0ce837e131 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 17:14:07 +0400
Subject: [PATCH 165/309] Extracted common part of defintitions of rx.time.d.ts
 and rx.lite.d.ts into rx.time-lite.ts.

---
 rx.js/rx.time-lite.ts | 51 +++++++++++++++++++++++++++++++++++++++++++
 rx.js/rx.time.d.ts    | 41 +---------------------------------
 2 files changed, 52 insertions(+), 40 deletions(-)
 create mode 100644 rx.js/rx.time-lite.ts

diff --git a/rx.js/rx.time-lite.ts b/rx.js/rx.time-lite.ts
new file mode 100644
index 000000000..1082f1a7b
--- /dev/null
+++ b/rx.js/rx.time-lite.ts
@@ -0,0 +1,51 @@
+// This file contains common part of defintions for rx.time.d.ts and rx.lite.d.ts
+// Do not include the file separately.
+
+///<reference path="rx-lite.ts" />
+
+declare module Rx {
+	export interface TimeInterval<T> {
+		value: T;
+		interval: number;
+	}
+
+	export interface Timestamp<T> {
+		value: T;
+		timestamp: number;
+	}
+
+	export interface Observable<T> {
+		delay(dueTime: number, scheduler?: IScheduler): Observable<T>;
+		throttle(dueTime: number, scheduler?: IScheduler): Observable<T>;
+		timeInterval(scheduler?: IScheduler): Observable<TimeInterval<T>>;
+		timestamp(scheduler?: IScheduler): Observable<Timestamp<T>>;
+		sample(interval: number, scheduler?: IScheduler): Observable<T>;
+		sample<TSample>(sampler: Observable<TSample>, scheduler?: IScheduler): Observable<T>;
+		timeout(dueTime: Date, other?: Observable<T>, scheduler?: IScheduler): Observable<T>;
+		timeout(dueTime: number, other?: Observable<T>, scheduler?: IScheduler): Observable<T>;
+
+		delaySubscription(dueTime: number, scheduler?: IScheduler): Observable<T>;
+		delayWithSelector(delayDurationSelector: (item: T) => number): Observable<T>;
+		delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): Observable<T>;
+
+		timeoutWithSelector<TTimeout>(firstTimeout: Observable<TTimeout>, timeoutdurationSelector?: (item: T) => Observable<TTimeout>, other?: Observable<T>): Observable<T>;
+		throttleWithSelector<TTimeout>(throttleDurationSelector: (item: T) => Observable<TTimeout>): Observable<T>;
+
+		skipLastWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
+		takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): Observable<T>;
+
+		takeLastBufferWithTime(duration: number, scheduler?: IScheduler): Observable<T[]>;
+		takeWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
+		skipWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
+
+		skipUntilWithTime(startTime: Date, scheduler?: IScheduler): Observable<T>;
+		takeUntilWithTime(endTime: Date, scheduler?: IScheduler): Observable<T>;
+	}
+
+	interface ObservableStatic {
+		interval(period: number, scheduler?: IScheduler): Observable<number>;
+		interval(dutTime: number, period: number, scheduler?: IScheduler): Observable<number>;
+		timer(dueTime: number, period: number, scheduler: IScheduler): Observable<number>;
+		timer(dueTime: number, scheduler: IScheduler): Observable<number>;
+	}
+}
diff --git a/rx.js/rx.time.d.ts b/rx.js/rx.time.d.ts
index 7e08c7949..994d9bf46 100644
--- a/rx.js/rx.time.d.ts
+++ b/rx.js/rx.time.d.ts
@@ -5,60 +5,21 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 ///<reference path="rx.d.ts" />
+///<reference path="rx.time-lite.ts" />
 
 declare module Rx {
-
-	export interface TimeInterval<T> {
-		value: T;
-		interval: number;
-	}
-
-	export interface Timestamp<T> {
-		value: T;
-		timestamp: number;
-	}
-
 	export interface Observable<T> {
-		delay(dueTime: number, scheduler?: IScheduler): Observable<T>;
-		throttle(dueTime: number, scheduler?: IScheduler): Observable<T>;
 		windowWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): Observable<Observable<T>>;
 		windowWithTime(timeSpan: number, scheduler?: IScheduler): Observable<Observable<T>>;
 		windowWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): Observable<Observable<T>>;
 		bufferWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): Observable<T[]>;
 		bufferWithTime(timeSpan: number, scheduler?: IScheduler): Observable<T[]>;
 		bufferWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): Observable<T[]>;
-		timeInterval(scheduler?: IScheduler): Observable<TimeInterval<T>>;
-		timestamp(scheduler?: IScheduler): Observable<Timestamp<T>>;
-		sample(interval: number, scheduler?: IScheduler): Observable<T>;
-		sample<TSample>(sampler: Observable<TSample>, scheduler?: IScheduler): Observable<T>;
-		timeout(dueTime: Date, other?: Observable<T>, scheduler?: IScheduler): Observable<T>;
-		timeout(dueTime: number, other?: Observable<T>, scheduler?: IScheduler): Observable<T>;
-
-		delaySubscription(dueTime: number, scheduler?: IScheduler): Observable<T>;
-		delayWithSelector(delayDurationSelector: (item: T) => number): Observable<T>;
-		delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): Observable<T>;
-
-		timeoutWithSelector<TTimeout>(firstTimeout: Observable<TTimeout>, timeoutdurationSelector?: (item: T) => Observable<TTimeout>, other?: Observable<T>): Observable<T>;
-		throttleWithSelector<TTimeout>(throttleDurationSelector: (item: T) => Observable<TTimeout>): Observable<T>;
-
-		skipLastWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
-		takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): Observable<T>;
-
-		takeLastBufferWithTime(duration: number, scheduler?: IScheduler): Observable<T[]>;
-		takeWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
-		skipWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
-
-		skipUntilWithTime(startTime: Date, scheduler?: IScheduler): Observable<T>;
-		takeUntilWithTime(endTime: Date, scheduler?: IScheduler): Observable<T>;
 	}
 
 	interface ObservableStatic {
-		interval(period: number, scheduler?: IScheduler): Observable<number>;
-		interval(dutTime: number, period: number, scheduler?: IScheduler): Observable<number>;
 		timer(dueTime: Date, period: number, scheduler: IScheduler): Observable<number>;
 		timer(dueTime: Date, scheduler: IScheduler): Observable<number>;
-		timer(dueTime: number, period: number, scheduler: IScheduler): Observable<number>;
-		timer(dueTime: number, scheduler: IScheduler): Observable<number>;
 
 		generateWithAbsoluteTime<TState, TResult>(
 			initialState: TState,

From fcbd7b6ba9cc4be42f6502dfd771c9f9fad4ada7 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 17:18:35 +0400
Subject: [PATCH 166/309] Extracted common part of definitions of
 rx.backpressure.d.ts and rx.lite.d.ts into rx.backpressure-lite.ts.

---
 rx.js/rx.backpressure-lite.ts | 39 +++++++++++++++++++++++++++++++++++
 rx.js/rx.backpressure.d.ts    | 38 +---------------------------------
 2 files changed, 40 insertions(+), 37 deletions(-)
 create mode 100644 rx.js/rx.backpressure-lite.ts

diff --git a/rx.js/rx.backpressure-lite.ts b/rx.js/rx.backpressure-lite.ts
new file mode 100644
index 000000000..52ff18225
--- /dev/null
+++ b/rx.js/rx.backpressure-lite.ts
@@ -0,0 +1,39 @@
+// This file contains common part of defintions for rx.backpressure.d.ts and rx.lite.d.ts
+// Do not include the file separately.
+
+declare module Rx {
+	export interface Observable<T> {
+		/**
+		* Pauses the underlying observable sequence based upon the observable sequence which yields true/false.
+		* @example
+		* var pauser = new Rx.Subject();
+		* var source = Rx.Observable.interval(100).pausable(pauser);
+		* @param pauser The observable sequence used to pause the underlying sequence.
+		* @returns The observable sequence which is paused based upon the pauser.
+		*/
+		pausable(pauser: Observable<boolean>): Observable<T>;
+
+		/**
+		* Pauses the underlying observable sequence based upon the observable sequence which yields true/false,
+		* and yields the values that were buffered while paused.
+		* @example
+		* var pauser = new Rx.Subject();
+		* var source = Rx.Observable.interval(100).pausableBuffered(pauser);
+		* @param pauser The observable sequence used to pause the underlying sequence.
+		* @returns The observable sequence which is paused based upon the pauser.
+		*/
+		pausableBuffered(pauser: Observable<boolean>): Observable<T>;
+
+		/**
+		* Attaches a controller to the observable sequence with the ability to queue.
+		* @example
+		* var source = Rx.Observable.interval(100).controlled();
+		* source.request(3); // Reads 3 values
+		*/
+		controlled(enableQueue?: boolean): ControlledObservable<T>;
+	}
+
+	export interface ControlledObservable<T> extends Observable<T> {
+		request(numberOfItems?: number): IDisposable;
+	}
+}
diff --git a/rx.js/rx.backpressure.d.ts b/rx.js/rx.backpressure.d.ts
index d09aa91e7..7d7b878fd 100644
--- a/rx.js/rx.backpressure.d.ts
+++ b/rx.js/rx.backpressure.d.ts
@@ -4,40 +4,4 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 ///<reference path="rx.d.ts" />
-
-declare module Rx {
-	export interface Observable<T> {
-		/**
-		* Pauses the underlying observable sequence based upon the observable sequence which yields true/false.
-		* @example
-		* var pauser = new Rx.Subject();
-		* var source = Rx.Observable.interval(100).pausable(pauser);
-		* @param pauser The observable sequence used to pause the underlying sequence.
-		* @returns The observable sequence which is paused based upon the pauser.
-		*/
-		pausable(pauser: Observable<boolean>): Observable<T>;
-
-		/**
-		* Pauses the underlying observable sequence based upon the observable sequence which yields true/false,
-		* and yields the values that were buffered while paused.
-		* @example
-		* var pauser = new Rx.Subject();
-		* var source = Rx.Observable.interval(100).pausableBuffered(pauser);
-		* @param pauser The observable sequence used to pause the underlying sequence.
-		* @returns The observable sequence which is paused based upon the pauser.
-		*/
-		pausableBuffered(pauser: Observable<boolean>): Observable<T>;
-
-		/**
-		* Attaches a controller to the observable sequence with the ability to queue.
-		* @example
-		* var source = Rx.Observable.interval(100).controlled();
-		* source.request(3); // Reads 3 values
-		*/
-		controlled(enableQueue?: boolean): ControlledObservable<T>;
-	}
-
-	export interface ControlledObservable<T> extends Observable<T> {
-		request(numberOfItems?: number): IDisposable;
-	}
-}
+///<reference path="rx.backpressure-lite.ts" />

From 0de8db56daf4b5779e24df7c104154a97d7a20ee Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 19 Mar 2014 17:19:26 +0400
Subject: [PATCH 167/309] Added rx.lite.d.ts with reference to all common parts
 with other modules and specific methods.

---
 rx.js/rx.lite.d.ts | 60 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 rx.js/rx.lite.d.ts

diff --git a/rx.js/rx.lite.d.ts b/rx.js/rx.lite.d.ts
new file mode 100644
index 000000000..c8f99ab5b
--- /dev/null
+++ b/rx.js/rx.lite.d.ts
@@ -0,0 +1,60 @@
+// Type definitions for RxJS-Lite v2.2.17
+// Project: http://rx.codeplex.com/
+// Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
+// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path="rx-lite.ts"/>
+///<reference path="rx.async-lite.ts" />
+///<reference path="rx.binding-lite.ts" />
+///<reference path="rx.time-lite.ts" />
+///<reference path="rx.backpressure-lite.ts" />
+
+declare module Rx {
+	export class Scheduler implements IScheduler {
+		constructor(
+			now: () => number,
+			schedule: (state: any, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable,
+			scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable,
+			scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable);
+
+		static normalize(timeSpan: number): number;
+
+		static immediate: IScheduler;
+		static currentThread: ICurrentThreadScheduler;
+		static timeout: IScheduler;
+
+		now(): number;
+
+		schedule(action: () => void): IDisposable;
+		scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+		scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
+		scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+		scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
+		scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+
+		scheduleRecursive(action: (action: () => void) => void): IDisposable;
+		scheduleRecursiveWithState<TState>(state: TState, action: (state: TState, action: (state: TState) => void) => void): IDisposable;
+		scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
+		scheduleRecursiveWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
+		scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
+		scheduleRecursiveWithRelativeAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
+
+		schedulePeriodic(period: number, action: () => void): IDisposable;
+		schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
+	}
+
+	export interface Observable<T> {
+		shareReplay(bufferSize?: number, window?: number, scheduler?: IScheduler): Observable<T>;	// same as replayWhileObserved in rx.binding.d.ts
+	}
+
+	export interface ObservableStatic {
+		generateWithTime<TState, TResult>(
+			initialState: TState,
+			condition: (state: TState) => boolean,
+			iterate: (state: TState) => TState,
+			resultSelector: (state: TState) => TResult,
+			timeSelector: (state: TState) => number,
+			scheduler?: IScheduler): Observable<TResult>;
+	}
+}

From ab5886b01f4b5f39b9c0eeed04ec00585d956994 Mon Sep 17 00:00:00 2001
From: John Purcell <jpurcell@moodlerooms.com>
Date: Wed, 19 Mar 2014 13:03:19 -0400
Subject: [PATCH 168/309] Expose agent on supertest and cookie methods on
 superagent

---
 superagent/superagent.d.ts   |  2 ++
 supertest/supertest-tests.ts | 16 ++++++++++++++++
 supertest/supertest.d.ts     |  2 ++
 3 files changed, 20 insertions(+)

diff --git a/superagent/superagent.d.ts b/superagent/superagent.d.ts
index 9ff52099c..860f70ea3 100644
--- a/superagent/superagent.d.ts
+++ b/superagent/superagent.d.ts
@@ -79,6 +79,8 @@ declare module "superagent" {
     unsubscribe(url: string, callback?: (err: Error, res: Response) => void): Request;
     patch(url: string, callback?: (err: Error, res: Response) => void): Request;
     parse(fn: Function): Request;
+    saveCookies(res: Response): void;
+    attachCookies(req: Request): void;
   }
 
   export function agent(): Agent;
diff --git a/supertest/supertest-tests.ts b/supertest/supertest-tests.ts
index 1a1d60db7..c4bdfb271 100644
--- a/supertest/supertest-tests.ts
+++ b/supertest/supertest-tests.ts
@@ -14,3 +14,19 @@ supertest(app)
   .end((err, res) => {
     if (err) throw err;
   });
+
+// cookie scenario
+var request = supertest(app);
+var agent = supertest.agent();
+request
+  .post('/login')
+  .end((err, res) => {
+    if (err) throw err;
+    agent.saveCookies(res);
+
+    var req = request.get('/admin');
+    agent.attachCookies(req);
+    req.expect(200, (err, res) => {
+      if (err) throw err;
+    });
+  });
\ No newline at end of file
diff --git a/supertest/supertest.d.ts b/supertest/supertest.d.ts
index 8a2069d33..1b38f4d2f 100644
--- a/supertest/supertest.d.ts
+++ b/supertest/supertest.d.ts
@@ -46,6 +46,8 @@ declare module "supertest" {
       unsubscribe(url: string): Test;
       patch(url: string): Test;
     }
+
+    function agent(): superagent.Agent;
   }
 
   function supertest(app: any): supertest.SuperTest;

From 941d790d6f42a00fd1b7f2daa65f44c1f881a77b Mon Sep 17 00:00:00 2001
From: John Purcell <jpurcell@moodlerooms.com>
Date: Wed, 19 Mar 2014 16:53:31 -0400
Subject: [PATCH 169/309] Update crypto.Hmac.update and crypto.Hmac.digest
 methods to the correct signature

---
 node/node-tests.ts | 8 ++++++++
 node/node.d.ts     | 4 ++--
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/node/node-tests.ts b/node/node-tests.ts
index 397a9dfa4..f82fb9530 100644
--- a/node/node-tests.ts
+++ b/node/node-tests.ts
@@ -6,6 +6,7 @@ import events = require("events");
 import zlib = require("zlib");
 import url = require('url');
 import util = require("util");
+import crypto = require("crypto");
 
 assert(1 + 1 - 2 === 0, "The universe isn't how it should.");
 
@@ -80,3 +81,10 @@ function stream_readable_pipe_test() {
     var w = fs.createWriteStream('file.txt.gz');
     r.pipe(z).pipe(w);
 }
+
+
+////////////////////////////////////////////////////
+/// Crypto tests : http://nodejs.org/api/crypto.html
+////////////////////////////////////////////////////
+
+var hmacResult: string = crypto.createHmac('md5', 'hello').update('world').digest('hex');
diff --git a/node/node.d.ts b/node/node.d.ts
index a0473ad8b..2e368c314 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -1017,8 +1017,8 @@ declare module "crypto" {
         digest(encoding?: string): string;
     }
     interface Hmac {
-        update(data: any): void;
-        digest(encoding?: string): void;
+        update(data: any, input_encoding?: string): Hmac;
+        digest(encoding?: string): string;
     }
     export function createCipher(algorithm: string, password: any): Cipher;
     export function createCipheriv(algorithm: string, key: any, iv: any): Cipher;

From efc61c9d5555c7ff04901f310fe1294414b14edd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=A1clav=20Oborn=C3=ADk?= <register.ufon@gmail.com>
Date: Thu, 20 Mar 2014 07:57:12 +0100
Subject: [PATCH 170/309] added handshake data to socket.io Socket interface

---
 socket.io/socket.io.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/socket.io/socket.io.d.ts b/socket.io/socket.io.d.ts
index be79b2dcd..184468b12 100644
--- a/socket.io/socket.io.d.ts
+++ b/socket.io/socket.io.d.ts
@@ -20,6 +20,7 @@ declare module "socket.io" {
     log: any;
     volatile: any;
     broadcast: any;
+    handshake: any;
     in(room: string): Socket;
     to(room: string): Socket;
     join(name: string, fn: Function): Socket;

From 077b00386ca59961d8d548c9f0f23bd1653b22af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=A1clav=20Oborn=C3=ADk?= <register.ufon@gmail.com>
Date: Thu, 20 Mar 2014 08:03:46 +0100
Subject: [PATCH 171/309] Override set method for supertest Request

---
 supertest/supertest.d.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/supertest/supertest.d.ts b/supertest/supertest.d.ts
index 8a2069d33..d13f7d595 100644
--- a/supertest/supertest.d.ts
+++ b/supertest/supertest.d.ts
@@ -19,6 +19,8 @@ declare module "supertest" {
       expect(body: Object, callback?: (err: Error, res: superagent.Response) => void): Test;
       expect(field: string, val: string, callback?: (err: Error, res: superagent.Response) => void): Test;
       expect(field: string, val: RegExp, callback?: (err: Error, res: superagent.Response) => void): Test;
+      set(field: string, val: string): Test;
+      set(field: Object): Test;
     }
 
     interface SuperTest {

From efcd438cbc4889ba8e0b7fc1d828810c27ddff0c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=A1clav=20Oborn=C3=ADk?= <register.ufon@gmail.com>
Date: Thu, 20 Mar 2014 08:19:49 +0100
Subject: [PATCH 172/309] Supertest - added query, send methods

---
 supertest/supertest.d.ts | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/supertest/supertest.d.ts b/supertest/supertest.d.ts
index d13f7d595..8bca76070 100644
--- a/supertest/supertest.d.ts
+++ b/supertest/supertest.d.ts
@@ -21,6 +21,9 @@ declare module "supertest" {
       expect(field: string, val: RegExp, callback?: (err: Error, res: superagent.Response) => void): Test;
       set(field: string, val: string): Test;
       set(field: Object): Test;
+      query(val: Object): Test;
+      send(data: string): Test;
+      send(data: Object): Test;
     }
 
     interface SuperTest {

From 8a2f7f1a1d5d18d3bc6243d79cea8baa27fa3567 Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Thu, 20 Mar 2014 17:20:29 +0900
Subject: [PATCH 173/309] Added assert.d.ts

---
 README.md              |  1 +
 assert/assert-tests.ts | 19 +++++++++++++++
 assert/assert.d.ts     | 53 ++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 73 insertions(+)
 create mode 100644 assert/assert-tests.ts
 create mode 100644 assert/assert.d.ts

diff --git a/README.md b/README.md
index 1ead84bb8..a3c0aa08d 100755
--- a/README.md
+++ b/README.md
@@ -37,6 +37,7 @@ List of Definitions
 * [Angular UI Bootstrap](http://angular-ui.github.io/bootstrap) (by [Brian Surowiec](https://github.com/xt0rted))
 * [AppFramework](http://app-framework-software.intel.com/) (by [Kyo Ago](https://github.com/kyo-ago))
 * [Arbiter](http://arbiterjs.com/) (by [Arash Shakery](https://github.com/arash16))
+* [assert](https://github.com/Jxck/assert) (by [vvakame](https://github.com/vvakame))
 * [async](https://github.com/caolan/async) (by [Boris Yankov](https://github.com/borisyankov))
 * [Backbone.js](http://backbonejs.org/) (by [Boris Yankov](https://github.com/borisyankov))
 * [Backbone Relational](http://backbonerelational.org/) (by [Eirik Hoem](https://github.com/eirikhm))
diff --git a/assert/assert-tests.ts b/assert/assert-tests.ts
new file mode 100644
index 000000000..b01703e4d
--- /dev/null
+++ b/assert/assert-tests.ts
@@ -0,0 +1,19 @@
+/// <reference path="./assert.d.ts" />
+
+assert(1 + 1 - 2 === 0, "The universe isn't how it should.");
+
+assert.deepEqual({ x: { y: 3 } }, { x: { y: 3 } }, "DEEP WENT DERP");
+
+assert.equal(3, "3", "uses == comparator");
+
+assert.notStrictEqual(2, "2", "uses === comparator");
+
+assert.throws(() => {
+    throw "a hammer at your face";
+}, undefined, "DODGED IT");
+
+assert.doesNotThrow(() => {
+    if (false) {
+        throw "a hammer at your face";
+    }
+}, undefined, "What the...*crunch*");
diff --git a/assert/assert.d.ts b/assert/assert.d.ts
new file mode 100644
index 000000000..b54eae7fa
--- /dev/null
+++ b/assert/assert.d.ts
@@ -0,0 +1,53 @@
+// Type definitions for assert and power-assert
+// Project: https://github.com/Jxck/assert
+// Project: https://github.com/twada/power-assert
+// Definitions by: vvakame <https://github.com/vvakame>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// copy from assert external module in node.d.ts
+
+function assert(value:any, message?:string):void;
+module assert {
+    export class AssertionError implements Error {
+        name:string;
+        message:string;
+        actual:any;
+        expected:any;
+        operator:string;
+        generatedMessage:boolean;
+
+        constructor(options?:{message?: string; actual?: any; expected?: any; operator?: string; stackStartFunction?: Function});
+    }
+
+    export function fail(actual?:any, expected?:any, message?:string, operator?:string):void;
+
+    export function ok(value:any, message?:string):void;
+
+    export function equal(actual:any, expected:any, message?:string):void;
+
+    export function notEqual(actual:any, expected:any, message?:string):void;
+
+    export function deepEqual(actual:any, expected:any, message?:string):void;
+
+    export function notDeepEqual(acutal:any, expected:any, message?:string):void;
+
+    export function strictEqual(actual:any, expected:any, message?:string):void;
+
+    export function notStrictEqual(actual:any, expected:any, message?:string):void;
+
+    export var throws:{
+        (block:Function, message?:string): void;
+        (block:Function, error:Function, message?:string): void;
+        (block:Function, error:RegExp, message?:string): void;
+        (block:Function, error:(err:any) => boolean, message?:string): void;
+    };
+
+    export var doesNotThrow:{
+        (block:Function, message?:string): void;
+        (block:Function, error:Function, message?:string): void;
+        (block:Function, error:RegExp, message?:string): void;
+        (block:Function, error:(err:any) => boolean, message?:string): void;
+    };
+
+    export function ifError(value:any):void;
+}

From 749e409bfc89947dade2981634f9de1f2afd509f Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Thu, 20 Mar 2014 17:22:59 +0900
Subject: [PATCH 174/309] fix travis-ci failed

---
 assert/assert.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/assert/assert.d.ts b/assert/assert.d.ts
index b54eae7fa..7bbd370f3 100644
--- a/assert/assert.d.ts
+++ b/assert/assert.d.ts
@@ -6,8 +6,8 @@
 
 // copy from assert external module in node.d.ts
 
-function assert(value:any, message?:string):void;
-module assert {
+declare function assert(value:any, message?:string):void;
+declare module assert {
     export class AssertionError implements Error {
         name:string;
         message:string;

From 5619051b5e7cbeffd35c968cb74d9b00b2a31e78 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Thu, 20 Mar 2014 14:10:25 +0400
Subject: [PATCH 175/309] `generateWithTime` from `rx.lite.d.ts` was renamed to
 `generateWithRelativeTime` and moved as common part to `rx.time-lite.ts`.

---
 rx.js/rx.lite.d.ts    | 10 ----------
 rx.js/rx.time-lite.ts |  7 +++++++
 rx.js/rx.time.d.ts    |  8 --------
 3 files changed, 7 insertions(+), 18 deletions(-)

diff --git a/rx.js/rx.lite.d.ts b/rx.js/rx.lite.d.ts
index c8f99ab5b..70d228bad 100644
--- a/rx.js/rx.lite.d.ts
+++ b/rx.js/rx.lite.d.ts
@@ -47,14 +47,4 @@ declare module Rx {
 	export interface Observable<T> {
 		shareReplay(bufferSize?: number, window?: number, scheduler?: IScheduler): Observable<T>;	// same as replayWhileObserved in rx.binding.d.ts
 	}
-
-	export interface ObservableStatic {
-		generateWithTime<TState, TResult>(
-			initialState: TState,
-			condition: (state: TState) => boolean,
-			iterate: (state: TState) => TState,
-			resultSelector: (state: TState) => TResult,
-			timeSelector: (state: TState) => number,
-			scheduler?: IScheduler): Observable<TResult>;
-	}
 }
diff --git a/rx.js/rx.time-lite.ts b/rx.js/rx.time-lite.ts
index 1082f1a7b..b79275fe4 100644
--- a/rx.js/rx.time-lite.ts
+++ b/rx.js/rx.time-lite.ts
@@ -47,5 +47,12 @@ declare module Rx {
 		interval(dutTime: number, period: number, scheduler?: IScheduler): Observable<number>;
 		timer(dueTime: number, period: number, scheduler: IScheduler): Observable<number>;
 		timer(dueTime: number, scheduler: IScheduler): Observable<number>;
+		generateWithRelativeTime<TState, TResult>(
+			initialState: TState,
+			condition: (state: TState) => boolean,
+			iterate: (state: TState) => TState,
+			resultSelector: (state: TState) => TResult,
+			timeSelector: (state: TState) => number,
+			scheduler?: IScheduler): Observable<TResult>;
 	}
 }
diff --git a/rx.js/rx.time.d.ts b/rx.js/rx.time.d.ts
index 994d9bf46..47482bca4 100644
--- a/rx.js/rx.time.d.ts
+++ b/rx.js/rx.time.d.ts
@@ -28,13 +28,5 @@ declare module Rx {
 			resultSelector: (state: TState) => TResult,
 			timeSelector: (state: TState) => Date,
 			scheduler?: IScheduler): Observable<TResult>;
-
-		generateWithRelativeTime<TState, TResult>(
-			initialState: TState,
-			condition: (state: TState) => boolean,
-			iterate: (state: TState) => TState,
-			resultSelector: (state: TState) => TResult,
-			timeSelector: (state: TState) => number,
-			scheduler?: IScheduler): Observable<TResult>;
 	}
 }

From 1485111fcf4039e55afb1c9d8b893b1b224eab16 Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Thu, 20 Mar 2014 14:10:17 +0000
Subject: [PATCH 176/309] jQuery.validation:started JSDoc for jQuery val

---
 jquery.validation/jquery.validation.d.ts | 49 +++++++++++++++++++++---
 1 file changed, 44 insertions(+), 5 deletions(-)

diff --git a/jquery.validation/jquery.validation.d.ts b/jquery.validation/jquery.validation.d.ts
index 301bf6bc6..842722f54 100644
--- a/jquery.validation/jquery.validation.d.ts
+++ b/jquery.validation/jquery.validation.d.ts
@@ -70,11 +70,50 @@ interface Validator
 
 interface JQuery
 {
-	removeAttrs(attributes: string): any;
+    /**
+     * Remove the specified attributes from the first matched element and return them.
+     * 
+     * @param attributes A space-seperated list of attribute names to remove.
+     */
+    removeAttrs(attributes: string): any;
+
+    /**
+     * Returns the validations rules for the first selected element
+     */
 	rules(): any;
-	rules(methodName: string): any;
-	rules(methodName: string, rules: any): any;
-	valid(): boolean;
+
+    /**
+     * Removes the specified rules and returns all rules for the first matched element.
+     * 
+     * @param command "remove"
+     * @param rules Removes and returns all rules. Manipulates only rules specified via rules-option or via rules("add").
+     */
+    rules(command: string): any;
+    /**
+     * Removes the specified rules and returns all rules for the first matched element.
+     * 
+     * @param command "remove"
+     * @param rules The space-separated names of rules to remove and return. Manipulates only rules specified via rules-option or via rules("add").
+     */
+    rules(command: string, rules: string): any;
+    /**
+     * Adds the specified rules and returns all rules for the first matched element. Requires that the parent form is validated, that is, $("form").validate() is called first 
+     * 
+     * @param command "add"
+     * @param rules The rules to add. Accepts the same format as the rules-option of the validate-method.
+     */
+    rules(command: string, rules: Object): any;
+
+    /**
+     * Checks whether the selected form is valid or whether all selected elements are valid.
+     */
+    valid(): boolean;
+
+    /**
+     * Validates the selected form.
+     * 
+     * @param options options for validation
+     */
 	validate(options?: ValidationOptions): Validator;
 }
 
@@ -82,4 +121,4 @@ interface JQueryStatic
 {
 	format(template: string, ...arguments: string[]): string;
 	validator: Validator;
-}
\ No newline at end of file
+}

From 6a22fbb28626b8145ae1e34427a89f3d92e9fd93 Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Thu, 20 Mar 2014 17:17:16 +0000
Subject: [PATCH 177/309] jQuery-validate

---
 jquery.validation/jquery.validation.d.ts | 53 +++++++++++++++++++++++-
 1 file changed, 52 insertions(+), 1 deletion(-)

diff --git a/jquery.validation/jquery.validation.d.ts b/jquery.validation/jquery.validation.d.ts
index 866846af8..3b99514df 100644
--- a/jquery.validation/jquery.validation.d.ts
+++ b/jquery.validation/jquery.validation.d.ts
@@ -49,16 +49,62 @@ interface ErrorListItem
 
 interface Validator
 {
-	addClassRules(name: string, rules: any): void;
+    /**
+     * Add a compound class method - useful to refactor common combinations of rules into a single class.
+     * 
+     * @param name The name of the class rule to add
+     * @param rules The compound rules
+     */
+	addClassRules(name: string, rules: Object): ): void;
+    /**
+     * Add a compound class method - useful to refactor common combinations of rules into a single class.
+     * 
+     * @param rules A map of className-rules pairs
+     */
 	addClassRules(rules: any): void;
+    /**
+     * Add a custom validation method. It must consist of a name (must be a legal javascript identifier), a javascript based function and a default string message.
+     * 
+     * @param name The name of the method used to identify it and referencing it; this must be a valid JavaScript identifier
+     * @param method The actual method implementation, returning true if an element is valid. First argument: Current value. Second argument: Validated element. Third argument: Parameters.
+     */
 	addMethod(name: string, method: (value: any, element: any, params: any) => any, message?: any): void;
+    /**
+     * Validates a single element, returns true if it is valid, false otherwise.
+     * 
+     * @param element An element to validate, must be inside the validated form. eg "#myselect"
+     */
 	element(element: any): boolean;
+    /**
+     * Validates the form, returns true if it is valid, false otherwise.
+     */
 	form(): boolean;
+    /**
+     * Replaces {n} placeholders with arguments.
+     * 
+     * @param template The string to format.
+     */
 	format(template: string, ...arguments: string[]): string;
+    /**
+     * Returns the number of invalid fields.
+     */
 	numberOfInvalids(): number;
+    /**
+     * Resets the controlled form.
+     */
 	resetForm(): void;
+    /**
+     * Modify default settings for validation.
+     * 
+     * @param options Options to set as default.
+     */
 	setDefaults(defaults: ValidationOptions): void;
 	settings: ValidationOptions;
+    /**
+     * Show the specified messages.
+     * 
+     * @param errors One or more key/value pairs of input names and messages.
+     */
 	showErrors(errors: any): void;
 	hideErrors(): void;
 	valid(): boolean;
@@ -119,6 +165,11 @@ interface JQuery
 
 interface JQueryStatic
 {
+    /**
+     * Replaces {n} placeholders with arguments.
+     * 
+     * @param template The string to format.
+     */
 	format(template: string, ...arguments: string[]): string;
 	validator: Validator;
 }

From 2da211a3a67483ebb52bd0af82e17d72ba625400 Mon Sep 17 00:00:00 2001
From: Paul Vick <paulvick@hotmail.com>
Date: Thu, 20 Mar 2014 15:31:56 -0700
Subject: [PATCH 178/309] Add missing methods to create npm publish tasks

---
 jake/jake.d.ts | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/jake/jake.d.ts b/jake/jake.d.ts
index 6995abc83..59da4597f 100644
--- a/jake/jake.d.ts
+++ b/jake/jake.d.ts
@@ -22,7 +22,6 @@ declare function desc(description:string): void;
  */
 declare function directory(name:string): jake.DirectoryTask;
 
-
 /**
  * Causes Jake execution to abort with an error. Allows passing an optional error code, which will be used to set the exit-code of exiting process.
  * @param err The error to thow when aborting execution. If this argument is an Error object, it will simply be thrown. If a String, it will be used as the error-message. (If it is a multi-line String, the first line will be used as the Error message, and the remaining lines will be used as the error-stack.)
@@ -57,6 +56,15 @@ declare function task(name:string, prereqs?:string[], action?:(...params:any[])=
 declare function task(name:string, action?:(...params:any[])=>any, opts?:jake.TaskOptions): jake.Task;
 declare function task(name:string, opts?:jake.TaskOptions, action?:(...params:any[])=>any): jake.Task;
 
+/**
+ * @param name The name of the NpmPublishTask
+ * @param packageFiles The files to include in the package
+ * @param definition A function that creates the package definition
+ */
+declare function npmPublishTask(name:string, packageFiles:string[]): jake.NpmPublishTask;
+declare function npmPublishTask(name:string, definition?:()=>void): jake.NpmPublishTask;
+
+
 declare module jake{
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -368,6 +376,7 @@ declare module jake{
 
 	export class NpmPublishTask{
 		constructor(name:string, packageFiles:string[]);
+		constructor(name:string, definition?:()=>void);
 	}
 
 	export function addListener(event: string, listener: Function): NodeEventEmitter;

From 9474532386f0727e42a4a94a662fcc0947be3713 Mon Sep 17 00:00:00 2001
From: Wilker Lucio <wilkerlucio@gmail.com>
Date: Thu, 20 Mar 2014 20:54:44 -0300
Subject: [PATCH 179/309] added interfaces for firebase simple login

---
 firebase/firebase-simplelogin-tests.ts | 78 +++++++++++++++++++++
 firebase/firebase-simplelogin.d.ts     | 94 ++++++++++++++++++++++++++
 2 files changed, 172 insertions(+)
 create mode 100644 firebase/firebase-simplelogin-tests.ts
 create mode 100644 firebase/firebase-simplelogin.d.ts

diff --git a/firebase/firebase-simplelogin-tests.ts b/firebase/firebase-simplelogin-tests.ts
new file mode 100644
index 000000000..e6c834fcf
--- /dev/null
+++ b/firebase/firebase-simplelogin-tests.ts
@@ -0,0 +1,78 @@
+/// <reference path="./firebase-simplelogin.d.ts" />
+
+var chatRef: Firebase = new Firebase('https://<YOUR-FIREBASE>.firebaseio.com');
+var auth: FirebaseSimpleLogin = new FirebaseSimpleLogin(chatRef, function(error, user) {
+    if (error) {
+        // an error occurred while attempting login
+        switch(error.code) {
+            case 'INVALID_EMAIL':
+            case 'INVALID_PASSWORD':
+            default:
+        }
+    } else if (user) {
+        // user authenticated with Firebase
+        console.log('User ID: ' + user.id + ', Provider: ' + user.provider);
+    } else {
+        // user is logged out
+    }
+});
+
+var email = 'my@email.com';
+var password = 'secret';
+var oldPassword = 'secret';
+var newPassword = 'secret';
+
+auth.login('password', {
+    email: '<email@domain.com>',
+    password: '<password>',
+    rememberMe: true
+});
+
+auth.login('facebook', {
+    rememberMe: true,
+    scope: 'email,user_likes'
+});
+
+auth.login('github', {
+    rememberMe: true,
+    scope: 'user,gist'
+});
+
+auth.login('google', {
+    rememberMe: true,
+    scope: 'https://www.googleapis.com/auth/plus.login'
+});
+
+auth.login('persona', {
+    rememberMe: true
+});
+
+auth.login('twitter', {
+    rememberMe: true
+});
+
+auth.login('anonymous');
+
+auth.createUser(email, password, function(error, user) {
+    if (!error) {
+        console.log('User Id: ' + user.id + ', Email: ' + user.email);
+    }
+});
+
+auth.changePassword(email, oldPassword, newPassword, function(error, success) {
+    if (!error) {
+        console.log('Password changed successfully');
+    }
+});
+
+auth.sendPasswordResetEmail(email, function(error, success) {
+    if (!error) {
+        console.log('Password reset email sent successfully');
+    }
+});
+
+auth.removeUser(email, password, function(error, success) {
+    if (!error) {
+        console.log('User deleted successfully');
+    }
+});
\ No newline at end of file
diff --git a/firebase/firebase-simplelogin.d.ts b/firebase/firebase-simplelogin.d.ts
new file mode 100644
index 000000000..a617ef794
--- /dev/null
+++ b/firebase/firebase-simplelogin.d.ts
@@ -0,0 +1,94 @@
+// Type definitions for Firebase Simple Login
+// Project: https://www.firebase.com/docs/security/simple-login-overview.html
+// Definitions by: Wilker Lucio <http://github.com/wilkerlucio>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="./firebase.d.ts" />
+
+interface IFirebaseSimpleLoginError {
+    code: string;
+    message: string;
+}
+
+interface IFirebaseSimpleLoginOptions {
+    // general options
+    debug?: boolean
+    rememberMe?: boolean
+
+    // email
+    email?: string
+    password?: string
+
+    // facebook / github / google / twitter
+    preferRedirect?: boolean
+
+    // facebook / github / google
+    scope?: string
+
+    // facebook
+    access_token?: string
+
+    // twitter
+    oauth_token?: string
+
+    // persona
+    backgroundColor?: string
+    privacyPolicy?: string
+    siteLogo?: string
+    siteName?: string
+    termsOfService?: string
+}
+
+interface IFirebaseSimpleLoginUser {
+    // general data
+    firebaseAuthToken: string;
+    id: string;
+    provider: string;
+    uid: string;
+
+    // email / persona
+    md5_hash?: string;
+
+    // email
+    email?: string;
+
+    // facebook / github / google / twitter
+    accessToken?: string
+    displayName?: string
+    thirdPartyUserData?: Object
+
+    // github / twitter
+    username?: string
+
+    // twitter
+    accessTokenSecret?: string
+}
+
+declare class FirebaseSimpleLogin {
+    email: string;
+    id: string;
+    provider: string;
+    uid: string;
+    username: string;
+
+    constructor(firebase: Firebase, callback: (err: IFirebaseSimpleLoginError, user: IFirebaseSimpleLoginUser) => any);
+
+    login(loginType: string, options?: IFirebaseSimpleLoginOptions);
+    logout();
+
+    createUser(email: string,
+               password: string,
+               callback?: (err: IFirebaseSimpleLoginError, user: IFirebaseSimpleLoginUser) => any);
+
+    changePassword(email: string,
+                   oldPassword: string,
+                   newPassword: string,
+                   callback?: (err: IFirebaseSimpleLoginError, success: boolean) => any);
+
+    sendPasswordResetEmail(email: string,
+                           callback: (err: IFirebaseSimpleLoginError, success: boolean) => any);
+
+    removeUser(email: string,
+               password: string,
+               callback: (err: IFirebaseSimpleLoginError, success: boolean) => any);
+}
\ No newline at end of file

From 960179b8a28cf12808367c28a5f4c75f34cceac2 Mon Sep 17 00:00:00 2001
From: Wilker Lucio <wilkerlucio@gmail.com>
Date: Thu, 20 Mar 2014 21:00:38 -0300
Subject: [PATCH 180/309] added explicitly void return type for firebase simple
 login calls

---
 firebase/firebase-simplelogin.d.ts | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/firebase/firebase-simplelogin.d.ts b/firebase/firebase-simplelogin.d.ts
index a617ef794..7e30e9ad1 100644
--- a/firebase/firebase-simplelogin.d.ts
+++ b/firebase/firebase-simplelogin.d.ts
@@ -73,22 +73,22 @@ declare class FirebaseSimpleLogin {
 
     constructor(firebase: Firebase, callback: (err: IFirebaseSimpleLoginError, user: IFirebaseSimpleLoginUser) => any);
 
-    login(loginType: string, options?: IFirebaseSimpleLoginOptions);
-    logout();
+    login(loginType: string, options?: IFirebaseSimpleLoginOptions): void;
+    logout(): void;
 
     createUser(email: string,
                password: string,
-               callback?: (err: IFirebaseSimpleLoginError, user: IFirebaseSimpleLoginUser) => any);
+               callback?: (err: IFirebaseSimpleLoginError, user: IFirebaseSimpleLoginUser) => any): void;
 
     changePassword(email: string,
                    oldPassword: string,
                    newPassword: string,
-                   callback?: (err: IFirebaseSimpleLoginError, success: boolean) => any);
+                   callback?: (err: IFirebaseSimpleLoginError, success: boolean) => any): void;
 
     sendPasswordResetEmail(email: string,
-                           callback: (err: IFirebaseSimpleLoginError, success: boolean) => any);
+                           callback: (err: IFirebaseSimpleLoginError, success: boolean) => any): void;
 
     removeUser(email: string,
                password: string,
-               callback: (err: IFirebaseSimpleLoginError, success: boolean) => any);
+               callback: (err: IFirebaseSimpleLoginError, success: boolean) => any): void;
 }
\ No newline at end of file

From 85ade7c47733d3488fc91e6988d955fc0e418728 Mon Sep 17 00:00:00 2001
From: Basarat Syed <bas@picnicsoftware.com>
Date: Fri, 21 Mar 2014 16:54:46 +1100
Subject: [PATCH 181/309] KineticJS initial commit of definitions

---
 README.md                    |   1 +
 kineticjs/kineticjs-tests.ts |  54 ++++
 kineticjs/kineticjs.d.ts     | 547 +++++++++++++++++++++++++++++++++++
 3 files changed, 602 insertions(+)
 create mode 100644 kineticjs/kineticjs-tests.ts
 create mode 100644 kineticjs/kineticjs.d.ts

diff --git a/README.md b/README.md
index a3c0aa08d..377dcdd56 100755
--- a/README.md
+++ b/README.md
@@ -172,6 +172,7 @@ List of Definitions
 * [jStorage](http://www.jstorage.info/) (by [Danil Flores](https://github.com/dflor003/))
 * [JWPlayer](http://developer.longtailvideo.com/trac/) (by [Martin Duparc](https://github.com/martinduparc/))
 * [KeyboardJS](https://github.com/RobertWHurst/KeyboardJS) (by [Vincent Bortone](https://github.com/vbortone/))
+* [KineticJS](http://kineticjs.com/) (by [Basarat Ali Syed](https://github.com/basarat))
 * [Knockback](http://kmalakoff.github.com/knockback/) (by [Marcel Binot](https://github.com/docgit))
 * [Knockout.js](http://knockoutjs.com/) (by [Boris Yankov](https://github.com/borisyankov))
 * [Knockout.DeferredUpdates](https://github.com/mbest/knockout-deferred-updates) (by [Sebastián Galiano](https://github.com/sgaliano))
diff --git a/kineticjs/kineticjs-tests.ts b/kineticjs/kineticjs-tests.ts
new file mode 100644
index 000000000..c323ccc87
--- /dev/null
+++ b/kineticjs/kineticjs-tests.ts
@@ -0,0 +1,54 @@
+/// <reference path="kineticjs.d.ts"/>
+
+// http://www.html5canvastutorials.com/kineticjs/html5-canvas-kineticjs-rect-tutorial/
+module RectTutorial {
+    var stage = new Kinetic.Stage({
+        container: 'container',
+        width: 578,
+        height: 200
+    });
+
+    var layer = new Kinetic.Layer();
+
+    var rect = new Kinetic.Rect({
+        x: 239,
+        y: 75,
+        width: 100,
+        height: 50,
+        fill: 'green',
+        stroke: 'black',
+        strokeWidth: 4
+    });
+
+    // add the shape to the layer
+    layer.add(rect);
+
+    // add the layer to the stage
+    stage.add(layer);
+}
+
+// http://www.html5canvastutorials.com/kineticjs/html5-canvas-kineticjs-circle-tutorial/
+module CircleTutorial {
+    var stage = new Kinetic.Stage({
+        container: 'container',
+        width: 578,
+        height: 200
+    });
+
+    var layer = new Kinetic.Layer();
+
+    var circle = new Kinetic.Circle({
+        x: stage.getWidth() / 2,
+        y: stage.getHeight() / 2,
+        radius: 70,
+        fill: 'red',
+        stroke: 'black',
+        strokeWidth: 4
+    });
+
+    // add the shape to the layer
+    layer.add(circle);
+
+    // add the layer to the stage
+    stage.add(layer);
+}
diff --git a/kineticjs/kineticjs.d.ts b/kineticjs/kineticjs.d.ts
new file mode 100644
index 000000000..bbe2d68e8
--- /dev/null
+++ b/kineticjs/kineticjs.d.ts
@@ -0,0 +1,547 @@
+// Type definitions for KineticJS
+// Project: http://kineticjs.com/
+// Definitions by: Basarat Ali Syed <http://www.github.com/basarat>, Ralph de Ruijter <http://www.superdopey.nl/techblog/>
+// DefinitelyTyped: https://github.com/borisyankov/DefinitelyTyped
+
+declare module Kinetic {
+
+    var Node: {
+        new (config: ObjectOptionsConfig): INode;
+    }
+
+    interface INode {
+        cache(cacheConfig?: any): INode;
+        clone(attrs: any): INode;
+        destroy(): void;
+        draw(): INode;
+        drawBuffer(): any;
+        drawScene(): any;
+        getAbsoluteOpacity(): number;
+        getAbsolutePosition(): Vector2d;
+        getAbsoluteTransform(): any;
+        getAbsoluteZIndex(): number;
+        getAttrs(): any;
+        getDragBounds(): any;
+        getDragConstraint(): any;
+        getDraggable(): boolean;
+        getLayer(): any;
+        getLevel(): number;
+        getListening(): any;
+        getName(): string;
+        getOffset(): Vector2d;
+        getOpacity(): number;
+        getParent(): any;
+        getPosition(): Vector2d;
+        getRotation(): number;
+        getRotationDeg(): number;
+        getScale(): Vector2d;
+        getScaleX(): number;
+        getScaleY(): number;
+        getSize(): ISize;
+        getStage(): IStage;
+        getTransform(): any;
+        getZIndex(): number;
+        hide(): void;
+        isDraggable(): boolean;
+        isDragging(): boolean;
+        isListening(): boolean;
+        move(x: number, y: number): void;
+        moveDown(): void;
+        moveTo(newContainer: IContainer): void;
+        moveToBottom(): void;
+        moveToTop(): void;
+        moveUp(): void;
+        name(): string;
+        name(name: string): void;
+        rotate(theta: number): void;
+        rotateDeg(deg: number): void;
+
+        // Events 
+        on(typesStr: string, handler: (data: any) => any): void;
+        off(typesStr: string): void;
+        fire(typeStr: string, event?: any, bubble?: boolean): any;
+
+        setAbsolutePosition(pos: Vector2d): void;
+        setAttrs(config: any): void;
+        setDefaultAttrs(config: any): void;
+        setDragBounds(bounds: any): void;
+
+        setDragConstraint(constraint: string): void;
+        setDraggable(draggable: boolean): void;
+        setListening(listening: boolean): void;
+        setOffset(offset: Vector2d): any;
+        setOpacity(opacity: any): void;
+        setPosition(position: Vector2d): void;
+        setRotation(theta: number): void;
+        setRotationDeg(rotDeg: number): void;
+        setScale(scale: Vector2d): void;
+        setScaleX(scale: number): void;
+        setScaleY(scale: number): void;
+        setSize(size: ISize): any;
+        setZIndex(zIndex: number): void;
+        show(): void;
+        simulate(eventType: string): void;
+        toDataURL(config: any): void;
+        transitionTo(config: any): void;
+
+        // Width / Height
+        width(): number;
+        width(width: number): void;
+        getWidth(): any;
+        setWidth(width: number): void;
+        height(): number;
+        height(height: number): void;
+        getHeight(): any;
+        setHeight(height: number): any;
+
+        // id 
+        id(): string;
+        id(id: string): void;
+        getId(): string;
+        setId(id: string): void;
+
+        // Position
+        x(): number;
+        x(x: number): void;
+        y(): number;
+        y(y: number): void;
+        getX(): number;
+        setX(x: number): void;
+        getY(): number;
+        setY(y: number): void;
+    }
+
+    var Container: {
+        new (config: any): IContainer;
+    }
+
+    interface IContainer extends INode {
+        add(child: INode): any;
+        clone(attrs: any): IContainer;
+        destroyChildren(): IContainer;
+        find(selector: string): any;
+        get(selector: any): any;
+        getChildren(): INode[];
+        getIntersections(point: any): any;
+        isAncestorOf(node: any): any;
+        remove(child: any): any;
+        removeChildren(): any;
+    }
+
+    var Stage: {
+        new (config: StageConfig): IStage;
+    }
+
+    interface IStage extends IContainer {
+        add(layer: ILayer): any;
+        clear(): any;
+        getContainer(): HTMLElement;
+        getDOM(): HTMLElement;
+        getHeight(): number;
+        getIntersection(pos: any): any;
+        getMousePosition(evt?: Event): any;
+        getPointerPosition(): Vector2d;
+        getStage(): IStage;
+        getTouchPosition(evt?: Event): any;
+        getUserPosition(evt?: Event): any;
+        getWidth(): number;
+        load(JSON: any): any;
+        reset(): any;
+        setHeight(height: number): any;
+        setWidth(width: number): any;
+        toDataURL(config: any): any;
+        toImage(config: any, callback: () => any): any;
+        toJSON(): any;
+    }
+
+    var Layer: {
+        new (config?: LayerConfig): ILayer;
+    }
+
+    interface ILayer extends IContainer {
+        afterDraw(handler: () => any): any;
+        beforeDraw(handler: () => any): any;
+        clear(): any;
+        getCanvas(): ICanvas;
+        getClearBeforeDraw(): any;
+        getContext(): CanvasRenderingContext2D;
+        remove(): any;
+        setClearBeforeDraw(clearBeforeDraw: boolean): any;
+        toDataURL(config: any): any;
+    }
+
+    interface ICanvas {
+        _canvas: HTMLCanvasElement;
+
+        getPixelRatio(): number;
+
+        height: number;
+        setPixelRatio(pixelRatio: number): any;
+        width: number;
+    }
+
+    var Shape: {
+        new (config: any): IShape;
+    }
+
+    interface IShape extends INode {
+        applyLineJoin(): void;
+        drawImage(): void;
+        fill(): void;
+        fillText(text: string): void;
+        getCanvas(): ICanvas;
+        getContext(): any;
+        getDrawFunc(): any;
+        getFill(): string;
+        getLineJoin(): any;
+        getShadow(): any;
+        getStroke(): any;
+        getStrokeWidth(): number;
+        intersects(point: any): boolean;
+        setDrawFunc(drawFunc: () => any): any;
+        setFill(fill: string): any;
+        setLineJoin(): any;
+        setShadow(config: any): any;
+        setSize(size: ISize): any;
+        setStroke(stroke: string): any;
+        setStrokeWidth(strokeWidth: number): any;
+        stroke(): any;
+        strokeText(text: string): any;
+    }
+
+    var Rect: {
+        new (config: RectConfig): IRect;
+    }
+
+    interface IRect extends IShape {
+        getCornerRadius(): number;
+        getHeight(): number;
+        getWidth(): number;
+        setCornerRadius(radius: number): any;
+        setHeight(height: number): any;
+        setWidth(width: number): any;
+    }
+
+    var Circle: {
+        new (config: CircleConfig): ICircle;
+
+    }
+
+    interface ICircle extends IShape {
+        getRadius(): number;
+        setRadius(radius: number): any;
+    }
+
+    var Ellipse: {
+        new (config: CircleConfig): IEllipse;
+    }
+
+    interface IEllipse extends IShape {
+        getRadius(): number;
+        setRadius(radius: number): any;
+    }
+
+    var Group: {
+        new (config?: ObjectOptionsConfig): IGroup;
+    }
+
+    interface IGroup extends IContainer {
+    }
+
+    var Collection: {
+        new (): ICollection;
+    }
+
+    interface ICollection {
+        apply(method: Function, val: any): any;
+        each(func: () => any): any;
+    }
+
+    var Image: {
+        new (config?: ImageConfig): IImage;
+    }
+
+    interface IImage extends IShape {
+        applyFilter(config: any): any;
+        clearImageBuffer(): any;
+        createImageBuffer(callback: () => any): any;
+        getCrop(): any;
+        getFilter(): any;
+        getHeight(): number;
+        getImage(): IImage;
+        getWidth(): number;
+        setCrop(config: CropConfig): any;
+        setFilter(config: any): any;
+        setHeight(height: number): any;
+        setImage(image: IImage): any;
+        setWidth(width: number): any;
+    }
+
+    var Line: {
+        new (config: LineConfig): ILine;
+    }
+
+    interface ILine extends IShape {
+        getDashArray(): any;
+        getLineCap(): any;
+        getPoints(): any;
+        setDashArray(dashArray: any): any;
+        setLineCap(lineCap: string): any;
+        setPoints(can: any[]): any;
+    }
+
+    var Path: {
+        new (config: PathConfig): IPath;
+        parsePathData(data: string): any;
+    }
+    interface IPath extends IShape {
+        getData(): string;
+        setData(SVG: string): any;
+    }
+
+    var Polygon: {
+        new (config: PolygonConfig): IPolygon;
+    }
+
+    interface IPolygon extends IShape {
+        getPoints(): any;
+        setPoints(points: any): any;
+    }
+
+    var RegularPolygon: {
+        new (config: RegularPolygonConfig): IRegularPolygon;
+    }
+
+    interface IRegularPolygon extends IShape {
+        getRadius(): number;
+        getSides(): number;
+        setRadius(radius: number): any;
+        setSides(sides: number): any;
+    }
+
+    var Sprite: {
+        new (config: SpriteConfig): ISprite;
+    }
+    interface ISprite extends IShape {
+        afterFrame(index: number, func: () => any): any;
+        getAnimation(): string;
+        getAnimations(): any;
+        getIndex(): number;
+        setAnimation(anim: string): any;
+        setAnimations(animations: any): any;
+        setIndex(index: number): any;
+        start(): any;
+        stop(): any;
+    }
+
+    var Star: {
+        new (config: StarConfig): IStar;
+    }
+    interface IStar extends IShape {
+        getInnerRadius(): number;
+        getNumPoints(): number;
+        getOuterRadius(): number;
+        setInnerRadius(radius: number): any;
+        setNumPoints(points: number): any;
+        setOuterRadius(radius: number): any;
+    }
+
+    var Text: {
+        new (config: TextConfig): IText;
+    }
+    interface IText extends IShape {
+        getAlign(): string;
+        getBoxHeight(): number;
+        getBoxWidth(): number;
+        getFontFamily(): string;
+        getFontSize(): number;
+        getFontStyle(): string;
+        getHeight(): number;
+        getLineHeight(): number;
+        getPadding(): number;
+        getShadow(): any;
+        getText(): string;
+        getTextFill(): any;
+        getTextHeight(): number;
+        getTextStroke(): any;
+        getTextStrokeWidth(): number;
+        getTextWidth(): number;
+        getWidth(): number;
+        setAlign(align: string): any;
+        setFontFamily(fontFamily: string): any;
+        setFontSize(fontSize: number): any;
+        setFontStroke(textStroke: any): any;
+        setFontStyle(fontStyle: string): any;
+        setHeight(height: number): any;
+        setLineHeight(lineHeight: number): any;
+        setPadding(padding: number): any;
+        setShadow(config: any): any;
+        setText(text: string): any;
+        setTextFill(textFill: any): any;
+        setTextStrokeWidth(textStrokeWidth: number): any;
+        setWidth(width: number): any;
+    }
+
+    var TextPath: {
+        new (config: any): ITextPath;
+    }
+    interface ITextPath extends IShape {
+        getFontFamily(): string;
+        getFontSize(): number;
+        getFontStyle(): string;
+        getText(): string;
+        getTextFill(): any;
+        getTextHeight(): number;
+        getTextStroke(): any;
+        getTextStrokeWidth(): number;
+        getTextWidth(): number;
+        setFontFamily(fontFamily: string): any;
+        setFontSize(fontSize: number): any;
+        setFontStroke(textStroke: any): any;
+        setFontStyle(fontStyle: string): any;
+        setText(text: string): any;
+        setTextFill(textFill: any): any;
+        setTextStrokeWidth(textStrokeWidth: number): any;
+    }
+
+    var Transition: {
+        new (node: Node, config: any): ITransition;
+    }
+    interface ITransition {
+        start(): any;
+        stop(): any;
+    }
+
+    var Animation: {
+        new (...args: any[]): IAnimation;
+    }
+    interface IAnimation extends IContainer {
+        start(): any;
+        stop(): any;
+    }
+
+    interface CropConfig {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }
+
+    interface StageConfig extends ObjectOptionsConfig {
+        container: string;
+        width: number;
+        height: number;
+    }
+
+    interface LayerConfig extends ObjectOptionsConfig {
+        clearBeforeDraw?: boolean;
+    }
+
+    //shape configs class
+    interface RectConfig extends DrawOptionsConfig, ObjectOptionsConfig {
+        width?: number;
+        height?: number;
+        cornerRadius?: number;
+    }
+
+    interface CircleConfig extends DrawOptionsConfig, ObjectOptionsConfig {
+        radius: number;
+    }
+
+    interface ImageConfig extends DrawOptionsConfig, ObjectOptionsConfig {
+        image: any;
+        width?: number;
+        height?: number;
+        crop?: any;
+    }
+
+    interface SpriteConfig extends DrawOptionsConfig, ObjectOptionsConfig {
+        image: any;
+        animations?: any;
+        animation?: any;
+        frameRate?: number;
+    }
+
+    interface TextConfig extends DrawOptionsConfig, ObjectOptionsConfig {
+        text: string;
+        fontSize?: number;
+        fontFamily?: string;
+        fontStyle?: string;
+        textFill?: any;
+        textStroke?: any;
+        textStrokeWidth?: number;
+        align?: string;
+        padding?: string;
+        width?: number;
+        height?: number;
+        lineHeight?: number;
+        cornerRadius?: number;
+    }
+
+    interface LineConfig extends DrawOptionsConfig, ObjectOptionsConfig {
+        points: any;
+        lineCap?: string;
+        dashArray?: any;
+    }
+
+    interface PolygonConfig extends DrawOptionsConfig, ObjectOptionsConfig {
+        points: any;
+    }
+
+    interface RegularPolygonConfig extends DrawOptionsConfig, ObjectOptionsConfig {
+        sides: number;
+        radius: number;
+    }
+
+    interface PathConfig extends DrawOptionsConfig, ObjectOptionsConfig {
+        data: string;
+    }
+
+    interface StarConfig extends DrawOptionsConfig, ObjectOptionsConfig {
+        numPoints: number;
+        outerRadius: number;
+        innerRadius: number;
+    }
+
+    interface CustomConfig extends DrawOptionsConfig, ObjectOptionsConfig {
+        drawFunc: () => any;
+    }
+
+    interface DrawOptionsConfig {
+        fill?: string;
+        stroke?: string;
+        strokeWidth?: number;
+        lineJoin?: string;
+        shadow?: any;
+    }
+
+    interface Vector2d {
+        x: number;
+        y: number;
+    }
+
+    interface ObjectOptionsConfig {
+        x?: number;
+        y?: number;
+        visible?: boolean;
+        listening?: boolean;
+        id?: string;
+        name?: string;
+        opacity?: any;
+        scale?: Vector2d;
+        rotation?: number;
+        rotationDeg?: number;
+        offset?: Vector2d;
+        draggable?: boolean;
+        dragConstraint?: string;
+        dragBounds?: any;
+        dragBoundFunc?: (pos: Vector2d) => Vector2d;
+        width?: number;
+        height?: number;
+    }
+
+    interface ISize {
+        width: number;
+        height: number;
+    }
+}
\ No newline at end of file

From c765fad27f0b5444b29268765bc058c50b192a47 Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Fri, 21 Mar 2014 08:50:24 +0000
Subject: [PATCH 182/309] jQuery-validate: fix up

---
 jquery.validation/jquery.validation.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/jquery.validation/jquery.validation.d.ts b/jquery.validation/jquery.validation.d.ts
index 3b99514df..6e2451566 100644
--- a/jquery.validation/jquery.validation.d.ts
+++ b/jquery.validation/jquery.validation.d.ts
@@ -55,13 +55,13 @@ interface Validator
      * @param name The name of the class rule to add
      * @param rules The compound rules
      */
-	addClassRules(name: string, rules: Object): ): void;
+	addClassRules(name: string, rules: Object): void;
     /**
      * Add a compound class method - useful to refactor common combinations of rules into a single class.
      * 
      * @param rules A map of className-rules pairs
      */
-	addClassRules(rules: any): void;
+	addClassRules(rules: Object): void;
     /**
      * Add a custom validation method. It must consist of a name (must be a legal javascript identifier), a javascript based function and a default string message.
      * 

From e984ccc6e3356d948ada1a0f98c07626812add34 Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Fri, 21 Mar 2014 08:59:20 +0000
Subject: [PATCH 183/309] jQuery-validate: interface JSDoc

---
 jquery.validation/jquery.validation.d.ts | 120 ++++++++++++++++++++++-
 1 file changed, 116 insertions(+), 4 deletions(-)

diff --git a/jquery.validation/jquery.validation.d.ts b/jquery.validation/jquery.validation.d.ts
index 6e2451566..d0bee3279 100644
--- a/jquery.validation/jquery.validation.d.ts
+++ b/jquery.validation/jquery.validation.d.ts
@@ -1,6 +1,6 @@
 // Type definitions for jquery.validation 1.11.1
 // Project: http://bassistance.de/jquery-plugins/jquery-plugin-validation/
-// Definitions by: https://github.com/fdecampredon
+// Definitions by: https://github.com/fdecampredon , https://github.com/johnnyreilly
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 
@@ -8,31 +8,143 @@
 
 interface ValidationOptions
 {
+    /**
+     * Enables debug mode. If true, the form is not submitted and certain errors are displayed on the console (will check if a window.console property exists). Try to enable when a form is just submitted instead of validation stopping the submit.
+     * 
+     * default: false
+     */
 	debug?: boolean;
+    /**
+     * Use this class to create error labels, to look for existing error labels and to add it to invalid elements.
+     * 
+     * default: "error"
+     */
 	errorClass?: string;
+    /**
+     * Hide and show this container when validating.
+     */
 	errorContainer?: string;
+    /**
+     * Use this element type to create error messages and to look for existing error messages. The default, "label", has the advantage of creating a meaningful link between error message and invalid field using the for attribute (which is always used, regardless of element type).
+     * 
+     * default: "label"
+     */
 	errorElement?: string;
+    /**
+     * Hide and show this container when validating. (eg "#messageBox")
+     */
 	errorLabelContainer?: string;
+    /**
+     * Customize placement of created error labels. First argument: The created error label as a jQuery object. Second argument: The invalid element as a jQuery object.
+     * 
+     * default: Places the error label after the invalid element
+     */
 	errorPlacement?: (error: JQuery, element: JQuery) => void;
+    /**
+     * If enabled, removes the errorClass from the invalid elements and hides all error messages whenever the element is focused. Avoid combination with focusInvalid.
+     * 
+     * default: false
+     */
 	focusCleanup?: boolean;
+    /**
+     * Focus the last active or first invalid element on submit via validator.focusInvalid(). The last active element is the one that had focus when the form was submitted, avoiding stealing its focus. If there was no element focused, the first one in the form gets it, unless this option is turned off.
+     * 
+     * default: true
+     */
 	focusInvalid?: boolean;
+    /**
+     * Specify grouping of error messages. A group consists of an arbitrary group name as the key and a space separated list of element names as the value. Use errorPlacement to control where the group message is placed.
+     */
 	groups?: Object;
+    /**
+     * How to highlight invalid fields. Override to decide which fields and how to highlight.
+     * 
+     * default: Adds errorClass (see the option) to the element
+     */
 	highlight?: (element: HTMLElement, errorClass: string, validClass: string) => void;
+    /**
+     * Elements to ignore when validating, simply filtering them out. jQuery's not-method is used, therefore everything that is accepted by not() can be passed as this option. Inputs of type submit and reset are always ignored, so are disabled elements.
+     */
 	ignore?: string;
+    /**
+     * Set to skip reading messages from the title attribute, helps to avoid issues with Google Toolbar; default is false for compability, the message-from-title is likely to be completely removed in a future release.
+     * 
+     * default: false
+     */
 	ignoreTitle?: boolean;
+    /**
+     * Callback for custom code when an invalid form is submitted. Called with an event object as the first argument, and the validator as the second.
+     */
 	invalidHandler?: (event: JQueryEventObject, validator: Validator) => void;
+    /**
+     * Key/value pairs defining custom messages. Key is the name of an element, value the message to display for that element. Instead of a plain message, another map with specific messages for each rule can be used. Overrides the title attribute of an element or the default message for the method (in that order). Each message can be a String or a Callback. The callback is called in the scope of the validator, with the rule's parameters as the first argument and the element as the second, and must return a String to display as the message.
+     * 
+     * default: the default message for the method used
+     */
 	messages?: Object;
 	meta?: string;
-	onclick?: boolean;
-	onfocusout?: boolean;
-	onkeyup?: boolean;
+    /**
+     * Boolean or Function. Validate checkboxes and radio buttons on click. Set to false to disable. 
+     * 
+     * Set to a Function to decide for yourself when to run validation.
+     * A boolean true is not a valid value.
+     */
+	onclick?: any;
+    /**
+     * Boolean or Function. Validate elements (except checkboxes/radio buttons) on blur. If nothing is entered, all rules are skipped, except when the field was already marked as invalid.
+     *
+     * Set to a Function to decide for yourself when to run validation.
+     * A boolean true is not a valid value.
+     */
+	onfocusout?: any;
+    /**
+     * Boolean or Function. Validate elements on keyup. As long as the field is not marked as invalid, nothing happens. Otherwise, all rules are checked on each key up event. Set to false to disable.
+     * 
+     * Set to a Function to decide for yourself when to run validation.
+     * A boolean true is not a valid value.
+     */
+	onkeyup?: any;
+    /**
+     * Validate the form on submit. Set to false to use only other events for validation. 
+     * Set to a Function to decide for yourself when to run validation. 
+     * A boolean true is not a valid value.
+     * 
+     * default: true
+     */
 	onsubmit?: boolean;
+    /**
+     * A custom message display handler. Gets the map of errors as the first argument and an array of errors as the second, called in the context of the validator object. The arguments contain only those elements currently validated, which can be a single element when doing validation onblur/keyup. You can trigger (in addition to your own messages) the default behaviour by calling this.defaultShowErrors().
+     */
 	rules?: Object;
+    /**
+     * A custom message display handler. Gets the map of errors as the first argument and an array of errors as the second, called in the context of the validator object. The arguments contain only those elements currently validated, which can be a single element when doing validation onblur/keyup. You can trigger (in addition to your own messages) the default behaviour by calling this.defaultShowErrors().
+     */
    	showErrors?: (errorMap: ErrorDictionary, errorList: ErrorListItem[]) => void;
+    /**
+     * Callback for handling the actual submit when the form is valid. Gets the form as the only argument. Replaces the default submit. The right place to submit a form via Ajax after it is validated.
+     */
 	submitHandler?: (form: HTMLFormElement) => void;
+    /**
+     * String or Function. If specified, the error label is displayed to show a valid element. If a String is given, it is added as a class to the label. If a Function is given, it is called with the label (as a jQuery object) and the validated input (as a DOM element). The label can be used to add a text like "ok!".
+     */
 	success?: any;
+    /**
+     * Called to revert changes made by option highlight, same arguments as highlight.
+     * 
+     * default: Removes the errorClass
+     */
 	unhighlight?: (element: HTMLElement, errorClass: string, validClass: string) => void;
+    /**
+     * This class is added to an element after it was validated and considered valid.
+     * 
+     * default: "valid"
+     */
 	validClass?: string;
+    /**
+     * Wrap error labels with the specified element. Useful in combination with errorLabelContainer to create a list of error messages.
+     * 
+     * default: window
+     */
 	wrapper?: string;
 }
 

From d0c677de5d1aa94ba53edd08d8151b9699e18af2 Mon Sep 17 00:00:00 2001
From: Yousef <yousefdardiry@gmail.com>
Date: Fri, 21 Mar 2014 14:33:04 +0100
Subject: [PATCH 184/309] Update greensock.d.ts

added TimelineLite.set
---
 greensock/greensock.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/greensock/greensock.d.ts b/greensock/greensock.d.ts
index 455b28052..772685786 100644
--- a/greensock/greensock.d.ts
+++ b/greensock/greensock.d.ts
@@ -129,6 +129,7 @@ declare class TimelineLite extends SimpleTimeline {
     progress(value:number):any;
     remove(value:any):any;
     removeLabel(label:string):any;
+    set(target: Object, vars: Object, position?:any):any;
     seek(position:any, suppressEvents?:boolean):any;
     shiftChildren(amount:number, adjustLabels?:boolean, ignoreBeforeTime?:number):any;
     staggerFrom(targets:any[], duration:number, vars:Object, stagger?:number, position?:any, onCompleteAll?:Function, onCompleteAllParams?:any[], onCompleteScope?:any):any;

From 5c914fb2967ba27fbe0a09a2d44aafe769855cfe Mon Sep 17 00:00:00 2001
From: Wilker Lucio <wilkerlucio@gmail.com>
Date: Fri, 21 Mar 2014 13:33:33 -0300
Subject: [PATCH 185/309] make the callbacks optional on firebase simple login

---
 firebase/firebase-simplelogin-tests.ts | 10 +++++++++-
 firebase/firebase-simplelogin.d.ts     |  4 ++--
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/firebase/firebase-simplelogin-tests.ts b/firebase/firebase-simplelogin-tests.ts
index e6c834fcf..e0be13e48 100644
--- a/firebase/firebase-simplelogin-tests.ts
+++ b/firebase/firebase-simplelogin-tests.ts
@@ -59,20 +59,28 @@ auth.createUser(email, password, function(error, user) {
     }
 });
 
+auth.createUser(email, password);
+
 auth.changePassword(email, oldPassword, newPassword, function(error, success) {
     if (!error) {
         console.log('Password changed successfully');
     }
 });
 
+auth.changePassword(email, oldPassword, newPassword);
+
 auth.sendPasswordResetEmail(email, function(error, success) {
     if (!error) {
         console.log('Password reset email sent successfully');
     }
 });
 
+auth.sendPasswordResetEmail(email);
+
 auth.removeUser(email, password, function(error, success) {
     if (!error) {
         console.log('User deleted successfully');
     }
-});
\ No newline at end of file
+});
+
+auth.removeUser(email, password);
\ No newline at end of file
diff --git a/firebase/firebase-simplelogin.d.ts b/firebase/firebase-simplelogin.d.ts
index 7e30e9ad1..817ec934a 100644
--- a/firebase/firebase-simplelogin.d.ts
+++ b/firebase/firebase-simplelogin.d.ts
@@ -86,9 +86,9 @@ declare class FirebaseSimpleLogin {
                    callback?: (err: IFirebaseSimpleLoginError, success: boolean) => any): void;
 
     sendPasswordResetEmail(email: string,
-                           callback: (err: IFirebaseSimpleLoginError, success: boolean) => any): void;
+                           callback?: (err: IFirebaseSimpleLoginError, success: boolean) => any): void;
 
     removeUser(email: string,
                password: string,
-               callback: (err: IFirebaseSimpleLoginError, success: boolean) => any): void;
+               callback?: (err: IFirebaseSimpleLoginError, success: boolean) => any): void;
 }
\ No newline at end of file

From 622cb22a699d93b155e0598b0a5f6826ee222ca8 Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Fri, 21 Mar 2014 13:57:19 -0400
Subject: [PATCH 186/309] First arg of resolve method should be optional.

This is because you may want to resolve a deferred without passing anything.
---
 jquery/jquery.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 558453ab3..5928165b3 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -482,7 +482,7 @@ interface JQueryDeferred<T> extends JQueryPromise<T> {
      * @param value First argument passed to doneCallbacks.
      * @param args Optional subsequent arguments that are passed to the doneCallbacks.
      */
-    resolve(value: T, ...args: any[]): JQueryDeferred<T>;
+    resolve(value?: T, ...args: any[]): JQueryDeferred<T>;
 
     // COMMENTED OUT AS MAKES resolve LESS USEFUL - PERHAPS REMOVE ENTIRELY LATER
     /**

From 9aef1ad84dc006e3d25f5e57709198e33996ba84 Mon Sep 17 00:00:00 2001
From: Paul Vick <paulvick@hotmail.com>
Date: Fri, 21 Mar 2014 15:37:11 -0700
Subject: [PATCH 187/309] Add typings for nomnom

---
 nomnom/nomnom-tests.ts           | 122 +++++++++++++++++
 nomnom/nomnom-tests.ts.tscparams |   1 +
 nomnom/nomnom.d.ts               | 225 +++++++++++++++++++++++++++++++
 3 files changed, 348 insertions(+)
 create mode 100644 nomnom/nomnom-tests.ts
 create mode 100644 nomnom/nomnom-tests.ts.tscparams
 create mode 100644 nomnom/nomnom.d.ts

diff --git a/nomnom/nomnom-tests.ts b/nomnom/nomnom-tests.ts
new file mode 100644
index 000000000..f840b0e02
--- /dev/null
+++ b/nomnom/nomnom-tests.ts
@@ -0,0 +1,122 @@
+// https://github.com/harthur/nomnom
+/// <reference path="nomnom.d.ts" />
+
+import nomnom = require("nomnom");
+
+var opts1 = nomnom
+    .option('debug', {
+        abbr: 'd',
+        flag: true,
+        help: 'Print debugging info'
+    })
+    .option('config', {
+        abbr: 'c',
+        default: 'config.json',
+        help: 'JSON file with tests to run'
+    })
+    .option('version', {
+        flag: true,
+        help: 'print version and exit',
+        callback: () => "version 1.2.4"
+    })
+    .parse();
+
+if (opts1.debug) {
+}
+
+var opts2 = nomnom.parse();
+
+var url = opts2[0];     // get the first positional arg
+var file = opts2.file;  // see if --file was specified
+var verbose = opts2.v;  // see if -v was specified
+var extras = opts2._;   // get an array of the unmatched, positional args
+
+var parser = nomnom;
+
+function runBrowser(url: string): void {
+}
+
+function runSanity(filename: string): void {
+}
+
+parser.command('browser')
+    .callback(opts => {
+        runBrowser(opts.url);
+    })
+    .help("run browser tests");
+
+parser.command('sanity')
+    .option('outfile', {
+        abbr: 'o',
+        help: "file to write results to"
+    })
+    .option('config', {
+        abbr: 'c',
+        default: 'config.json',
+        help: "json manifest of tests to run"
+    })
+    .callback(opts => {
+        runSanity(opts.filename);
+    })
+    .help("run the sanity tests");
+
+parser.parse();
+
+var opts3 = nomnom
+    .script("runtests")
+    .options({
+        path: {
+            position: 0,
+            help: "Test file to run",
+            list: true
+        },
+        config: {
+            abbr: 'c',
+            metavar: 'FILE',
+            help: "Config file with tests to run"
+        },
+        debug: {
+            abbr: 'd',
+            flag: true,
+            help: "Print debugging info"
+        }
+    }).parse();
+
+nomnom.option('debug', {
+    abbr: 'd'
+});
+
+nomnom.option('numLines', {
+    abbr: 'n',
+    full: 'num-lines'
+});
+
+nomnom.option('config', {
+    flag: true
+});
+
+nomnom.option('count', {
+    callback: count => {
+        if (count != parseInt(count))
+            return "count must be an integer";
+    }
+});
+
+nomnom.option('debug', {
+    abbr: 'd',
+    flag: true,
+    help: "Print debugging info"
+});
+
+nomnom.options({
+    debug: {
+        abbr: 'd',
+        flag: true,
+        help: "Print debugging info"
+    },
+    fruit: {
+        help: "Fruit to buy"
+    }
+});
+
+var opts4 = nomnom.parse(["-xvf", "--atomic=true"]);
\ No newline at end of file
diff --git a/nomnom/nomnom-tests.ts.tscparams b/nomnom/nomnom-tests.ts.tscparams
new file mode 100644
index 000000000..e16c76dff
--- /dev/null
+++ b/nomnom/nomnom-tests.ts.tscparams
@@ -0,0 +1 @@
+""
diff --git a/nomnom/nomnom.d.ts b/nomnom/nomnom.d.ts
new file mode 100644
index 000000000..2e7259939
--- /dev/null
+++ b/nomnom/nomnom.d.ts
@@ -0,0 +1,225 @@
+// Type definitions for nomnom
+// Project: https://github.com/harthur/nomnom
+// Definitions by: Paul Vick <https://github.com/panopticoncentral>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "nomnom"
+{
+    /**
+     * The command-line parser.
+     */
+    module Parser
+    {
+        /**
+         * A command-line option.
+         */
+        export interface Option
+        {
+            /**
+             * The abbreviated name of the option.
+             */
+            abbr?: string;
+
+            /**
+             * The full name of the option.
+             */
+            full?: string;
+
+            /**
+             * Whether the option is a flag.
+             */
+            flag?: boolean;
+
+            /**
+             * A string to be used in the usage printout.
+             */
+            metavar?: string;
+
+            /**
+             * A shorthand for abbr, full, and metavar.
+             */
+            string?: string;
+
+            /**
+             * A help string for the option.
+             */
+            help?: string;
+
+            /**
+             * The default value of the option.
+             */
+            default?: any;
+
+            /**
+             * A callback for the option.
+             */
+            callback?: (option: any) => string;
+
+            /**
+             * The position of the option if it's a positional argument.
+             */
+            position?: number;
+
+            /**
+             * Whether the option is a list.
+             */
+            list?: boolean;
+
+            /**
+             * Whether the option is required.
+             */
+            required?: boolean;
+
+            /**
+             * The choices for the option.
+             */
+            choices?: string[];
+
+            /**
+             * If you don't want the option JSON-parsed, specify type "string".
+             */
+            type?: string;
+
+            /**
+             * Whether the option is hidden.
+             */
+            hidden?: boolean;
+        }
+
+        /**
+         * A command-line command specification.
+         */
+        export interface Command
+        {
+            /**
+             * The name of the command.
+             */
+            name: string;
+
+            /**
+             * Sets the options of the command.
+             * @param specs The specifications of the options.
+             * @returns The command.
+             */
+            options(specs: { [index: string]: Option }): Command;
+
+            /**
+             * Sets an option of the command.
+             * @param name The name of the option.
+             * @param spec The specifiction of the option.
+             * @returns The command.
+             */
+            option(name: string, spec: Option): Command;
+
+            /**
+             * Sets a callback for the command.
+             * @param func The callback function.
+             * @returns The command.
+             */
+            callback(func: (options: any) => void): Command;
+
+            /**
+             * Sets the help string for the command.
+             * @param help The help string.
+             * @returns The command.
+             */
+            help(help: string): Command;
+
+            /**
+             * Sets the usage string for the command.
+             * @param usage The usage string.
+             * @returns The command.
+             */
+            usage(usage: string): Command;
+        }
+    }
+
+    /**
+     * The command-line parser.
+     */
+    interface Parser
+    {
+        /**
+         * Returns the parser.
+         */
+        (): Parser;
+
+        /**
+         * Creates a new command.
+         * @param name The name of the command.
+         * @returns The new command.
+         */
+        command(name: string): Parser.Command;
+
+        /**
+         * Returns the commmand representing no command.
+         * @returns The command representing no command.
+         */
+        nocommand(): Parser.Command;
+
+        /**
+         * Sets the options of the command-line.
+         * @param specs The specifications of the options.
+         * @returns The command-line parser.
+         */
+        options(specs: { [index: string]: Parser.Option }): Parser;
+
+        /**
+         * Sets an option of the command-line.
+         * @param name The name of the option.
+         * @param spec The specifiction of the option.
+         * @returns The command-line parser.
+         */
+        option(name: string, spec: Parser.Option): Parser;
+
+        /**
+         * Sets the usage string for the command-line.
+         * @param usage The usage string.
+         * @returns The command-line parser.
+         */
+        usage(usage: string): Parser;
+
+        /**
+         * Provides a printer to the command-line processor.
+         * @param print The print function to use.
+         * @returns The command-line parser.
+         */
+        printer(print: (message: string, code?: number) => void): Parser;
+
+        /**
+         * Sets the name of the script.
+         * @param script The script name.
+         * @returns The command-line parser.
+         */
+        script(script: string): Parser;
+
+        /**
+         * Sets the help string for the command-line.
+         * @param help The help string.
+         * @returns The command-line parser.
+         */
+        help(help: string): Parser;
+
+        /**
+         * Sets the command-line parser not to use colors.
+         * @returns The command-line parser.
+         */
+        nocolors(): Parser;
+
+        /**
+         * Parses the command-line.
+         * @param argv The command-line arguments.
+         * @returns The parsed command-line.
+         */
+        nom(argv?: string[]): any;
+
+        /**
+         * Parses the command-line.
+         * @param argv The command-line arguments.
+         * @returns The parsed command-line.
+         */
+        parse(argv?: string[]): any;
+    }
+
+    export = Parser;
+}

From 626cdd625fa118da89872d44a288af573182b986 Mon Sep 17 00:00:00 2001
From: Basarat Ali Syed <bas@basarat.com>
Date: Sat, 22 Mar 2014 13:07:10 +1100
Subject: [PATCH 188/309] momentjs update * fixed indentation * added property
 "version" * using MomentStatic to be consistent with other definitions

---
 moment/moment-tests.ts |  2 +
 moment/moment.d.ts     | 91 +++++++++++++++++++++---------------------
 2 files changed, 48 insertions(+), 45 deletions(-)

diff --git a/moment/moment-tests.ts b/moment/moment-tests.ts
index de51252d9..68a718a33 100644
--- a/moment/moment-tests.ts
+++ b/moment/moment-tests.ts
@@ -416,3 +416,5 @@ moment.lang('en', {
         return number + output;
     }
 });
+
+console.log(moment.version);
diff --git a/moment/moment.d.ts b/moment/moment.d.ts
index 0d7affcb2..4eeb15685 100644
--- a/moment/moment.d.ts
+++ b/moment/moment.d.ts
@@ -175,23 +175,23 @@ interface Moment {
     lang(reset: boolean): void;
     lang(): string;
 
-	max(date: Date): Moment;
-	max(date: number): Moment;
-	max(date: any[]): Moment;
-	max(date: string): Moment;
-	max(date: string, format: string): Moment;
-	max(clone: Moment): Moment;
-	
-	min(date: Date): Moment;
-	min(date: number): Moment;
-	min(date: any[]): Moment;
-	min(date: string): Moment;
-	min(date: string, format: string): Moment;
-	min(clone: Moment): Moment;
-	
-	get(unit: string): number;
-	set(unit: string, value: number): Moment;
-	
+    max(date: Date): Moment;
+    max(date: number): Moment;
+    max(date: any[]): Moment;
+    max(date: string): Moment;
+    max(date: string, format: string): Moment;
+    max(clone: Moment): Moment;
+    
+    min(date: Date): Moment;
+    min(date: number): Moment;
+    min(date: any[]): Moment;
+    min(date: string): Moment;
+    min(date: string, format: string): Moment;
+    min(clone: Moment): Moment;
+    
+    get(unit: string): number;
+    set(unit: string, value: number): Moment;
+    
 }
 
 interface MomentCalendar {
@@ -294,37 +294,38 @@ interface MomentStatic {
     duration(input: MomentInput): Duration;
     duration(object: any): Duration;
     duration(): Duration;
-	
-	parseZone(date: string): Moment;
-	
-	months(): string[];
-	months(index: number): string;
-	months(format: string): string[];
-	months(format: string, index: number): string;
-	monthsShort(): string[];
-	monthsShort(index: number): string;
-	monthsShort(format: string): string[];
-	monthsShort(format: string, index: number): string;
-	weekdays(): string[];
-	weekdays(index: number): string;
-	weekdays(format: string): string[];
-	weekdays(format: string, index: number): string;
-	weekdaysShort(): string[];
-	weekdaysShort(index: number): string;
-	weekdaysShort(format: string): string[];
-	weekdaysShort(format: string, index: number): string;
-	weekdaysMin(): string[];
-	weekdaysMin(index: number): string;
-	weekdaysMin(format: string): string[];
-	weekdaysMin(format: string, index: number): string;
-	
-	normalizeUnits(unit: string): string;
-	
-	invalid(parsingFlags?: Object): Moment;
+    
+    parseZone(date: string): Moment;
+    
+    months(): string[];
+    months(index: number): string;
+    months(format: string): string[];
+    months(format: string, index: number): string;
+    monthsShort(): string[];
+    monthsShort(index: number): string;
+    monthsShort(format: string): string[];
+    monthsShort(format: string, index: number): string;
+    version: string;
+    weekdays(): string[];
+    weekdays(index: number): string;
+    weekdays(format: string): string[];
+    weekdays(format: string, index: number): string;
+    weekdaysShort(): string[];
+    weekdaysShort(index: number): string;
+    weekdaysShort(format: string): string[];
+    weekdaysShort(format: string, index: number): string;
+    weekdaysMin(): string[];
+    weekdaysMin(index: number): string;
+    weekdaysMin(format: string): string[];
+    weekdaysMin(format: string, index: number): string;
+    
+    normalizeUnits(unit: string): string;
+    
+    invalid(parsingFlags?: Object): Moment;
 }
 
 declare var moment: MomentStatic;
 
 declare module "moment" {
-    export = moment;
+    export = MomentStatic;
 }

From 0cdeaaa3a777c1e4d4d30dd8f8d755d24bb27049 Mon Sep 17 00:00:00 2001
From: Paul Loyd <pavelko95@gmail.com>
Date: Sat, 22 Mar 2014 21:29:50 +0400
Subject: [PATCH 189/309] node: rename http.NodeAgent to http.Agent and
 net.NodeSocket to net.Socket

---
 node/node.d.ts           | 36 ++++++++++++++++++------------------
 websocket/websocket.d.ts | 10 +++++-----
 ws/ws.d.ts               |  2 +-
 3 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/node/node.d.ts b/node/node.d.ts
index a0473ad8b..4fafb883e 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -267,7 +267,7 @@ declare module "http" {
         setEncoding(encoding?: string): void;
         pause(): void;
         resume(): void;
-        connection: net.NodeSocket;
+        connection: net.Socket;
     }
     export interface ServerResponse extends NodeEventEmitter, WritableStream {
         // Extended base methods
@@ -491,19 +491,19 @@ declare module "https" {
         rejectUnauthorized?: boolean;
     }
 
-    export interface NodeAgent {
+    export interface Agent {
         maxSockets: number;
         sockets: any;
         requests: any;
     }
     export var Agent: {
-        new (options?: RequestOptions): NodeAgent;
+        new (options?: RequestOptions): Agent;
     };
     export interface Server extends tls.Server { }
     export function createServer(options: ServerOptions, requestListener?: Function): Server;
     export function request(options: RequestOptions, callback?: (res: NodeEventEmitter) =>void ): http.ClientRequest;
     export function get(options: RequestOptions, callback?: (res: NodeEventEmitter) =>void ): http.ClientRequest;
-    export var globalAgent: NodeAgent;
+    export var globalAgent: Agent;
 }
 
 declare module "punycode" {
@@ -669,7 +669,7 @@ declare module "dns" {
 declare module "net" {
     import stream = require("stream");
 
-    export interface NodeSocket extends ReadWriteStream {
+    export interface Socket extends ReadWriteStream {
         // Extended base methods
         write(buffer: NodeBuffer): boolean;
         write(buffer: NodeBuffer, cb?: Function): boolean;
@@ -703,10 +703,10 @@ declare module "net" {
     }
 
     export var Socket: {
-        new (options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }): NodeSocket;
+        new (options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }): Socket;
     };
 
-    export interface Server extends NodeSocket {
+    export interface Server extends Socket {
         listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
         listen(path: string, listeningListener?: Function): void;
         listen(handle: any, listeningListener?: Function): void;
@@ -715,14 +715,14 @@ declare module "net" {
         maxConnections: number;
         connections: number;
     }
-    export function createServer(connectionListener?: (socket: NodeSocket) =>void ): Server;
-    export function createServer(options?: { allowHalfOpen?: boolean; }, connectionListener?: (socket: NodeSocket) =>void ): Server;
-    export function connect(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): NodeSocket;
-    export function connect(port: number, host?: string, connectionListener?: Function): NodeSocket;
-    export function connect(path: string, connectionListener?: Function): NodeSocket;
-    export function createConnection(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): NodeSocket;
-    export function createConnection(port: number, host?: string, connectionListener?: Function): NodeSocket;
-    export function createConnection(path: string, connectionListener?: Function): NodeSocket;
+    export function createServer(connectionListener?: (socket: Socket) =>void ): Server;
+    export function createServer(options?: { allowHalfOpen?: boolean; }, connectionListener?: (socket: Socket) =>void ): Server;
+    export function connect(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): Socket;
+    export function connect(port: number, host?: string, connectionListener?: Function): Socket;
+    export function connect(path: string, connectionListener?: Function): Socket;
+    export function createConnection(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): Socket;
+    export function createConnection(port: number, host?: string, connectionListener?: Function): Socket;
+    export function createConnection(path: string, connectionListener?: Function): Socket;
     export function isIP(input: string): number;
     export function isIPv4(input: string): boolean;
     export function isIPv6(input: string): boolean;
@@ -940,7 +940,7 @@ declare module "tls" {
     export interface ConnectionOptions {
         host?: string;
         port?: number;
-        socket?: net.NodeSocket;
+        socket?: net.Socket;
         pfx?: any;   //string | Buffer
         key?: any;   //string | Buffer
         passphrase?: string;
@@ -1229,11 +1229,11 @@ declare module "tty" {
     import net = require("net");
 
     export function isatty(fd: number): boolean;
-    export interface ReadStream extends net.NodeSocket {
+    export interface ReadStream extends net.Socket {
         isRaw: boolean;
         setRawMode(mode: boolean): void;
     }
-    export interface WriteStream extends net.NodeSocket {
+    export interface WriteStream extends net.Socket {
         columns: number;
         rows: number;
     }
diff --git a/websocket/websocket.d.ts b/websocket/websocket.d.ts
index d3b139222..cc22b89ea 100644
--- a/websocket/websocket.d.ts
+++ b/websocket/websocket.d.ts
@@ -208,7 +208,7 @@ declare module "websocket" {
         requestedExtensions: any[];
 
         cookies: ICookie[];
-        socket: net.NodeSocket;
+        socket: net.Socket;
 
         /**
          * List of strings that indicate the subprotocols the client would like to speak.
@@ -220,7 +220,7 @@ declare module "websocket" {
         requestedProtocols: string[];
         protocolFullCaseMap: {[key: string]: string};
 
-        constructor(socket: net.NodeSocket, httpRequest: http.ClientRequest, config: IServerConfig);
+        constructor(socket: net.Socket, httpRequest: http.ClientRequest, config: IServerConfig);
 
         /**
          * After inspecting the `request` properties, call this function on the
@@ -328,7 +328,7 @@ declare module "websocket" {
         protocol: string;
 
         config: IConfig;
-        socket: net.NodeSocket;
+        socket: net.Socket;
         maskOutgoingPackets: boolean;
         maskBytes: NodeBuffer;
         frameHeader: NodeBuffer;
@@ -361,7 +361,7 @@ declare module "websocket" {
         /** Whether or not the connection is still connected. Read-only */
         connected: boolean;
 
-        constructor(socket: net.NodeSocket, extensions: IExtension[], protocol: string,
+        constructor(socket: net.Socket, extensions: IExtension[], protocol: string,
                     maskOutgoingPackets: boolean, config: IConfig);
 
         /**
@@ -540,7 +540,7 @@ declare module "websocket" {
         origin: string;
         url: url.Url;
         secure: boolean;
-        socket: net.NodeSocket;
+        socket: net.Socket;
         response: http.ClientResponse;
 
         constructor(clientConfig?: IClientConfig);
diff --git a/ws/ws.d.ts b/ws/ws.d.ts
index 39d189b0c..2a3dbae40 100644
--- a/ws/ws.d.ts
+++ b/ws/ws.d.ts
@@ -109,7 +109,7 @@ declare module "ws" {
             constructor(options?: IServerOptions, callback?: Function);
 
             close(): void;
-            handleUpgrade(request: http.ClientRequest, socket: net.NodeSocket,
+            handleUpgrade(request: http.ClientRequest, socket: net.Socket,
                           upgradeHead: NodeBuffer, callback: (client: WebSocket) => void): void;
 
             // Events

From d7c37f857f36d34dea57928108118481972fa89b Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Sun, 23 Mar 2014 15:50:05 +0900
Subject: [PATCH 190/309] Update assert.d.ts

---
 assert/assert.d.ts | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/assert/assert.d.ts b/assert/assert.d.ts
index 7bbd370f3..bccf4fef9 100644
--- a/assert/assert.d.ts
+++ b/assert/assert.d.ts
@@ -51,3 +51,12 @@ declare module assert {
 
     export function ifError(value:any):void;
 }
+
+// duplicate to node.d.ts
+// declare module "assert" {
+//     export = assert;
+// }
+
+declare module "power-assert" {
+    export = assert;
+}

From a3353dec05ea8f1cb959f72a15639e9e770f9319 Mon Sep 17 00:00:00 2001
From: Per Kastman <per.kastman@avegagroup.se>
Date: Sun, 23 Mar 2014 11:34:44 +0100
Subject: [PATCH 191/309] Added AMD support for Knockout validation

---
 knockout.validation/knockout.validation.d.ts | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/knockout.validation/knockout.validation.d.ts b/knockout.validation/knockout.validation.d.ts
index e65ec6743..d5e23a9ba 100644
--- a/knockout.validation/knockout.validation.d.ts
+++ b/knockout.validation/knockout.validation.d.ts
@@ -144,3 +144,8 @@ interface KnockoutSubscribableFunctions<T> {
     rules: KnockoutObservableArray<KnockoutValidationRule>;
 }
 
+declare module "knockout.validation" {
+	export = validation;
+}
+
+declare var validation: KnockoutValidationStatic 

From a5a45a0ae10b02e3021b2d6caa6d05c247a800d2 Mon Sep 17 00:00:00 2001
From: Drew Noakes <git@drewnoakes.com>
Date: Sun, 23 Mar 2014 20:08:42 +0000
Subject: [PATCH 192/309] Update smoothe to v1.22

---
 smoothie/smoothie.d.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/smoothie/smoothie.d.ts b/smoothie/smoothie.d.ts
index 3353c3dbf..aae781d51 100644
--- a/smoothie/smoothie.d.ts
+++ b/smoothie/smoothie.d.ts
@@ -113,6 +113,10 @@ declare module "smoothie"
         scaleSmoothing?: number;
         /** Sets the speed at which the chart pans by. */
         millisPerPixel?: number;
+        /** Whether to render at different DPI depending upon the device. Enabled by default. */
+        enableDpiScaling?: boolean;
+        yMinFormatter?: (min:number, precision:number)=>string;
+        yMaxFormatter?: (max:number, precision:number)=>string;
         maxDataSetLength?: number;
         /** One of: 'bezier', 'linear', 'step' */
         interpolation?: string;

From a00413743e6fd6c95a574a3a30b8bd6697a26a36 Mon Sep 17 00:00:00 2001
From: maanasa <maanasa83@gmail.com>
Date: Mon, 24 Mar 2014 15:29:49 +0530
Subject: [PATCH 193/309] Update typeahead.d.ts

added support for call typeahead(options, dataset) where options include hint, highlight and minLength all of which are optional.
---
 typeahead/typeahead.d.ts | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/typeahead/typeahead.d.ts b/typeahead/typeahead.d.ts
index 9ee948392..f6f387986 100644
--- a/typeahead/typeahead.d.ts
+++ b/typeahead/typeahead.d.ts
@@ -50,6 +50,16 @@ interface JQuery {
       * @param query The query to be set in case method 'setQuery' is used.
       */
     typeahead(methodName: string, query: string): JQuery;
+    
+    /**
+      * Accomodates specifying options such as hint and highlight.
+      * This is in correspondence to the examples mentioned in http://twitter.github.io/typeahead.js/examples/
+      *
+      * @constructor
+      * @param options ('hint' or 'highlight' or 'minLength' all of which are optional)
+      * @param dataset Array of datasets
+      */
+    typeahead(options: Twitter.Typeahead.Options, dataset: Twitter.Typeahead.Dataset): JQuery;
 }
 
 declare module Twitter.Typeahead {
@@ -243,4 +253,26 @@ declare module Twitter.Typeahead {
           */
         tokens: string[];
     }
+    
+     /**
+      * When initializing a typeahead, there are a number of options you can configure.
+      */
+    interface Options {
+      /**
+        * highlight:  If true, when suggestions are rendered, 
+        * pattern matches for the current query in text nodes will be wrapped in a strong element.
+        * Defaults to false. 
+        */
+      highlight?: boolean;
+
+      /**
+        * If false, the typeahead will not show a hint. Defaults to true.
+        */
+      hint?: boolean;
+
+      /**
+        * The minimum character length needed before suggestions start getting rendered. Defaults to 1.
+        */
+      minLength?: number;
+    }
 }

From a8890740fc0649e35fad5300e04fd094febbe19d Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Mon, 24 Mar 2014 12:59:48 +0000
Subject: [PATCH 194/309] jQuery: remove unused resolve

---
 jquery/jquery.d.ts | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 5928165b3..b42f77aaa 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -484,14 +484,6 @@ interface JQueryDeferred<T> extends JQueryPromise<T> {
      */
     resolve(value?: T, ...args: any[]): JQueryDeferred<T>;
 
-    // COMMENTED OUT AS MAKES resolve LESS USEFUL - PERHAPS REMOVE ENTIRELY LATER
-    /**
-     * Resolve a Deferred object and call any doneCallbacks with the given args.
-     * 
-     * @param args Optional arguments that are passed to the doneCallbacks.
-     */
-    //resolve(...args: any[]): JQueryDeferred<T>;
-
     /**
      * Resolve a Deferred object and call any doneCallbacks with the given context and args.
      * 

From 3a583df3e4e450bc0d64565cace8defd35a87eed Mon Sep 17 00:00:00 2001
From: John Vilk <jvilk@cs.umass.edu>
Date: Mon, 24 Mar 2014 12:24:46 -0400
Subject: [PATCH 195/309] FileSystem `root` is a DirectoryEntry.

This is specified in the official standard:
http://www.w3.org/TR/file-system-api/#the-filesystem-interface

Interestingly enough, these typings already specify the `root` of
FileSystemSync (the synchronous version of the API) to be a DirectorySync. This must have been an oversight of the original author of these typings.
---
 filesystem/filesystem.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/filesystem/filesystem.d.ts b/filesystem/filesystem.d.ts
index d3447f162..11fb48dd0 100644
--- a/filesystem/filesystem.d.ts
+++ b/filesystem/filesystem.d.ts
@@ -110,7 +110,7 @@ interface FileSystem{
      * The root directory of the file system.
      * @readonly
      */
-    root:any;
+    root: DirectoryEntry;
 }
 
 interface Entry {

From 40e8f2f18187b6227e66676818152dedfb0a4e99 Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Mon, 24 Mar 2014 16:55:35 +0000
Subject: [PATCH 196/309] Q: Some JSDoc goodness

Created based on https://github.com/kriskowal/q/wiki/API-Reference
---
 q/Q.d.ts | 220 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 218 insertions(+), 2 deletions(-)

diff --git a/q/Q.d.ts b/q/Q.d.ts
index 4d7a7ce4f..85462503a 100644
--- a/q/Q.d.ts
+++ b/q/Q.d.ts
@@ -1,12 +1,23 @@
 // Type definitions for Q
 // Project: https://github.com/kriskowal/q
-// Definitions by: Barrie Nemetchek, Andrew Gaspar
+// Definitions by: Barrie Nemetchek, Andrew Gaspar, John Reilly
 // Definitions: https://github.com/borisyankov/DefinitelyTyped  
 
 /// <reference path="../jquery/jquery.d.ts"/>
 
+/**
+ * If value is a Q promise, returns the promise.
+ * If value is a promise from another library it is coerced into a Q promise (where possible).
+ */
 declare function Q<T>(promise: Q.IPromise<T>): Q.Promise<T>;
+/**
+ * If value is a Q promise, returns the promise.
+ * If value is a promise from another library it is coerced into a Q promise (where possible).
+ */
 declare function Q<T>(promise: JQueryPromise<T>): Q.Promise<T>;
+/**
+ * If value is not a promise, returns a promise that is fulfilled with value.
+ */
 declare function Q<T>(value: T): Q.Promise<T>;
 
 declare module Q {
@@ -26,51 +37,148 @@ declare module Q {
     }
 
     interface Promise<T> {
+        /**
+         * Like a finally clause, allows you to observe either the fulfillment or rejection of a promise, but to do so without modifying the final value. This is useful for collecting resources regardless of whether a job succeeded, like closing a database connection, shutting a server down, or deleting an unneeded key from an object.
+
+         * finally returns a promise, which will become resolved with the same fulfillment value or rejection reason as promise. However, if callback returns a promise, the resolution of the returned promise will be delayed until the promise returned from callback is finished.
+         */
         fin(finallyCallback: () => any): Promise<T>;
+        /**
+         * Like a finally clause, allows you to observe either the fulfillment or rejection of a promise, but to do so without modifying the final value. This is useful for collecting resources regardless of whether a job succeeded, like closing a database connection, shutting a server down, or deleting an unneeded key from an object.
+
+         * finally returns a promise, which will become resolved with the same fulfillment value or rejection reason as promise. However, if callback returns a promise, the resolution of the returned promise will be delayed until the promise returned from callback is finished.
+         */
         finally(finallyCallback: () => any): Promise<T>;
 
+        /**
+         * The then method from the Promises/A+ specification, with an additional progress handler.
+         */
         then<U>(onFulfill: (value: T) => IPromise<U>, onReject?: (reason: any) => IPromise<U>, onProgress?: Function): Promise<U>;
+        /**
+         * The then method from the Promises/A+ specification, with an additional progress handler.
+         */
         then<U>(onFulfill: (value: T) => IPromise<U>, onReject?: (reason: any) => U, onProgress?: Function): Promise<U>;
+        /**
+         * The then method from the Promises/A+ specification, with an additional progress handler.
+         */
         then<U>(onFulfill: (value: T) => U, onReject?: (reason: any) => IPromise<U>, onProgress?: Function): Promise<U>;
+        /**
+         * The then method from the Promises/A+ specification, with an additional progress handler.
+         */
         then<U>(onFulfill: (value: T) => U, onReject?: (reason: any) => U, onProgress?: Function): Promise<U>;
 
+        /**
+         * Like then, but "spreads" the array into a variadic fulfillment handler. If any of the promises in the array are rejected, instead calls onRejected with the first rejected promise's rejection reason.
+         * 
+         * This is especially useful in conjunction with all
+         */
         spread<U>(onFulfilled: Function, onRejected?: Function): Promise<U>;
 
         fail<U>(onRejected: (reason: any) => U): Promise<U>;
         fail<U>(onRejected: (reason: any) => IPromise<U>): Promise<U>;
+        /**
+         * A sugar method, equivalent to promise.then(undefined, onRejected).
+         */
         catch<U>(onRejected: (reason: any) => U): Promise<U>;
+        /**
+         * A sugar method, equivalent to promise.then(undefined, onRejected).
+         */
         catch<U>(onRejected: (reason: any) => IPromise<U>): Promise<U>;
 
+        /**
+         * A sugar method, equivalent to promise.then(undefined, undefined, onProgress).
+         */
         progress(onProgress: (progress: any) => any): Promise<T>;
 
+        /**
+         * Much like then, but with different behavior around unhandled rejection. If there is an unhandled rejection, either because promise is rejected and no onRejected callback was provided, or because onFulfilled or onRejected threw an error or returned a rejected promise, the resulting rejection reason is thrown as an exception in a future turn of the event loop.
+         *
+         * This method should be used to terminate chains of promises that will not be passed elsewhere. Since exceptions thrown in then callbacks are consumed and transformed into rejections, exceptions at the end of the chain are easy to accidentally, silently ignore. By arranging for the exception to be thrown in a future turn of the event loop, so that it won't be caught, it causes an onerror event on the browser window, or an uncaughtException event on Node.js's process object.
+         *
+         * Exceptions thrown by done will have long stack traces, if Q.longStackSupport is set to true. If Q.onerror is set, exceptions will be delivered there instead of thrown in a future turn.
+         *
+         * The Golden Rule of done vs. then usage is: either return your promise to someone else, or if the chain ends with you, call done to terminate it.
+         */
         done(onFulfilled?: (value: T) => any, onRejected?: (reason: any) => any, onProgress?: (progress: any) => any): void;
 
+        /**
+         * Returns a promise to get the named property of an object. Essentially equivalent to
+         * 
+         * promise.then(function (o) {
+         *     return o[propertyName];
+         * });
+         */
         get<U>(propertyName: String): Promise<U>;
         set<U>(propertyName: String, value: any): Promise<U>;
         delete<U>(propertyName: String): Promise<U>;
+        /**
+         * Returns a promise for the result of calling the named method of an object with the given array of arguments. The object itself is this in the function, just like a synchronous method call. Essentially equivalent to
+         * 
+         * promise.then(function (o) {
+         *     return o[methodName].apply(o, args);
+         * });
+         */
         post<U>(methodName: String, args: any[]): Promise<U>;
+        /**
+         * Returns a promise for the result of calling the named method of an object with the given variadic arguments. The object itself is this in the function, just like a synchronous method call.
+         */
         invoke<U>(methodName: String, ...args: any[]): Promise<U>;
         fapply<U>(args: any[]): Promise<U>;
         fcall<U>(...args: any[]): Promise<U>;
 
+        /**
+         * Returns a promise for an array of the property names of an object. Essentially equivalent to
+         * 
+         * promise.then(function (o) {
+         *     return Object.keys(o);
+         * });
+         */
         keys(): Promise<string[]>;
         
+        /**
+         * A sugar method, equivalent to promise.then(function () { return value; }).
+         */
         thenResolve<U>(value: U): Promise<U>;
+        /**
+         * A sugar method, equivalent to promise.then(function () { throw reason; }).
+         */
         thenReject(reason: any): Promise<T>;
         timeout(ms: number, message?: string): Promise<T>;
+        /**
+         * Returns a promise that will have the same result as promise, but will only be fulfilled or rejected after at least ms milliseconds have passed.
+         */
         delay(ms: number): Promise<T>;
 
+        /**
+         * Returns whether a given promise is in the fulfilled state. When the static version is used on non-promises, the result is always true.
+         */
         isFulfilled(): boolean;
+        /**
+         * Returns whether a given promise is in the rejected state. When the static version is used on non-promises, the result is always false.
+         */
         isRejected(): boolean;
+        /**
+         * Returns whether a given promise is in the pending state. When the static version is used on non-promises, the result is always false.
+         */
         isPending(): boolean;
 
         valueOf(): any;
 
+        /**
+         * Returns a "state snapshot" object, which will be in one of three forms:
+         * 
+         * - { state: "pending" }
+         * - { state: "fulfilled", value: <fulfllment value> }
+         * - { state: "rejected", reason: <rejection reason> }
+         */
         inspect(): PromiseState<T>;
     }
 
     interface PromiseState<T> {
-        state: string /* "fulfilled", "rejected", "pending" */;
+        /**
+         * "fulfilled", "rejected", "pending"
+         */
+        state: string;
         value?: T;
         reason?: any;
     }
@@ -106,54 +214,162 @@ declare module Q {
     export function nsend<T>(nodeModule: any, functionName: string, ...args: any[]): Promise<T>;
     export function nmcall<T>(nodeModule: any, functionName: string, ...args: any[]): Promise<T>;
 
+    /**
+     * Returns a promise that is fulfilled with an array containing the fulfillment value of each promise, or is rejected with the same rejection reason as the first promise to be rejected.
+     */
     export function all<T>(promises: IPromise<T>[]): Promise<T[]>;
+    /**
+     * Returns a promise that is fulfilled with an array containing the fulfillment value of each promise, or is rejected with the same rejection reason as the first promise to be rejected.
+     */
     export function all<T>(promises: any[]): Promise<T[]>;
     
+    /**
+     * Returns a promise that is fulfilled with an array of promise state snapshots, but only after all the original promises have settled, i.e. become either fulfilled or rejected.
+     */
     export function allSettled<T>(promises: IPromise<T>[]): Promise<PromiseState<T>[]>;
+    /**
+     * Returns a promise that is fulfilled with an array of promise state snapshots, but only after all the original promises have settled, i.e. become either fulfilled or rejected.
+     */
     export function allSettled<T>(promises: any[]): Promise<PromiseState<T>[]>;
 
     export function allResolved<T>(promises: IPromise<T>[]): Promise<Promise<T>[]>;
     export function allResolved<T>(promises: any[]): Promise<Promise<T>[]>;
 
+    /**
+     * Like then, but "spreads" the array into a variadic fulfillment handler. If any of the promises in the array are rejected, instead calls onRejected with the first rejected promise's rejection reason. 
+     * This is especially useful in conjunction with all.
+     */
     export function spread<U>(promises: any[], onFulfilled: (...args: any[]) => IPromise<U>, onRejected: (reason: any) => IPromise<U>): Promise<U>;
+    /**
+     * Like then, but "spreads" the array into a variadic fulfillment handler. If any of the promises in the array are rejected, instead calls onRejected with the first rejected promise's rejection reason. 
+     * This is especially useful in conjunction with all.
+     */
     export function spread<U>(promises: any[], onFulfilled: (...args: any[]) => IPromise<U>, onRejected: (reason: any) => U): Promise<U>;
+    /**
+     * Like then, but "spreads" the array into a variadic fulfillment handler. If any of the promises in the array are rejected, instead calls onRejected with the first rejected promise's rejection reason. 
+     * This is especially useful in conjunction with all.
+     */
     export function spread<U>(promises: any[], onFulfilled: (...args: any[]) => U, onRejected: (reason: any) => IPromise<U>): Promise<U>;
+    /**
+     * Like then, but "spreads" the array into a variadic fulfillment handler. If any of the promises in the array are rejected, instead calls onRejected with the first rejected promise's rejection reason. 
+     * This is especially useful in conjunction with all.
+     */
     export function spread<U>(promises: any[], onFulfilled: (...args: any[]) => U, onRejected: (reason: any) => U): Promise<U>;
     
+    /**
+     * Like then, but "spreads" the array into a variadic fulfillment handler. If any of the promises in the array are rejected, instead calls onRejected with the first rejected promise's rejection reason. 
+     * This is especially useful in conjunction with all.
+     */
     export function spread<T, U>(promises: IPromise<T>[], onFulfilled: (...args: T[]) => IPromise<U>, onRejected: (reason: any) => IPromise<U>): Promise<U>;
+    /**
+     * Like then, but "spreads" the array into a variadic fulfillment handler. If any of the promises in the array are rejected, instead calls onRejected with the first rejected promise's rejection reason. 
+     * This is especially useful in conjunction with all.
+     */
     export function spread<T, U>(promises: IPromise<T>[], onFulfilled: (...args: T[]) => IPromise<U>, onRejected: (reason: any) => U): Promise<U>;
+    /**
+     * Like then, but "spreads" the array into a variadic fulfillment handler. If any of the promises in the array are rejected, instead calls onRejected with the first rejected promise's rejection reason. 
+     * This is especially useful in conjunction with all.
+     */
     export function spread<T, U>(promises: IPromise<T>[], onFulfilled: (...args: T[]) => U, onRejected: (reason: any) => IPromise<U>): Promise<U>;
+    /**
+     * Like then, but "spreads" the array into a variadic fulfillment handler. If any of the promises in the array are rejected, instead calls onRejected with the first rejected promise's rejection reason. 
+     * This is especially useful in conjunction with all.
+     */
     export function spread<T, U>(promises: IPromise<T>[], onFulfilled: (...args: T[]) => U, onRejected: (reason: any) => U): Promise<U>;
     
+    /**
+     * Returns a promise that will have the same result as promise, except that if promise is not fulfilled or rejected before ms milliseconds, the returned promise will be rejected with an Error with the given message. If message is not supplied, the message will be "Timed out after " + ms + " ms".
+     */
     export function timeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T>;
 
+    /**
+     * Returns a promise that will have the same result as promise, but will only be fulfilled or rejected after at least ms milliseconds have passed.
+     */
     export function delay<T>(promise: Promise<T>, ms: number): Promise<T>;
+    /**
+     * Returns a promise that will have the same result as promise, but will only be fulfilled or rejected after at least ms milliseconds have passed.
+     */
     export function delay<T>(value: T, ms: number): Promise<T>;
 
+    /**
+     * Returns whether a given promise is in the fulfilled state. When the static version is used on non-promises, the result is always true.
+     */
     export function isFulfilled(promise: Promise<any>): boolean;
+    /**
+     * Returns whether a given promise is in the rejected state. When the static version is used on non-promises, the result is always false.
+     */
     export function isRejected(promise: Promise<any>): boolean;
+    /**
+     * Returns whether a given promise is in the pending state. When the static version is used on non-promises, the result is always false.
+     */
     export function isPending(promise: Promise<any>): boolean;
 
+    /**
+     * Returns a "deferred" object with a:
+     * promise property
+     * resolve(value) method
+     * reject(reason) method
+     * notify(value) method
+     * makeNodeResolver() method
+     */
     export function defer<T>(): Deferred<T>;
 
+    /**
+     * Returns a promise that is rejected with reason.
+     */
     export function reject(reason?: any): Promise<any>;
 
     export function promise<T>(resolver: (resolve: (val: IPromise<T>) => void , reject: (reason: any) => void , notify: (progress: any) => void ) => void ): Promise<T>;
     export function promise<T>(resolver: (resolve: (val: T) => void , reject: (reason: any) => void , notify: (progress: any) => void ) => void ): Promise<T>;
 
+    /**
+     * Creates a new version of func that accepts any combination of promise and non-promise values, converting them to their fulfillment values before calling the original func. The returned version also always returns a promise: if func does a return or throw, then Q.promised(func) will return fulfilled or rejected promise, respectively.
+     *
+     * This can be useful for creating functions that accept either promises or non-promise values, and for ensuring that the function always returns a promise even in the face of unintentional thrown exceptions.
+     */
     export function promised<T>(callback: (...args: any[]) => T): (...args: any[]) => Promise<T>;
 
+    /**
+     * Returns whether the given value is a Q promise.
+     */
     export function isPromise(object: any): boolean;
+    /**
+     * Returns whether the given value is a promise (i.e. it's an object with a then function).
+     */
     export function isPromiseAlike(object: any): boolean;
+    /**
+     * Returns whether a given promise is in the pending state. When the static version is used on non-promises, the result is always false.
+     */
     export function isPending(object: any): boolean;
 
+    /**
+     * This is an experimental tool for converting a generator function into a deferred function. This has the potential of reducing nested callbacks in engines that support yield.
+     */
     export function async<T>(generatorFunction: any): (...args: any[]) => Promise<T>;
     export function nextTick(callback: Function): void;
 
+    /**
+     * A settable property that will intercept any uncaught errors that would otherwise be thrown in the next tick of the event loop, usually as a result of done. Can be useful for getting the full stack trace of an error in browsers, which is not usually possible with window.onerror.
+     */
     export var onerror: (reason: any) => void;
+    /**
+     * A settable property that lets you turn on long stack trace support. If turned on, "stack jumps" will be tracked across asynchronous promise operations, so that if an uncaught error is thrown by done or a rejection reason's stack property is inspected in a rejection callback, a long stack trace is produced.
+     */
     export var longStackSupport: boolean;
 
+    /**
+     * Calling resolve with a pending promise causes promise to wait on the passed promise, becoming fulfilled with its fulfillment value or rejected with its rejection reason (or staying pending forever, if the passed promise does).
+     * Calling resolve with a rejected promise causes promise to be rejected with the passed promise's rejection reason.
+     * Calling resolve with a fulfilled promise causes promise to be fulfilled with the passed promise's fulfillment value.
+     * Calling resolve with a non-promise value causes promise to be fulfilled with that value.
+     */
     export function resolve<T>(object: IPromise<T>): Promise<T>;
+    /**
+     * Calling resolve with a pending promise causes promise to wait on the passed promise, becoming fulfilled with its fulfillment value or rejected with its rejection reason (or staying pending forever, if the passed promise does).
+     * Calling resolve with a rejected promise causes promise to be rejected with the passed promise's rejection reason.
+     * Calling resolve with a fulfilled promise causes promise to be fulfilled with the passed promise's fulfillment value.
+     * Calling resolve with a non-promise value causes promise to be fulfilled with that value.
+     */
     export function resolve<T>(object: T): Promise<T>;
 }
 

From b16db4154d9bda4f7a379f10a8d383b09d2309fd Mon Sep 17 00:00:00 2001
From: hansrwindhoff <hansrwindhoff@gmail.com>
Date: Mon, 24 Mar 2014 14:29:01 -0600
Subject: [PATCH 197/309] selectItem

---
 ng-grid/ng-grid.d.ts | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/ng-grid/ng-grid.d.ts b/ng-grid/ng-grid.d.ts
index e72344d34..70f4f569f 100644
--- a/ng-grid/ng-grid.d.ts
+++ b/ng-grid/ng-grid.d.ts
@@ -130,6 +130,9 @@ declare module ngGrid {
         /** all of the items selected in the grid. In single select mode there will only be one item in the array. */
         selectedItems?: any[];
 
+        /** Select deselect an item by index. */
+        selectItem?: (idx:number, state:boolean) =>any;
+
         /** Disable row selections by clicking on the row and only when the checkbox is clicked. */
         selectWithCheckboxOnly?: boolean;
 

From bc0028b45a0771fb0daa1bb0c68c1a1ff1fc78fa Mon Sep 17 00:00:00 2001
From: Panu Horsmalahti <panu.horsmalahti@iki.fi>
Date: Tue, 25 Mar 2014 14:03:06 +0200
Subject: [PATCH 198/309] Update angular-protractor.d.ts

Change string to the correct type, webdriver.promise.Promise.
---
 angular-protractor/angular-protractor.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/angular-protractor/angular-protractor.d.ts b/angular-protractor/angular-protractor.d.ts
index 951ba85de..a78fc42f3 100644
--- a/angular-protractor/angular-protractor.d.ts
+++ b/angular-protractor/angular-protractor.d.ts
@@ -772,7 +772,7 @@ declare module protractor {
         /**
          * Returns the current absolute url from AngularJS.
          */
-        getLocationAbsUrl(): string;
+        getLocationAbsUrl(): webdriver.promise.Promise;
 
         /**
          * Pauses the test and injects some helper functions into the browser, so that
@@ -865,4 +865,4 @@ declare var element: protractor.Element;
 
 declare module 'protractor' {
     export = protractor;
-}
\ No newline at end of file
+}

From 2ec79b766d51c092769b193f2b329c66b87287da Mon Sep 17 00:00:00 2001
From: Panu Horsmalahti <panu.horsmalahti@iki.fi>
Date: Tue, 25 Mar 2014 15:11:14 +0200
Subject: [PATCH 199/309] Update angular-protractor-tests.ts

Fix test to correspond with the new, correct type for getLocationAbsUrl.
---
 angular-protractor/angular-protractor-tests.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/angular-protractor/angular-protractor-tests.ts b/angular-protractor/angular-protractor-tests.ts
index 2c8e72f07..2ed627af8 100644
--- a/angular-protractor/angular-protractor-tests.ts
+++ b/angular-protractor/angular-protractor-tests.ts
@@ -167,7 +167,7 @@ function TestProtractor() {
 
     var webElement: webdriver.WebElement = ptor.wrapWebElement(new webdriver.WebElement(driver, 'id'));
 
-    var locationAbsUrl: string = ptor.getLocationAbsUrl();
+    var locationAbsUrl: webdriver.promise.Promise = ptor.getLocationAbsUrl();
 }
 
 function TestElement() {
@@ -239,4 +239,4 @@ function TestWebElements() {
     webElement = webElement.findElement(by.id('id')).$('.class');
     promise = webElement.findElement(by.id('id')).$$('.class');
     promise = webElement.findElement(by.id('id')).evaluate('something');
-}
\ No newline at end of file
+}

From 2e2fdad63488930262d09724a3e04d5350b720f1 Mon Sep 17 00:00:00 2001
From: David Rogers <docta5@hotmail.com>
Date: Tue, 25 Mar 2014 11:41:14 -0700
Subject: [PATCH 200/309] Add support for optional event data.

---
 jquery/jquery.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index b42f77aaa..2d98b338b 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -2671,7 +2671,7 @@ interface JQuery {
      * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the selector is null or omitted, the event is always triggered when it reaches the selected element.
      * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false.
      */
-    on(events: string, selector: string, handler: (eventObject: JQueryEventObject) => any): JQuery;
+    on(events: string, selector: string, handler: (eventObject: JQueryEventObject, ...eventData: any[]) => any): JQuery;
     /**
      * Attach an event handler function for one or more events to the selected elements.
      *
@@ -2680,7 +2680,7 @@ interface JQuery {
      * @param data Data to be passed to the handler in event.data when an event is triggered.
      * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false.
      */
-    on(events: string, selector: string, data: any, handler: (eventObject: JQueryEventObject) => any): JQuery;
+    on(events: string, selector: string, data: any, handler: (eventObject: JQueryEventObject, ...eventData: any[]) => any): JQuery;
     /**
      * Attach an event handler function for one or more events to the selected elements.
      *

From 58509774b492b9f46e18548e656ade0348cda842 Mon Sep 17 00:00:00 2001
From: LiFeleSs <lifeless85@gmail.com>
Date: Tue, 25 Mar 2014 21:46:43 +0100
Subject: [PATCH 201/309] use method moved to Parent interface

moved the use method from doc interface to Parent interface so it can be used on all svgjs.element
---
 svgjs/svgjs.d.ts | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/svgjs/svgjs.d.ts b/svgjs/svgjs.d.ts
index 44f32d9b1..ec3ffe5c5 100644
--- a/svgjs/svgjs.d.ts
+++ b/svgjs/svgjs.d.ts
@@ -31,8 +31,6 @@ declare module svgjs {
         
         defs():Defs;
 
-        use(element:Element):Element;
-
         clear():void;
 
         mask():Mask;
@@ -220,7 +218,8 @@ declare module svgjs {
         path(data:string):Element;
         image(url:string, w?:number, h?:number):Element;
         text(text:string):Element;
-        text(adder:(element:Element)=>void):Element;        
+        text(adder:(element:Element)=>void):Element;
+        use(element:Element):Element;
 
         group():Element;
     }

From 22e4f4f5426ee844b4e6a9c13bf9c72477cc460e Mon Sep 17 00:00:00 2001
From: Basarat Syed <bas@picnicsoftware.com>
Date: Wed, 26 Mar 2014 16:20:28 +1100
Subject: [PATCH 202/309] momentjs : fix external module definition + added
 tests

---
 moment/moment-external-tests.ts | 422 ++++++++++++++++++++++++++++++++
 moment/moment.d.ts              |   4 +-
 2 files changed, 424 insertions(+), 2 deletions(-)
 create mode 100644 moment/moment-external-tests.ts

diff --git a/moment/moment-external-tests.ts b/moment/moment-external-tests.ts
new file mode 100644
index 000000000..9c6116892
--- /dev/null
+++ b/moment/moment-external-tests.ts
@@ -0,0 +1,422 @@
+/// <reference path="moment.d.ts" />
+
+import moment = require('moment');
+
+moment().add('hours', 1).fromNow();
+
+var day = new Date(2011, 9, 16);
+var dayWrapper = moment(day);
+var otherDay = moment(new Date(2020, 3, 7));
+
+var day1 = moment(1318781876406);
+var day2 = moment.unix(1318781876);
+var day3 = moment("Dec 25, 1995");
+var day4 = moment("12-25-1995", "MM-DD-YYYY");
+var day5 = moment("12-25-1995", ["MM-DD-YYYY", "YYYY-MM-DD"]);
+var day6 = moment("05-06-1995", ["MM-DD-YYYY", "DD-MM-YYYY"]);
+var now = moment();
+var day7 = moment([2010, 1, 14, 15, 25, 50, 125]);
+var day8 = moment([2010]);
+var day9 = moment([2010, 6]);
+var day10 = moment([2010, 6, 10]); 
+var array = [2010, 1, 14, 15, 25, 50, 125];
+var day11 = moment(Date.UTC.apply({}, array));
+var day12 = moment.unix(1318781876);
+
+moment({ years: 2010, months: 3, days: 5, hours: 15, minutes: 10, seconds: 3, milliseconds: 123 });
+moment("20140101", "YYYYMMDD", true);
+moment("20140101", "YYYYMMDD", "en");
+moment("20140101", "YYYYMMDD", "en", true);
+moment("20140101", ["YYYYMMDD"], true);
+moment("20140101", ["YYYYMMDD"], "en");
+moment("20140101", ["YYYYMMDD"], "en", true);
+
+var a = moment([2012]);
+var b = moment(a);
+a.year(2000);
+b.year(); // 2012
+
+moment.utc();
+moment.utc(12345);
+moment.utc([12, 34, 56]);
+moment.utc({ years: 2010, months: 3, days: 5, hours: 15, minutes: 10, seconds: 3, milliseconds: 123 });
+moment.utc("1-2-3");
+moment.utc("1-2-3", "3-2-1");
+moment.utc("1-2-3", "3-2-1", true);
+moment.utc("1-2-3", "3-2-1", "en");
+moment.utc("1-2-3", "3-2-1", "en", true);
+moment.utc("01-01-2014", ["DD-MM-YYYY", "MM-DD-YYYY"]);
+moment.utc("01-01-2014", ["DD-MM-YYYY", "MM-DD-YYYY"], true);
+moment.utc("01-01-2014", ["DD-MM-YYYY", "MM-DD-YYYY"], "en");
+moment.utc("01-01-2014", ["DD-MM-YYYY", "MM-DD-YYYY"], "en", true);
+
+var a2 = moment.utc([2011, 0, 1, 8]);
+a.hours();
+a.local();
+a.hours();
+
+moment("2011-10-10", "YYYY-MM-DD").isValid(); 
+moment("2011-10-50", "YYYY-MM-DD").isValid(); 
+moment("2011-10-10T10:20:90").isValid();
+moment([2011, 0, 1]).isValid();
+moment([2011, 0, 50]).isValid();
+moment("not a date").isValid();
+
+moment().add('days', 7).subtract('months', 1).year(2009).hours(0).minutes(0).seconds(0);
+
+moment().add('days', 7);
+moment().add('days', 7).add('months', 1);
+moment().add({days:7,months:1});
+moment().add('milliseconds', 1000000); 
+moment().add('days', 360);
+moment([2010, 0, 31]);  
+moment([2010, 0, 31]).add('months', 1);
+var m = moment(new Date(2011, 2, 12, 5, 0, 0));
+m.hours(); 
+m.add('days', 1).hours();
+var m2 = moment(new Date(2011, 2, 12, 5, 0, 0)); 
+m2.hours();
+m2.add('hours', 24).hours(); 
+var duration = moment.duration({'days': 1});
+moment([2012, 0, 31]).add(duration);
+
+moment().subtract('days', 7);
+
+moment().seconds(30);
+moment().minutes(30);
+
+moment().hours(12); 
+moment().date(5);
+moment().day(5);
+moment().day("Sunday");
+moment().month(5);
+moment().month("January");
+moment().year(1984);
+moment().startOf('year'); 
+moment().month(0).date(1).hours(0).minutes(0).seconds(0).milliseconds(0);
+moment().startOf('hour');
+moment().minutes(0).seconds(0).milliseconds(0);
+moment().weekday();
+moment().weekday(0);
+moment().isoWeekday(1);
+moment().isoWeekday();
+moment().weekYear(2);
+moment().weekYear();
+moment().isoWeekYear(3);
+moment().isoWeekYear();
+moment().week();
+moment().week(45);
+moment().weeks();
+moment().weeks(45);
+moment().isoWeek();
+moment().isoWeek(45);
+moment().isoWeeks();
+moment().isoWeeks(45);
+
+var getMilliseconds: number = moment().milliseconds(); 
+var getSeconds: number = moment().seconds(); 
+var getMinutes: number = moment().minutes(); 
+var getHours: number = moment().hours(); 
+var getDate: number = moment().date();
+var getDay: number = moment().day();
+var getMonth: number = moment().month();
+var getQuater: number = moment().quarter();
+var getYear: number = moment().year();
+
+moment().hours(0).minutes(0).seconds(0).milliseconds(0);
+
+var a3 = moment([2011, 0, 1, 8]);
+a3.hours();
+a3.utc();
+a3.hours();
+
+var a4 = moment([2010, 1, 14, 15, 25, 50, 125]);
+a4.format("dddd, MMMM Do YYYY, h:mm:ss a"); 
+a4.format("ddd, hA");
+
+moment().format('\\L');
+moment().format('[today] DDDD'); 
+
+var a5 = moment([2007, 0, 29]);
+var b5 = moment([2007, 0, 28]);
+a5.from(b5);
+
+var a6 = moment([2007, 0, 29]);
+var b6 = moment([2007, 0, 28]);
+a6.from(b6);
+a6.from([2007, 0, 28]);         
+a6.from(new Date(2007, 0, 28)); 
+a6.from("1-28-2007");
+
+var a7 = moment();
+var b7 = moment("10-10-1900", "MM-DD-YYYY");
+a7.from(b7);
+
+var start = moment([2007, 0, 5]);
+var end = moment([2007, 0, 10]);
+start.from(end);   
+start.from(end, true);
+
+moment([2007, 0, 29]).fromNow(); 
+moment([2007, 0, 29]).fromNow();     
+moment([2007, 0, 29]).fromNow(true); 
+
+var a8 = moment([2007, 0, 29]);
+var b8 = moment([2007, 0, 28]);
+a8.diff(b8) ;
+a8.diff(b8, 'days');
+a8.diff(b8, 'years')      
+a8.diff(b8, 'years', true);
+
+moment([2007, 0, 29]).toDate();
+moment([2007, 1, 23]).toISOString();
+moment(1318874398806).valueOf(); 
+moment(1318874398806).unix();
+moment([2000]).isLeapYear();
+moment().zone();
+moment("2012-2", "YYYY-MM").daysInMonth();
+moment([2011, 2, 12]).isDST();
+
+moment.isMoment();
+moment.isMoment(new Date());
+moment.isMoment(moment());
+
+moment.lang('fr');
+moment(1316116057189).fromNow();
+
+moment.lang('en'); 
+var globalLang = moment();
+var localLang = moment();
+localLang.lang('fr'); 
+localLang.format('LLLL'); 
+globalLang.format('LLLL'); 
+
+moment.duration(100);
+moment.duration(2, 'seconds');
+moment.duration({
+    seconds: 2,
+    minutes: 2,
+    hours: 2,
+    days: 2,
+    weeks: 2,
+    months: 2,
+    years: 2
+});
+moment.duration(1, "minutes").humanize();
+moment.duration(500).milliseconds();
+moment.duration(500).asMilliseconds();
+moment.duration(500).seconds();
+moment.duration(500).asSeconds();
+moment.duration().minutes();
+moment.duration().asMinutes();
+
+// Defining a custom language: 
+moment.lang('en', {
+    months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
+    monthsShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
+    weekdays: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+    weekdaysShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+    weekdaysMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
+    longDateFormat: {
+        LT: "h:mm A",
+        L: "MM/DD/YYYY",
+        LL: "MMMM D YYYY",
+        LLL: "MMMM D YYYY LT",
+        LLLL: "dddd, MMMM D YYYY LT"
+    },
+    relativeTime: {
+        future: "in %s",
+        past: "%s ago",
+        s: "seconds",
+        m: "a minute",
+        mm: "%d minutes",
+        h: "an hour",
+        hh: "%d hours",
+        d: "a day",
+        dd: "%d days",
+        M: "a month",
+        MM: "%d months",
+        y: "a year",
+        yy: "%d years"
+    },
+    meridiem: function (hour, minute, isLower) {
+        if (hour < 9) {
+            return "??";
+        } else if (hour < 11 && minute < 30) {
+            return "??";
+        } else if (hour < 13 && minute < 30) {
+            return "??";
+        } else if (hour < 18) {
+            return "??";
+        } else {
+            return "??";
+        }
+    },
+    calendar: {
+        lastDay: '[Yesterday at] LT',
+        sameDay: '[Today at] LT',
+        nextDay: '[Tomorrow at] LT',
+        lastWeek: '[last] dddd [at] LT',
+        nextWeek: 'dddd [at] LT',
+        sameElse: 'L'
+    },
+    ordinal: function (number) {
+        var b = number % 10;
+        return (~~(number % 100 / 10) === 1) ? 'th' :
+            (b === 1) ? 'st' :
+            (b === 2) ? 'nd' :
+            (b === 3) ? 'rd' : 'th';
+    }
+});
+
+moment.lang('en', {
+    months : [
+        "January", "February", "March", "April", "May", "June", "July",
+        "August", "September", "October", "November", "December"
+    ]
+});
+
+moment.lang('en', {
+    months : function (momentToFormat: Moment, format: string) {
+        // momentToFormat is the moment currently being formatted
+        // format is the formatting string
+        if (/^MMMM/.test(format)) { // if the format starts with 'MMMM'
+            return this.nominative[momentToFormat.month()];
+        } else {
+            return this.subjective[momentToFormat.month()];
+        }
+    }
+});
+
+moment.lang('en', {
+    monthsShort : [
+        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+    ]
+});
+
+moment.lang('en', {
+    monthsShort : function (momentToFormat: Moment, format: string) {
+        if (/^MMMM/.test(format)) {
+            return this.nominative[momentToFormat.month()];
+        } else {
+            return this.subjective[momentToFormat.month()];
+        }
+    }
+});
+
+moment.lang('en', {
+    weekdays : [
+        "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
+    ]
+});
+
+moment.lang('en', {
+    weekdays : function (momentToFormat: Moment) {
+        return this.weekdays[momentToFormat.day()];
+    }
+});
+
+moment.lang('en', {
+    weekdaysShort : ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
+});
+
+moment.lang('en', {
+    weekdaysShort : function (momentToFormat: Moment) {
+        return this.weekdaysShort[momentToFormat.day()];
+    }
+});
+
+moment.lang('en', {
+    weekdaysMin : ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"]
+});
+
+moment.lang('en', {
+    weekdaysMin : function (momentToFormat: Moment) {
+        return this.weekdaysMin[momentToFormat.day()];
+    }
+});
+
+moment.lang('en', {
+    longDateFormat : {
+        LT: "h:mm A",
+        L: "MM/DD/YYYY",
+        l: "M/D/YYYY",
+        LL: "MMMM Do YYYY",
+        ll: "MMM D YYYY",
+        LLL: "MMMM Do YYYY LT",
+        lll: "MMM D YYYY LT",
+        LLLL: "dddd, MMMM Do YYYY LT",
+        llll: "ddd, MMM D YYYY LT"
+    }
+});
+
+moment.lang('en', {
+    longDateFormat : {
+        LT: "h:mm A",
+        L: "MM/DD/YYYY",
+        LL: "MMMM Do YYYY",
+        LLL: "MMMM Do YYYY LT",
+        LLLL: "dddd, MMMM Do YYYY LT"
+    }
+});
+
+moment.lang('en', {
+    relativeTime : {
+        future: "in %s",
+        past:   "%s ago",
+        s:  "seconds",
+        m:  "a minute",
+        mm: "%d minutes",
+        h:  "an hour",
+        hh: "%d hours",
+        d:  "a day",
+        dd: "%d days",
+        M:  "a month",
+        MM: "%d months",
+        y:  "a year",
+        yy: "%d years"
+    }
+});
+
+moment.lang('en', {
+    meridiem : function (hour, minute, isLowercase) {
+        if (hour < 9) {
+            return "早上";
+        } else if (hour < 11 && minute < 30) {
+            return "上午";
+        } else if (hour < 13 && minute < 30) {
+            return "中午";
+        } else if (hour < 18) {
+            return "下午";
+        } else {
+            return "晚上";
+        }
+    }
+});
+
+moment.lang('en', {
+    calendar : {
+        lastDay : '[Yesterday at] LT',
+        sameDay : '[Today at] LT',
+        nextDay : function () {
+          return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
+        },
+        lastWeek : '[last] dddd [at] LT',
+        nextWeek : 'dddd [at] LT',
+        sameElse : 'L'
+    }
+});
+
+moment.lang('en', {
+    ordinal : function (number) {
+        var b = number % 10;
+        var output = (~~ (number % 100 / 10) === 1) ? 'th' :
+            (b === 1) ? 'st' :
+            (b === 2) ? 'nd' :
+            (b === 3) ? 'rd' : 'th';
+        return number + output;
+    }
+});
+
+console.log(moment.version);
diff --git a/moment/moment.d.ts b/moment/moment.d.ts
index 4eeb15685..cfc19100b 100644
--- a/moment/moment.d.ts
+++ b/moment/moment.d.ts
@@ -326,6 +326,6 @@ interface MomentStatic {
 
 declare var moment: MomentStatic;
 
-declare module "moment" {
-    export = MomentStatic;
+declare module 'moment' {
+    export = moment;
 }

From c69db70217e535f1b27f40971729402d39e09351 Mon Sep 17 00:00:00 2001
From: troy_paypac <troy@paypac.com.au>
Date: Wed, 26 Mar 2014 14:58:30 +0800
Subject: [PATCH 203/309] internal module defns for node and express

---
 express/express.d.ts |  99 +++++++++++++++---------------
 node/node.d.ts       | 140 +++++++++++++++++++++----------------------
 2 files changed, 118 insertions(+), 121 deletions(-)

diff --git a/express/express.d.ts b/express/express.d.ts
index 243aa41d4..e18b7bc7d 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -12,14 +12,11 @@
 
 /// <reference path="../node/node.d.ts" />
 
-declare module "express" {
-    import http = require('http');
+declare module "express" { export = ExpressStatic; }
+declare function ExpressStatic(): ExpressStatic.Express
+declare module ExpressStatic {
 
-    // Merged declaration, e is both a callable function and a namespace
-    function e(): e.Express;
-
-    module e {
-        interface IRoute {
+        export interface IRoute {
             path: string;
 
             method: string;
@@ -35,7 +32,7 @@ declare module "express" {
             match(path: string): boolean;
         }
 
-        class Route implements IRoute {
+        export class Route implements IRoute {
             path: string;
 
             method: string;
@@ -62,7 +59,7 @@ declare module "express" {
             new (method: string, path: string, callbacks: Function[], options: any): Route;
         }
 
-        interface IRouter<T> {
+        export interface IRouter<T> {
             /**
              * Map the given param placeholder `name`(s) to the given callback(s).
              *
@@ -107,6 +104,8 @@ declare module "express" {
 
             all(path: string, ...callbacks: Function[]): void;
 
+            get(name: string): string;
+
             get(name: string, ...handlers: RequestFunction[]): T;
 
             get(name: RegExp, ...handlers: RequestFunction[]): T;
@@ -141,6 +140,8 @@ declare module "express" {
 
           all(path: string, ...callbacks: Function[]): void;
 
+          get(name: string): string;
+
           get(name: string, ...handlers: RequestFunction[]): Router;
 
           get(name: RegExp, ...handlers: RequestFunction[]): Router;
@@ -162,11 +163,11 @@ declare module "express" {
           patch(name: RegExp, ...handlers: RequestFunction[]): Router;
         }
 
-        interface Handler {
+        export interface Handler {
             (req: Request, res: Response, next?: Function): void;
         }
 
-        interface CookieOptions {
+        export interface CookieOptions {
             maxAge?: number;
             signed?: boolean;
             expires?: Date;
@@ -176,9 +177,9 @@ declare module "express" {
             secure?: boolean;
         }
 
-        interface Errback { (err: Error): void; }
+        export interface Errback { (err: Error): void; }
 
-        interface Session {
+        export interface Session {
             /**
              * Update reset `.cookie.maxAge` to prevent
              * the cookie from expiring when the
@@ -229,7 +230,7 @@ declare module "express" {
             count: number;
         }
 
-        interface Request {
+        export interface Request {
 
             session: Session;
 
@@ -533,19 +534,19 @@ declare module "express" {
             url: string;
         }
 
-        interface MediaType {
+        export interface MediaType {
             value: string;
             quality: number;
             type: string;
             subtype:  string;
         }
 
-        interface Send {
+        export interface Send {
             (status: number, body?: any): Response;
             (body: any): Response;
         }
 
-        interface Response extends http.ServerResponse {
+        export interface Response extends NodeHttp.ServerResponse {
             /**
              * Set status `code`.
              *
@@ -889,11 +890,11 @@ declare module "express" {
             charset: string;
         }
 
-        interface RequestFunction {
+        export interface RequestFunction {
             (req: Request, res: Response, next: Function): any;
         }
 
-        interface Application extends IRouter<Application> {
+        export interface Application extends IRouter<Application> {
             /**
              * Initialize the server.
              *
@@ -1145,7 +1146,7 @@ declare module "express" {
             routes: any;
         }
 
-        interface Express extends Application {
+        export interface Express extends Application {
             /**
              * Framework version.
              */
@@ -1199,7 +1200,7 @@ declare module "express" {
          *
          * @param options
          */
-        function bodyParser(options?: any): Handler;
+        export function bodyParser(options?: any): Handler;
 
         /**
          * Error handler:
@@ -1222,7 +1223,7 @@ declare module "express" {
          *
          *   When accepted connect will output a nice html stack trace.
          */
-        function errorHandler(opts?: any): Handler;
+        export function errorHandler(opts?: any): Handler;
 
         /**
          * Method Override:
@@ -1235,7 +1236,7 @@ declare module "express" {
          *
          * @param key
          */
-        function methodOverride(key?: string): Handler;
+        export function methodOverride(key?: string): Handler;
 
         /**
          * Cookie parser:
@@ -1256,7 +1257,7 @@ declare module "express" {
          *
          * @param secret
          */
-        function cookieParser(secret?: string): Handler;
+        export function cookieParser(secret?: string): Handler;
 
         /**
          * Session:
@@ -1393,7 +1394,7 @@ declare module "express" {
          *
          * @param options
          */
-        function session(options?: any): Handler;
+        export function session(options?: any): Handler;
 
         /**
          * Hash the given `sess` object omitting changes
@@ -1401,7 +1402,7 @@ declare module "express" {
          *
          * @param sess
          */
-        function hash(sess: string): string;
+        export function hash(sess: string): string;
 
         /**
          * Static:
@@ -1427,7 +1428,7 @@ declare module "express" {
          * @param root
          * @param options
          */
-        function static(root: string, options?: any): Handler;
+        export function static(root: string, options?: any): Handler;
 
         /**
          * Basic Auth:
@@ -1492,7 +1493,7 @@ declare module "express" {
          *
          * @param options
          */
-        function compress(options?: any): Handler;
+        export function compress(options?: any): Handler;
 
         /**
          * Cookie Session:
@@ -1519,7 +1520,7 @@ declare module "express" {
          *
          * @param options
          */
-        function cookieSession(options?: any): Handler;
+        export function cookieSession(options?: any): Handler;
 
         /**
          * Anti CSRF:
@@ -1560,7 +1561,7 @@ declare module "express" {
          * @param root
          * @param options
          */
-        function directory(root: string, options?: any): Handler;
+        export function directory(root: string, options?: any): Handler;
 
         /**
          * Favicon:
@@ -1609,7 +1610,7 @@ declare module "express" {
          *
          * @param options
          */
-        function json(options?: any): Handler;
+        export function json(options?: any): Handler;
 
         /**
          * Limit:
@@ -1623,9 +1624,9 @@ declare module "express" {
          *       .use(connect.limit('5.5mb'))
          *       .use(handleImageUpload)
          */
-        function limit(bytes: number): Handler;
+        export function limit(bytes: number): Handler;
 
-        function limit(bytes: string): Handler;
+        export function limit(bytes: string): Handler;
 
         /**
          * Logger:
@@ -1686,18 +1687,18 @@ declare module "express" {
          *
          *       connect.logger.format('name', 'string or function')
          */
-        function logger(options: string): Handler;
+        export function logger(options: string): Handler;
 
-        function logger(options: Function): Handler;
+        export function logger(options: Function): Handler;
 
-        function logger(options?: any): Handler;
+        export function logger(options?: any): Handler;
 
         /**
          * Compile `fmt` into a function.
          *
          * @param fmt
          */
-        function compile(fmt: string): Handler;
+        export function compile(fmt: string): Handler;
 
         /**
          * Define a token function with the given `name`,
@@ -1706,14 +1707,14 @@ declare module "express" {
          * @param name
          * @param fn
          */
-        function token(name: string, fn: Function): any;
+        export function token(name: string, fn: Function): any;
 
         /**
          * Define a `fmt` with the given `name`.
          */
-        function format(name: string, str: string): any;
+        export function format(name: string, str: string): any;
 
-        function format(name: string, str: Function): any;
+        export function format(name: string, str: Function): any;
 
         /**
          * Query:
@@ -1731,7 +1732,7 @@ declare module "express" {
          *
          *  The `options` passed are provided to qs.parse function.
          */
-        function query(options: any): Handler;
+        export function query(options: any): Handler;
 
         /**
          * Reponse time:
@@ -1739,7 +1740,7 @@ declare module "express" {
          * Adds the `X-Response-Time` header displaying the response
          * duration in milliseconds.
          */
-        function responseTime(): Handler;
+        export function responseTime(): Handler;
 
         /**
          * Static cache:
@@ -1771,7 +1772,7 @@ declare module "express" {
          *   - `maxObjects`  max cache objects [128]
          *   - `maxLength`  max cache object length 256kb
          */
-        function staticCache(options: any): Handler;
+        export function staticCache(options: any): Handler;
 
         /**
          * Timeout:
@@ -1784,7 +1785,7 @@ declare module "express" {
          * the response behaviour. This error has the `.timeout` property as
          * well as `.status == 408`.
          */
-        function timeout(ms: number): Handler;
+        export function timeout(ms: number): Handler;
 
         /**
          * Vhost:
@@ -1802,14 +1803,10 @@ declare module "express" {
          * @param hostname
          * @param server
          */
-        function vhost(hostname: string, server: any): Handler;
+        export function vhost(hostname: string, server: any): Handler;
 
-        function urlencoded(): any;
+        export function urlencoded(): any;
 
-        function multipart(): any;
-
-    }
-
-    export = e;
+        export function multipart(): any;
 }
 
diff --git a/node/node.d.ts b/node/node.d.ts
index 4fafb883e..ddfb5b94a 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -224,14 +224,16 @@ interface NodeTimer {
 *                   MODULES                     *
 *                                               *
 ************************************************/
-declare module "querystring" {
+declare module "querystring" { export = NodeQueryString; }
+declare module NodeQueryString {
     export function stringify(obj: any, sep?: string, eq?: string): string;
     export function parse(str: string, sep?: string, eq?: string, options?: { maxKeys?: number; }): any;
     export function escape(): any;
     export function unescape(): any;
 }
 
-declare module "events" {
+declare module "events" { export = NodeEvents; }
+declare module NodeEvents {
     export class EventEmitter implements NodeEventEmitter {
         static listenerCount(emitter: EventEmitter, event: string): number;
 
@@ -246,10 +248,8 @@ declare module "events" {
    }
 }
 
-declare module "http" {
-    import events = require("events");
-    import net = require("net");
-    import stream = require("stream");
+declare module "http" { export = NodeHttp; }
+declare module NodeHttp {
 
     export interface Server extends NodeEventEmitter {
         listen(port: number, hostname?: string, backlog?: number, callback?: Function): void;
@@ -267,7 +267,7 @@ declare module "http" {
         setEncoding(encoding?: string): void;
         pause(): void;
         resume(): void;
-        connection: net.Socket;
+        connection: NodeNet.Socket;
     }
     export interface ServerResponse extends NodeEventEmitter, WritableStream {
         // Extended base methods
@@ -335,9 +335,8 @@ declare module "http" {
     export var globalAgent: Agent;
 }
 
-declare module "cluster" {
-    import child  = require("child_process");
-    import events = require("events");
+declare module "cluster" { export = NodeCluster; }
+declare module NodeCluster {
 
     export interface ClusterSettings {
         exec?: string;
@@ -345,9 +344,9 @@ declare module "cluster" {
         silent?: boolean;
     }
 
-    export class Worker extends events.EventEmitter {
+    export class Worker extends NodeEvents.EventEmitter {
         id: string;
-        process: child.ChildProcess;
+        process: NodeChildProcess.ChildProcess;
         suicide: boolean;
         send(message: any, sendHandle?: any): void;
         kill(signal?: string): void;
@@ -375,8 +374,9 @@ declare module "cluster" {
     export function emit(event: string, ...args: any[]): boolean;
 }
 
-declare module "zlib" {
-    import stream = require("stream");
+declare module "zlib" { export = NodeZlib; }
+declare module NodeZlib {
+
     export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; }
 
     export interface Gzip extends ReadWriteStream { }
@@ -437,7 +437,8 @@ declare module "zlib" {
     export var Z_NULL: number;
 }
 
-declare module "os" {
+declare module "os" { export = NodeOs; }
+declare module NodeOs {
     export function tmpDir(): string;
     export function hostname(): string;
     export function type(): string;
@@ -453,10 +454,8 @@ declare module "os" {
     export var EOL: string;
 }
 
-declare module "https" {
-    import tls = require("tls");
-    import events = require("events");
-    import http = require("http");
+declare module "https" { export = NodeHttps; }
+declare module NodeHttps {
 
     export interface ServerOptions {
         pfx?: any;
@@ -499,14 +498,15 @@ declare module "https" {
     export var Agent: {
         new (options?: RequestOptions): Agent;
     };
-    export interface Server extends tls.Server { }
+    export interface Server extends NodeTls.Server { }
     export function createServer(options: ServerOptions, requestListener?: Function): Server;
-    export function request(options: RequestOptions, callback?: (res: NodeEventEmitter) =>void ): http.ClientRequest;
-    export function get(options: RequestOptions, callback?: (res: NodeEventEmitter) =>void ): http.ClientRequest;
+    export function request(options: RequestOptions, callback?: (res: NodeEventEmitter) => void): NodeHttp.ClientRequest;
+    export function get(options: RequestOptions, callback?: (res: NodeEventEmitter) => void): NodeHttp.ClientRequest;
     export var globalAgent: Agent;
 }
 
-declare module "punycode" {
+declare module "punycode" { export = NodePunyCode; }
+declare module NodePunyCode {
     export function decode(string: string): string;
     export function encode(string: string): string;
     export function toUnicode(domain: string): string;
@@ -519,9 +519,8 @@ declare module "punycode" {
     export var version: any;
 }
 
-declare module "repl" {
-    import stream = require("stream");
-    import events = require("events");
+declare module "repl" { export = NodeRepl; }
+declare module NodeRepl {
 
     export interface ReplOptions {
         prompt?: string;
@@ -537,9 +536,8 @@ declare module "repl" {
     export function start(options: ReplOptions): NodeEventEmitter;
 }
 
-declare module "readline" {
-    import events = require("events");
-    import stream = require("stream");
+declare module "readline" { export = NodeReadLine; }
+declare module NodeReadLine {
 
     export interface ReadLine extends NodeEventEmitter {
         setPrompt(prompt: string, length: number): void;
@@ -559,7 +557,8 @@ declare module "readline" {
     export function createInterface(options: ReadLineOptions): ReadLine;
 }
 
-declare module "vm" {
+declare module "vm" { export = NodeVm; }
+declare module NodeVm {
     export interface Context { }
     export interface Script {
         runInThisContext(): void;
@@ -572,9 +571,8 @@ declare module "vm" {
     export function createScript(code: string, filename?: string): Script;
 }
 
-declare module "child_process" {
-    import events = require("events");
-    import stream = require("stream");
+declare module "child_process" { export = NodeChildProcess; }
+declare module NodeChildProcess {
 
     export interface ChildProcess extends NodeEventEmitter {
         stdin: WritableStream;
@@ -621,7 +619,8 @@ declare module "child_process" {
     }): ChildProcess;
 }
 
-declare module "url" {
+declare module "url" { export = NodeUrl; }
+declare module NodeUrl {
     export interface Url {
         href: string;
         protocol: string;
@@ -651,7 +650,8 @@ declare module "url" {
     export function resolve(from: string, to: string): string;
 }
 
-declare module "dns" {
+declare module "dns" { export = NodeDns; }
+declare module NodeDns {
     export function lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string;
     export function lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string;
     export function resolve(domain: string, rrtype: string, callback: (err: Error, addresses: string[]) =>void ): string[];
@@ -666,8 +666,8 @@ declare module "dns" {
     export function reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[];
 }
 
-declare module "net" {
-    import stream = require("stream");
+declare module "net" { export = NodeNet; }
+declare module NodeNet {
 
     export interface Socket extends ReadWriteStream {
         // Extended base methods
@@ -728,8 +728,8 @@ declare module "net" {
     export function isIPv6(input: string): boolean;
 }
 
-declare module "dgram" {
-    import events = require("events");
+declare module "dgram" { export = NodeDgram; }
+declare module NodeDgram {
 
     export function createSocket(type: string, callback?: Function): Socket;
 
@@ -746,8 +746,8 @@ declare module "dgram" {
     }
 }
 
-declare module "fs" {
-    import stream = require("stream");
+declare module "fs" { export = NodeFs; }
+declare module NodeFs {
 
     interface Stats {
         isFile(): boolean;
@@ -893,7 +893,8 @@ declare module "fs" {
     }): WriteStream;
 }
 
-declare module "path" {
+declare module "path" { export = NodePath; }
+declare module NodePath {
     export function normalize(p: string): string;
     export function join(...paths: any[]): string;
     export function resolve(...pathSegments: any[]): string;
@@ -904,7 +905,8 @@ declare module "path" {
     export var sep: string;
 }
 
-declare module "string_decoder" {
+declare module "string_decoder" { export = NodeStringDecoder; }
+declare module NodeStringDecoder {
     export interface NodeStringDecoder {
         write(buffer: NodeBuffer): string;
         detectIncompleteChar(buffer: NodeBuffer): number;
@@ -914,10 +916,8 @@ declare module "string_decoder" {
     };
 }
 
-declare module "tls" {
-    import crypto = require("crypto");
-    import net = require("net");
-    import stream = require("stream");
+declare module "tls" { export = NodeTls; }
+declare module NodeTls {
 
     var CLIENT_RENEG_LIMIT: number;
     var CLIENT_RENEG_WINDOW: number;
@@ -940,7 +940,7 @@ declare module "tls" {
     export interface ConnectionOptions {
         host?: string;
         port?: number;
-        socket?: net.Socket;
+        socket?: NodeNet.Socket;
         pfx?: any;   //string | Buffer
         key?: any;   //string | Buffer
         passphrase?: string;
@@ -951,7 +951,7 @@ declare module "tls" {
         servername?: string;
     }
 
-    export interface Server extends net.Server {
+    export interface Server extends NodeNet.Server {
         // Extended base methods
         listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
         listen(path: string, listeningListener?: Function): void;
@@ -995,10 +995,11 @@ declare module "tls" {
     export function connect(options: TlsOptions, secureConnectionListener?: () =>void ): ClearTextStream;
     export function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
     export function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
-    export function createSecurePair(credentials?: crypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
+    export function createSecurePair(credentials?: NodeCrypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
 }
 
-declare module "crypto" {
+declare module "crypto" { export = NodeCrypto; }
+declare module NodeCrypto {
     export interface CredentialDetails {
         pfx: string;
         key: string;
@@ -1064,8 +1065,8 @@ declare module "crypto" {
     export function pseudoRandomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
 }
 
-declare module "stream" {
-    import events = require("events");
+declare module "stream" { export = NodeStream; }
+declare module NodeStream {
 
     export interface ReadableOptions {
         highWaterMark?: number;
@@ -1073,7 +1074,7 @@ declare module "stream" {
         objectMode?: boolean;
     }
 
-    export class Readable extends events.EventEmitter implements ReadableStream {
+    export class Readable extends NodeEvents.EventEmitter implements ReadableStream {
         readable: boolean;
         constructor(opts?: ReadableOptions);
         _read(size: number): void;
@@ -1094,7 +1095,7 @@ declare module "stream" {
         decodeStrings?: boolean;
     }
 
-    export class Writable extends events.EventEmitter implements WritableStream {
+    export class Writable extends NodeEvents.EventEmitter implements WritableStream {
         writable: boolean;
         constructor(opts?: WritableOptions);
         _write(data: NodeBuffer, encoding: string, callback: Function): void;
@@ -1130,7 +1131,7 @@ declare module "stream" {
     export interface TransformOptions extends ReadableOptions, WritableOptions {}
 
     // Note: Transform lacks the _read and _write methods of Readable/Writable.
-    export class Transform extends events.EventEmitter implements ReadWriteStream {
+    export class Transform extends NodeEvents.EventEmitter implements ReadWriteStream {
         readable: boolean;
         writable: boolean;
         constructor(opts?: TransformOptions);
@@ -1159,7 +1160,8 @@ declare module "stream" {
     export class PassThrough extends Transform {}
 }
 
-declare module "util" {
+declare module "util" { export = NodeUtil; }
+declare module NodeUtil {
     export interface InspectOptions {
         showHidden?: boolean;
         depth?: number;
@@ -1182,9 +1184,10 @@ declare module "util" {
     export function inherits(constructor: any, superConstructor: any): void;
 }
 
-declare module "assert" {
-    function internal (value: any, message?: string): void;
-    module internal {
+declare module "assert" { export = NodeAssert; }
+declare function NodeAssert(value: any, message?: string): void;
+declare module NodeAssert {
+
         export class AssertionError implements Error {
             name: string;
             message: string;
@@ -1220,29 +1223,26 @@ declare module "assert" {
         }
 
         export function ifError(value: any): void;
-    }
-
-    export = internal;
 }
 
-declare module "tty" {
-    import net = require("net");
+declare module "tty" { export = NodeTty; }
+declare module NodeTty {
 
     export function isatty(fd: number): boolean;
-    export interface ReadStream extends net.Socket {
+    export interface ReadStream extends NodeNet.Socket {
         isRaw: boolean;
         setRawMode(mode: boolean): void;
     }
-    export interface WriteStream extends net.Socket {
+    export interface WriteStream extends NodeNet.Socket {
         columns: number;
         rows: number;
     }
 }
 
-declare module "domain" {
-    import events = require("events");
+declare module "domain" { export = NodeDomain; }
+declare module NodeDomain {
 
-    export class Domain extends events.EventEmitter {
+    export class Domain extends NodeEvents.EventEmitter {
         run(fn: Function): void;
         add(emitter: NodeEventEmitter): void;
         remove(emitter: NodeEventEmitter): void;

From 1fd18add08705c7d0a6196dc372d52b465176332 Mon Sep 17 00:00:00 2001
From: troy_paypac <troy@paypac.com.au>
Date: Wed, 26 Mar 2014 14:58:30 +0800
Subject: [PATCH 204/309] internal module defns for node and express

---
 express/express.d.ts |  99 +++++++++++++++---------------
 node/node.d.ts       | 140 +++++++++++++++++++++----------------------
 2 files changed, 118 insertions(+), 121 deletions(-)

diff --git a/express/express.d.ts b/express/express.d.ts
index 243aa41d4..e18b7bc7d 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -12,14 +12,11 @@
 
 /// <reference path="../node/node.d.ts" />
 
-declare module "express" {
-    import http = require('http');
+declare module "express" { export = ExpressStatic; }
+declare function ExpressStatic(): ExpressStatic.Express
+declare module ExpressStatic {
 
-    // Merged declaration, e is both a callable function and a namespace
-    function e(): e.Express;
-
-    module e {
-        interface IRoute {
+        export interface IRoute {
             path: string;
 
             method: string;
@@ -35,7 +32,7 @@ declare module "express" {
             match(path: string): boolean;
         }
 
-        class Route implements IRoute {
+        export class Route implements IRoute {
             path: string;
 
             method: string;
@@ -62,7 +59,7 @@ declare module "express" {
             new (method: string, path: string, callbacks: Function[], options: any): Route;
         }
 
-        interface IRouter<T> {
+        export interface IRouter<T> {
             /**
              * Map the given param placeholder `name`(s) to the given callback(s).
              *
@@ -107,6 +104,8 @@ declare module "express" {
 
             all(path: string, ...callbacks: Function[]): void;
 
+            get(name: string): string;
+
             get(name: string, ...handlers: RequestFunction[]): T;
 
             get(name: RegExp, ...handlers: RequestFunction[]): T;
@@ -141,6 +140,8 @@ declare module "express" {
 
           all(path: string, ...callbacks: Function[]): void;
 
+          get(name: string): string;
+
           get(name: string, ...handlers: RequestFunction[]): Router;
 
           get(name: RegExp, ...handlers: RequestFunction[]): Router;
@@ -162,11 +163,11 @@ declare module "express" {
           patch(name: RegExp, ...handlers: RequestFunction[]): Router;
         }
 
-        interface Handler {
+        export interface Handler {
             (req: Request, res: Response, next?: Function): void;
         }
 
-        interface CookieOptions {
+        export interface CookieOptions {
             maxAge?: number;
             signed?: boolean;
             expires?: Date;
@@ -176,9 +177,9 @@ declare module "express" {
             secure?: boolean;
         }
 
-        interface Errback { (err: Error): void; }
+        export interface Errback { (err: Error): void; }
 
-        interface Session {
+        export interface Session {
             /**
              * Update reset `.cookie.maxAge` to prevent
              * the cookie from expiring when the
@@ -229,7 +230,7 @@ declare module "express" {
             count: number;
         }
 
-        interface Request {
+        export interface Request {
 
             session: Session;
 
@@ -533,19 +534,19 @@ declare module "express" {
             url: string;
         }
 
-        interface MediaType {
+        export interface MediaType {
             value: string;
             quality: number;
             type: string;
             subtype:  string;
         }
 
-        interface Send {
+        export interface Send {
             (status: number, body?: any): Response;
             (body: any): Response;
         }
 
-        interface Response extends http.ServerResponse {
+        export interface Response extends NodeHttp.ServerResponse {
             /**
              * Set status `code`.
              *
@@ -889,11 +890,11 @@ declare module "express" {
             charset: string;
         }
 
-        interface RequestFunction {
+        export interface RequestFunction {
             (req: Request, res: Response, next: Function): any;
         }
 
-        interface Application extends IRouter<Application> {
+        export interface Application extends IRouter<Application> {
             /**
              * Initialize the server.
              *
@@ -1145,7 +1146,7 @@ declare module "express" {
             routes: any;
         }
 
-        interface Express extends Application {
+        export interface Express extends Application {
             /**
              * Framework version.
              */
@@ -1199,7 +1200,7 @@ declare module "express" {
          *
          * @param options
          */
-        function bodyParser(options?: any): Handler;
+        export function bodyParser(options?: any): Handler;
 
         /**
          * Error handler:
@@ -1222,7 +1223,7 @@ declare module "express" {
          *
          *   When accepted connect will output a nice html stack trace.
          */
-        function errorHandler(opts?: any): Handler;
+        export function errorHandler(opts?: any): Handler;
 
         /**
          * Method Override:
@@ -1235,7 +1236,7 @@ declare module "express" {
          *
          * @param key
          */
-        function methodOverride(key?: string): Handler;
+        export function methodOverride(key?: string): Handler;
 
         /**
          * Cookie parser:
@@ -1256,7 +1257,7 @@ declare module "express" {
          *
          * @param secret
          */
-        function cookieParser(secret?: string): Handler;
+        export function cookieParser(secret?: string): Handler;
 
         /**
          * Session:
@@ -1393,7 +1394,7 @@ declare module "express" {
          *
          * @param options
          */
-        function session(options?: any): Handler;
+        export function session(options?: any): Handler;
 
         /**
          * Hash the given `sess` object omitting changes
@@ -1401,7 +1402,7 @@ declare module "express" {
          *
          * @param sess
          */
-        function hash(sess: string): string;
+        export function hash(sess: string): string;
 
         /**
          * Static:
@@ -1427,7 +1428,7 @@ declare module "express" {
          * @param root
          * @param options
          */
-        function static(root: string, options?: any): Handler;
+        export function static(root: string, options?: any): Handler;
 
         /**
          * Basic Auth:
@@ -1492,7 +1493,7 @@ declare module "express" {
          *
          * @param options
          */
-        function compress(options?: any): Handler;
+        export function compress(options?: any): Handler;
 
         /**
          * Cookie Session:
@@ -1519,7 +1520,7 @@ declare module "express" {
          *
          * @param options
          */
-        function cookieSession(options?: any): Handler;
+        export function cookieSession(options?: any): Handler;
 
         /**
          * Anti CSRF:
@@ -1560,7 +1561,7 @@ declare module "express" {
          * @param root
          * @param options
          */
-        function directory(root: string, options?: any): Handler;
+        export function directory(root: string, options?: any): Handler;
 
         /**
          * Favicon:
@@ -1609,7 +1610,7 @@ declare module "express" {
          *
          * @param options
          */
-        function json(options?: any): Handler;
+        export function json(options?: any): Handler;
 
         /**
          * Limit:
@@ -1623,9 +1624,9 @@ declare module "express" {
          *       .use(connect.limit('5.5mb'))
          *       .use(handleImageUpload)
          */
-        function limit(bytes: number): Handler;
+        export function limit(bytes: number): Handler;
 
-        function limit(bytes: string): Handler;
+        export function limit(bytes: string): Handler;
 
         /**
          * Logger:
@@ -1686,18 +1687,18 @@ declare module "express" {
          *
          *       connect.logger.format('name', 'string or function')
          */
-        function logger(options: string): Handler;
+        export function logger(options: string): Handler;
 
-        function logger(options: Function): Handler;
+        export function logger(options: Function): Handler;
 
-        function logger(options?: any): Handler;
+        export function logger(options?: any): Handler;
 
         /**
          * Compile `fmt` into a function.
          *
          * @param fmt
          */
-        function compile(fmt: string): Handler;
+        export function compile(fmt: string): Handler;
 
         /**
          * Define a token function with the given `name`,
@@ -1706,14 +1707,14 @@ declare module "express" {
          * @param name
          * @param fn
          */
-        function token(name: string, fn: Function): any;
+        export function token(name: string, fn: Function): any;
 
         /**
          * Define a `fmt` with the given `name`.
          */
-        function format(name: string, str: string): any;
+        export function format(name: string, str: string): any;
 
-        function format(name: string, str: Function): any;
+        export function format(name: string, str: Function): any;
 
         /**
          * Query:
@@ -1731,7 +1732,7 @@ declare module "express" {
          *
          *  The `options` passed are provided to qs.parse function.
          */
-        function query(options: any): Handler;
+        export function query(options: any): Handler;
 
         /**
          * Reponse time:
@@ -1739,7 +1740,7 @@ declare module "express" {
          * Adds the `X-Response-Time` header displaying the response
          * duration in milliseconds.
          */
-        function responseTime(): Handler;
+        export function responseTime(): Handler;
 
         /**
          * Static cache:
@@ -1771,7 +1772,7 @@ declare module "express" {
          *   - `maxObjects`  max cache objects [128]
          *   - `maxLength`  max cache object length 256kb
          */
-        function staticCache(options: any): Handler;
+        export function staticCache(options: any): Handler;
 
         /**
          * Timeout:
@@ -1784,7 +1785,7 @@ declare module "express" {
          * the response behaviour. This error has the `.timeout` property as
          * well as `.status == 408`.
          */
-        function timeout(ms: number): Handler;
+        export function timeout(ms: number): Handler;
 
         /**
          * Vhost:
@@ -1802,14 +1803,10 @@ declare module "express" {
          * @param hostname
          * @param server
          */
-        function vhost(hostname: string, server: any): Handler;
+        export function vhost(hostname: string, server: any): Handler;
 
-        function urlencoded(): any;
+        export function urlencoded(): any;
 
-        function multipart(): any;
-
-    }
-
-    export = e;
+        export function multipart(): any;
 }
 
diff --git a/node/node.d.ts b/node/node.d.ts
index 4fafb883e..ddfb5b94a 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -224,14 +224,16 @@ interface NodeTimer {
 *                   MODULES                     *
 *                                               *
 ************************************************/
-declare module "querystring" {
+declare module "querystring" { export = NodeQueryString; }
+declare module NodeQueryString {
     export function stringify(obj: any, sep?: string, eq?: string): string;
     export function parse(str: string, sep?: string, eq?: string, options?: { maxKeys?: number; }): any;
     export function escape(): any;
     export function unescape(): any;
 }
 
-declare module "events" {
+declare module "events" { export = NodeEvents; }
+declare module NodeEvents {
     export class EventEmitter implements NodeEventEmitter {
         static listenerCount(emitter: EventEmitter, event: string): number;
 
@@ -246,10 +248,8 @@ declare module "events" {
    }
 }
 
-declare module "http" {
-    import events = require("events");
-    import net = require("net");
-    import stream = require("stream");
+declare module "http" { export = NodeHttp; }
+declare module NodeHttp {
 
     export interface Server extends NodeEventEmitter {
         listen(port: number, hostname?: string, backlog?: number, callback?: Function): void;
@@ -267,7 +267,7 @@ declare module "http" {
         setEncoding(encoding?: string): void;
         pause(): void;
         resume(): void;
-        connection: net.Socket;
+        connection: NodeNet.Socket;
     }
     export interface ServerResponse extends NodeEventEmitter, WritableStream {
         // Extended base methods
@@ -335,9 +335,8 @@ declare module "http" {
     export var globalAgent: Agent;
 }
 
-declare module "cluster" {
-    import child  = require("child_process");
-    import events = require("events");
+declare module "cluster" { export = NodeCluster; }
+declare module NodeCluster {
 
     export interface ClusterSettings {
         exec?: string;
@@ -345,9 +344,9 @@ declare module "cluster" {
         silent?: boolean;
     }
 
-    export class Worker extends events.EventEmitter {
+    export class Worker extends NodeEvents.EventEmitter {
         id: string;
-        process: child.ChildProcess;
+        process: NodeChildProcess.ChildProcess;
         suicide: boolean;
         send(message: any, sendHandle?: any): void;
         kill(signal?: string): void;
@@ -375,8 +374,9 @@ declare module "cluster" {
     export function emit(event: string, ...args: any[]): boolean;
 }
 
-declare module "zlib" {
-    import stream = require("stream");
+declare module "zlib" { export = NodeZlib; }
+declare module NodeZlib {
+
     export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; }
 
     export interface Gzip extends ReadWriteStream { }
@@ -437,7 +437,8 @@ declare module "zlib" {
     export var Z_NULL: number;
 }
 
-declare module "os" {
+declare module "os" { export = NodeOs; }
+declare module NodeOs {
     export function tmpDir(): string;
     export function hostname(): string;
     export function type(): string;
@@ -453,10 +454,8 @@ declare module "os" {
     export var EOL: string;
 }
 
-declare module "https" {
-    import tls = require("tls");
-    import events = require("events");
-    import http = require("http");
+declare module "https" { export = NodeHttps; }
+declare module NodeHttps {
 
     export interface ServerOptions {
         pfx?: any;
@@ -499,14 +498,15 @@ declare module "https" {
     export var Agent: {
         new (options?: RequestOptions): Agent;
     };
-    export interface Server extends tls.Server { }
+    export interface Server extends NodeTls.Server { }
     export function createServer(options: ServerOptions, requestListener?: Function): Server;
-    export function request(options: RequestOptions, callback?: (res: NodeEventEmitter) =>void ): http.ClientRequest;
-    export function get(options: RequestOptions, callback?: (res: NodeEventEmitter) =>void ): http.ClientRequest;
+    export function request(options: RequestOptions, callback?: (res: NodeEventEmitter) => void): NodeHttp.ClientRequest;
+    export function get(options: RequestOptions, callback?: (res: NodeEventEmitter) => void): NodeHttp.ClientRequest;
     export var globalAgent: Agent;
 }
 
-declare module "punycode" {
+declare module "punycode" { export = NodePunyCode; }
+declare module NodePunyCode {
     export function decode(string: string): string;
     export function encode(string: string): string;
     export function toUnicode(domain: string): string;
@@ -519,9 +519,8 @@ declare module "punycode" {
     export var version: any;
 }
 
-declare module "repl" {
-    import stream = require("stream");
-    import events = require("events");
+declare module "repl" { export = NodeRepl; }
+declare module NodeRepl {
 
     export interface ReplOptions {
         prompt?: string;
@@ -537,9 +536,8 @@ declare module "repl" {
     export function start(options: ReplOptions): NodeEventEmitter;
 }
 
-declare module "readline" {
-    import events = require("events");
-    import stream = require("stream");
+declare module "readline" { export = NodeReadLine; }
+declare module NodeReadLine {
 
     export interface ReadLine extends NodeEventEmitter {
         setPrompt(prompt: string, length: number): void;
@@ -559,7 +557,8 @@ declare module "readline" {
     export function createInterface(options: ReadLineOptions): ReadLine;
 }
 
-declare module "vm" {
+declare module "vm" { export = NodeVm; }
+declare module NodeVm {
     export interface Context { }
     export interface Script {
         runInThisContext(): void;
@@ -572,9 +571,8 @@ declare module "vm" {
     export function createScript(code: string, filename?: string): Script;
 }
 
-declare module "child_process" {
-    import events = require("events");
-    import stream = require("stream");
+declare module "child_process" { export = NodeChildProcess; }
+declare module NodeChildProcess {
 
     export interface ChildProcess extends NodeEventEmitter {
         stdin: WritableStream;
@@ -621,7 +619,8 @@ declare module "child_process" {
     }): ChildProcess;
 }
 
-declare module "url" {
+declare module "url" { export = NodeUrl; }
+declare module NodeUrl {
     export interface Url {
         href: string;
         protocol: string;
@@ -651,7 +650,8 @@ declare module "url" {
     export function resolve(from: string, to: string): string;
 }
 
-declare module "dns" {
+declare module "dns" { export = NodeDns; }
+declare module NodeDns {
     export function lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string;
     export function lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string;
     export function resolve(domain: string, rrtype: string, callback: (err: Error, addresses: string[]) =>void ): string[];
@@ -666,8 +666,8 @@ declare module "dns" {
     export function reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[];
 }
 
-declare module "net" {
-    import stream = require("stream");
+declare module "net" { export = NodeNet; }
+declare module NodeNet {
 
     export interface Socket extends ReadWriteStream {
         // Extended base methods
@@ -728,8 +728,8 @@ declare module "net" {
     export function isIPv6(input: string): boolean;
 }
 
-declare module "dgram" {
-    import events = require("events");
+declare module "dgram" { export = NodeDgram; }
+declare module NodeDgram {
 
     export function createSocket(type: string, callback?: Function): Socket;
 
@@ -746,8 +746,8 @@ declare module "dgram" {
     }
 }
 
-declare module "fs" {
-    import stream = require("stream");
+declare module "fs" { export = NodeFs; }
+declare module NodeFs {
 
     interface Stats {
         isFile(): boolean;
@@ -893,7 +893,8 @@ declare module "fs" {
     }): WriteStream;
 }
 
-declare module "path" {
+declare module "path" { export = NodePath; }
+declare module NodePath {
     export function normalize(p: string): string;
     export function join(...paths: any[]): string;
     export function resolve(...pathSegments: any[]): string;
@@ -904,7 +905,8 @@ declare module "path" {
     export var sep: string;
 }
 
-declare module "string_decoder" {
+declare module "string_decoder" { export = NodeStringDecoder; }
+declare module NodeStringDecoder {
     export interface NodeStringDecoder {
         write(buffer: NodeBuffer): string;
         detectIncompleteChar(buffer: NodeBuffer): number;
@@ -914,10 +916,8 @@ declare module "string_decoder" {
     };
 }
 
-declare module "tls" {
-    import crypto = require("crypto");
-    import net = require("net");
-    import stream = require("stream");
+declare module "tls" { export = NodeTls; }
+declare module NodeTls {
 
     var CLIENT_RENEG_LIMIT: number;
     var CLIENT_RENEG_WINDOW: number;
@@ -940,7 +940,7 @@ declare module "tls" {
     export interface ConnectionOptions {
         host?: string;
         port?: number;
-        socket?: net.Socket;
+        socket?: NodeNet.Socket;
         pfx?: any;   //string | Buffer
         key?: any;   //string | Buffer
         passphrase?: string;
@@ -951,7 +951,7 @@ declare module "tls" {
         servername?: string;
     }
 
-    export interface Server extends net.Server {
+    export interface Server extends NodeNet.Server {
         // Extended base methods
         listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
         listen(path: string, listeningListener?: Function): void;
@@ -995,10 +995,11 @@ declare module "tls" {
     export function connect(options: TlsOptions, secureConnectionListener?: () =>void ): ClearTextStream;
     export function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
     export function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
-    export function createSecurePair(credentials?: crypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
+    export function createSecurePair(credentials?: NodeCrypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
 }
 
-declare module "crypto" {
+declare module "crypto" { export = NodeCrypto; }
+declare module NodeCrypto {
     export interface CredentialDetails {
         pfx: string;
         key: string;
@@ -1064,8 +1065,8 @@ declare module "crypto" {
     export function pseudoRandomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
 }
 
-declare module "stream" {
-    import events = require("events");
+declare module "stream" { export = NodeStream; }
+declare module NodeStream {
 
     export interface ReadableOptions {
         highWaterMark?: number;
@@ -1073,7 +1074,7 @@ declare module "stream" {
         objectMode?: boolean;
     }
 
-    export class Readable extends events.EventEmitter implements ReadableStream {
+    export class Readable extends NodeEvents.EventEmitter implements ReadableStream {
         readable: boolean;
         constructor(opts?: ReadableOptions);
         _read(size: number): void;
@@ -1094,7 +1095,7 @@ declare module "stream" {
         decodeStrings?: boolean;
     }
 
-    export class Writable extends events.EventEmitter implements WritableStream {
+    export class Writable extends NodeEvents.EventEmitter implements WritableStream {
         writable: boolean;
         constructor(opts?: WritableOptions);
         _write(data: NodeBuffer, encoding: string, callback: Function): void;
@@ -1130,7 +1131,7 @@ declare module "stream" {
     export interface TransformOptions extends ReadableOptions, WritableOptions {}
 
     // Note: Transform lacks the _read and _write methods of Readable/Writable.
-    export class Transform extends events.EventEmitter implements ReadWriteStream {
+    export class Transform extends NodeEvents.EventEmitter implements ReadWriteStream {
         readable: boolean;
         writable: boolean;
         constructor(opts?: TransformOptions);
@@ -1159,7 +1160,8 @@ declare module "stream" {
     export class PassThrough extends Transform {}
 }
 
-declare module "util" {
+declare module "util" { export = NodeUtil; }
+declare module NodeUtil {
     export interface InspectOptions {
         showHidden?: boolean;
         depth?: number;
@@ -1182,9 +1184,10 @@ declare module "util" {
     export function inherits(constructor: any, superConstructor: any): void;
 }
 
-declare module "assert" {
-    function internal (value: any, message?: string): void;
-    module internal {
+declare module "assert" { export = NodeAssert; }
+declare function NodeAssert(value: any, message?: string): void;
+declare module NodeAssert {
+
         export class AssertionError implements Error {
             name: string;
             message: string;
@@ -1220,29 +1223,26 @@ declare module "assert" {
         }
 
         export function ifError(value: any): void;
-    }
-
-    export = internal;
 }
 
-declare module "tty" {
-    import net = require("net");
+declare module "tty" { export = NodeTty; }
+declare module NodeTty {
 
     export function isatty(fd: number): boolean;
-    export interface ReadStream extends net.Socket {
+    export interface ReadStream extends NodeNet.Socket {
         isRaw: boolean;
         setRawMode(mode: boolean): void;
     }
-    export interface WriteStream extends net.Socket {
+    export interface WriteStream extends NodeNet.Socket {
         columns: number;
         rows: number;
     }
 }
 
-declare module "domain" {
-    import events = require("events");
+declare module "domain" { export = NodeDomain; }
+declare module NodeDomain {
 
-    export class Domain extends events.EventEmitter {
+    export class Domain extends NodeEvents.EventEmitter {
         run(fn: Function): void;
         add(emitter: NodeEventEmitter): void;
         remove(emitter: NodeEventEmitter): void;

From 64bd6c8132f7daf0f306f156fd68127ea4eef3e7 Mon Sep 17 00:00:00 2001
From: maanasa <maanasa83@gmail.com>
Date: Wed, 26 Mar 2014 17:04:20 +0530
Subject: [PATCH 205/309] Update typeahead-tests.ts

---
 typeahead/typeahead-tests.ts | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/typeahead/typeahead-tests.ts b/typeahead/typeahead-tests.ts
index f93049a44..3a24fb152 100644
--- a/typeahead/typeahead-tests.ts
+++ b/typeahead/typeahead-tests.ts
@@ -71,3 +71,16 @@ $('.example-films .typeahead').typeahead([
         engine: Hogan
     }
 ]);
+
+//Basic substring search
+//Specifies options along with datasets. In this case the dataset uses a custom substring matcher function as its source
+$('#the-basics .typeahead').typeahead({
+  hint: true,
+  highlight: true,
+  minLength: 1
+},
+{
+  name: 'states',
+  displayKey: 'value',
+  source: substringMatcher(states)
+});

From ec0735af319299632e738be3d0d1fdeae9ed927e Mon Sep 17 00:00:00 2001
From: maanasa <maanasa83@gmail.com>
Date: Wed, 26 Mar 2014 17:45:30 +0530
Subject: [PATCH 206/309] Update typeahead-tests.ts

Adding tests for including options
---
 typeahead/typeahead-tests.ts | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/typeahead/typeahead-tests.ts b/typeahead/typeahead-tests.ts
index 3a24fb152..67fc8d31a 100644
--- a/typeahead/typeahead-tests.ts
+++ b/typeahead/typeahead-tests.ts
@@ -72,15 +72,16 @@ $('.example-films .typeahead').typeahead([
     }
 ]);
 
-//Basic substring search
-//Specifies options along with datasets. In this case the dataset uses a custom substring matcher function as its source
-$('#the-basics .typeahead').typeahead({
+// Countries - Modified the first test here to add options
+// Specifies options to display hint with a highlight and adds a minimum length restriction for search
+// Prefetches data, stores it in localStorage, and searches it on the client
+$('.example-countries .typeahead').typeahead({
   hint: true,
   highlight: true,
-  minLength: 1
+  minLength: 2
 },
 {
-  name: 'states',
-  displayKey: 'value',
-  source: substringMatcher(states)
+  name: 'countries',
+  prefetch: '../data/countries.json',
+  limit: 10
 });

From 9f9d58db2154e4d86890b0acc4fdb9efeba01172 Mon Sep 17 00:00:00 2001
From: MaceWindu <buzyka@gmail.com>
Date: Wed, 26 Mar 2014 17:20:55 +0100
Subject: [PATCH 207/309] Fix callback parameters type for $.Deffered methods

---
 jquery/jquery.d.ts | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index b42f77aaa..07a4062d9 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -287,6 +287,13 @@ interface JQueryGenericPromise<T> {
     then<U>(doneFilter: (value: T) => JQueryGenericPromise<U>, failFilter?: (reason: any) => JQueryGenericPromise<U>): JQueryGenericPromise<U>;
 }
 
+/**
+ * Interface for the JQuery promise/deffered callbacks
+ */
+interface JQueryPromiseCallback<T> {
+    (value?: T, ...args: any[]): void;
+}
+
 /**
  * Interface for the JQuery promise, part of callbacks
  */
@@ -297,27 +304,27 @@ interface JQueryPromise<T> {
      * @param alwaysCallbacks1 A function, or array of functions, that is called when the Deferred is resolved or rejected.
      * @param alwaysCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved or rejected.
      */
-    always(alwaysCallbacks1?: T, ...alwaysCallbacks2: T[]): JQueryDeferred<T>;
+    always(alwaysCallbacks1?: JQueryPromiseCallback<T>, ...alwaysCallbacks2: JQueryPromiseCallback<T>[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object is resolved.
      * 
      * @param doneCallbacks1 A function, or array of functions, that are called when the Deferred is resolved.
      * @param doneCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved.
      */
-    done(doneCallbacks1?: T, ...doneCallbacks2: T[]): JQueryDeferred<T>;
+    done(doneCallbacks1?: JQueryPromiseCallback<T>, ...doneCallbacks2: JQueryPromiseCallback<T>[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object is rejected.
      * 
      * @param failCallbacks1 A function, or array of functions, that are called when the Deferred is rejected.
      * @param failCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is rejected.
      */
-    fail(failCallbacks1?: T, ...failCallbacks2: T[]): JQueryDeferred<T>;
+    fail(failCallbacks1?: JQueryPromiseCallback<T>, ...failCallbacks2: JQueryPromiseCallback<T>[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object generates progress notifications.
      * 
      * @param progressCallbacks A function, or array of functions, to be called when the Deferred generates progress notifications.
      */
-    progress(...progressCallbacks: T[]): JQueryDeferred<T>;
+    progress(...progressCallbacks: JQueryPromiseCallback<T>[]): JQueryDeferred<T>;
 
     /**
      * Add handlers to be called when the Deferred object is either resolved or rejected.
@@ -425,27 +432,27 @@ interface JQueryDeferred<T> extends JQueryPromise<T> {
      * @param alwaysCallbacks1 A function, or array of functions, that is called when the Deferred is resolved or rejected.
      * @param alwaysCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved or rejected.
      */
-    always(alwaysCallbacks1?: T, ...alwaysCallbacks2: T[]): JQueryDeferred<T>;
+    always(alwaysCallbacks1?: JQueryPromiseCallback<T>, ...alwaysCallbacks2: JQueryPromiseCallback<T>[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object is resolved.
      * 
      * @param doneCallbacks1 A function, or array of functions, that are called when the Deferred is resolved.
      * @param doneCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved.
      */
-    done(doneCallbacks1?: T, ...doneCallbacks2: T[]): JQueryDeferred<T>;
+    done(doneCallbacks1?: JQueryPromiseCallback<T>, ...doneCallbacks2: JQueryPromiseCallback<T>[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object is rejected.
      * 
      * @param failCallbacks1 A function, or array of functions, that are called when the Deferred is rejected.
      * @param failCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is rejected.
      */
-    fail(failCallbacks1?: T, ...failCallbacks2: T[]): JQueryDeferred<T>;
+    fail(failCallbacks1?: JQueryPromiseCallback<T>, ...failCallbacks2: JQueryPromiseCallback<T>[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object generates progress notifications.
      * 
      * @param progressCallbacks A function, or array of functions, to be called when the Deferred generates progress notifications.
      */
-    progress(...progressCallbacks: T[]): JQueryDeferred<T>;
+    progress(...progressCallbacks: JQueryPromiseCallback<T>[]): JQueryDeferred<T>;
 
     /**
      * Call the progressCallbacks on a Deferred object with the given args.

From cb01abe1b25ef5ebe2e6df5de764ef2d8ad07a5b Mon Sep 17 00:00:00 2001
From: John Purcell <john.purcell@blackboard.com>
Date: Wed, 26 Mar 2014 14:54:22 -0400
Subject: [PATCH 208/309] Return correct type from .listen() and .close(),
 expose .address() on http.Server

---
 node/node-tests.ts |  8 ++++++++
 node/node.d.ts     | 27 ++++++++++++++-------------
 2 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/node/node-tests.ts b/node/node-tests.ts
index 397a9dfa4..9b896a3ef 100644
--- a/node/node-tests.ts
+++ b/node/node-tests.ts
@@ -6,6 +6,8 @@ import events = require("events");
 import zlib = require("zlib");
 import url = require('url');
 import util = require("util");
+import http = require("http");
+import net = require("net");
 
 assert(1 + 1 - 2 === 0, "The universe isn't how it should.");
 
@@ -80,3 +82,9 @@ function stream_readable_pipe_test() {
     var w = fs.createWriteStream('file.txt.gz');
     r.pipe(z).pipe(w);
 }
+
+////////////////////////////////////////////////////
+
+// Make sure .listen() and .close() retuern a Server instance
+http.createServer().listen(0).close().address();
+net.createServer().listen(0).close().address();
diff --git a/node/node.d.ts b/node/node.d.ts
index 4fafb883e..4a15d4777 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -252,10 +252,11 @@ declare module "http" {
     import stream = require("stream");
 
     export interface Server extends NodeEventEmitter {
-        listen(port: number, hostname?: string, backlog?: number, callback?: Function): void;
-        listen(path: string, callback?: Function): void;
-        listen(handle: any, listeningListener?: Function): void;
-        close(cb?: any): void;
+        listen(port: number, hostname?: string, backlog?: number, callback?: Function): Server;
+        listen(path: string, callback?: Function): Server;
+        listen(handle: any, listeningListener?: Function): Server;
+        close(cb?: any): Server;
+        address(): { port: number; family: string; address: string; };
         maxHeadersCount: number;
     }
     export interface ServerRequest extends NodeEventEmitter, ReadableStream {
@@ -707,10 +708,10 @@ declare module "net" {
     };
 
     export interface Server extends Socket {
-        listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
-        listen(path: string, listeningListener?: Function): void;
-        listen(handle: any, listeningListener?: Function): void;
-        close(callback?: Function): void;
+        listen(port: number, host?: string, backlog?: number, listeningListener?: Function): Server;
+        listen(path: string, listeningListener?: Function): Server;
+        listen(handle: any, listeningListener?: Function): Server;
+        close(callback?: Function): Server;
         address(): { port: number; family: string; address: string; };
         maxConnections: number;
         connections: number;
@@ -953,12 +954,12 @@ declare module "tls" {
 
     export interface Server extends net.Server {
         // Extended base methods
-        listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
-        listen(path: string, listeningListener?: Function): void;
-        listen(handle: any, listeningListener?: Function): void;
+        listen(port: number, host?: string, backlog?: number, listeningListener?: Function): Server;
+        listen(path: string, listeningListener?: Function): Server;
+        listen(handle: any, listeningListener?: Function): Server;
 
-        listen(port: number, host?: string, callback?: Function): void;
-        close(): void;
+        listen(port: number, host?: string, callback?: Function): Server;
+        close(): Server;
         address(): { port: number; family: string; address: string; };
         addContext(hostName: string, credentials: {
             key: string;

From f5b19e8dd70c9f35cd32ca900bf4553f9ce09221 Mon Sep 17 00:00:00 2001
From: John Purcell <john.purcell@blackboard.com>
Date: Wed, 26 Mar 2014 15:07:49 -0400
Subject: [PATCH 209/309] Return http.Server from express.listen()

---
 express/express-tests.ts |  7 +++++++
 express/express.d.ts     | 10 +++++-----
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/express/express-tests.ts b/express/express-tests.ts
index 3efdf19a6..57d1d638c 100644
--- a/express/express-tests.ts
+++ b/express/express-tests.ts
@@ -1489,3 +1489,10 @@ function test_middleware() {
     app.use(express.static('public'));
     app.use(router.middleware);
 }
+
+////////////////////
+
+// make sure server can be shut down
+var testShutdownServer = app.listen(0);
+console.log('listening on port ' + testShutdownServer.address().port);
+testShutdownServer.close();
diff --git a/express/express.d.ts b/express/express.d.ts
index 243aa41d4..7dd170629 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -1112,15 +1112,15 @@ declare module "express" {
              *    http.createServer(app).listen(80);
              *    https.createServer({ ... }, app).listen(443);
              */
-            listen(port: number, hostname: string, backlog: number, callback?: Function): void;
+            listen(port: number, hostname: string, backlog: number, callback?: Function): http.Server;
 
-            listen(port: number, hostname: string, callback?: Function): void;
+            listen(port: number, hostname: string, callback?: Function): http.Server;
 
-            listen(port: number, callback?: Function): void;
+            listen(port: number, callback?: Function): http.Server;
 
-            listen(path: string, callback?: Function): void;
+            listen(path: string, callback?: Function): http.Server;
 
-            listen(handle: any, listeningListener?: Function): void;
+            listen(handle: any, listeningListener?: Function): http.Server;
 
             route: IRoute;
 

From d92f1822bdd173173ce92991c99db8ef061e497d Mon Sep 17 00:00:00 2001
From: MaceWindu <buzyka@gmail.com>
Date: Wed, 26 Mar 2014 21:03:19 +0100
Subject: [PATCH 210/309] fix tests, add additional overrides to deferred
 methods

---
 jquery/jquery-tests.ts | 9 ++++++---
 jquery/jquery.d.ts     | 9 +++++++++
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/jquery/jquery-tests.ts b/jquery/jquery-tests.ts
index 37e03aa88..973818f5a 100644
--- a/jquery/jquery-tests.ts
+++ b/jquery/jquery-tests.ts
@@ -3164,8 +3164,11 @@ $.ajax({
 
 function test_deferred() {
 
-    function returnPromise(): JQueryPromise<(data: { MyString: string; MyNumber: number; }, textStatus: string, jqXHR: JQueryXHR) => any> {
-        return $.ajax("test.php");
+    function returnPromise(): JQueryPromise<{ MyString: string; MyNumber: number; }> {
+        return $.Deferred<{ MyString: string; MyNumber: number; }>().resolve({
+            MyString: "MyString",
+            MyNumber: 5
+        }, "failed", null);
     }
     var x = returnPromise();
     x.done((data, textStatus, jqXHR) => {
@@ -3190,7 +3193,7 @@ function test_deferred() {
     function fn3(n) {
         $("p").append(n + " 3 " + n);
     }
-    var dfd = $.Deferred();
+    var dfd = $.Deferred<string>();
     dfd
         .done([fn1, fn2], fn3, [fn2, fn1])
         .done(function (n) {
diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index 07a4062d9..eadd8a492 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -433,6 +433,9 @@ interface JQueryDeferred<T> extends JQueryPromise<T> {
      * @param alwaysCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved or rejected.
      */
     always(alwaysCallbacks1?: JQueryPromiseCallback<T>, ...alwaysCallbacks2: JQueryPromiseCallback<T>[]): JQueryDeferred<T>;
+    always(alwaysCallbacks1?: JQueryPromiseCallback<T>[], ...alwaysCallbacks2: JQueryPromiseCallback<T>[]): JQueryDeferred<T>;
+    always(alwaysCallbacks1?: JQueryPromiseCallback<T>, ...alwaysCallbacks2: any[]): JQueryDeferred<T>;
+    always(alwaysCallbacks1?: JQueryPromiseCallback<T>[], ...alwaysCallbacks2: any[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object is resolved.
      * 
@@ -440,6 +443,9 @@ interface JQueryDeferred<T> extends JQueryPromise<T> {
      * @param doneCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved.
      */
     done(doneCallbacks1?: JQueryPromiseCallback<T>, ...doneCallbacks2: JQueryPromiseCallback<T>[]): JQueryDeferred<T>;
+    done(doneCallbacks1?: JQueryPromiseCallback<T>[], ...doneCallbacks2: JQueryPromiseCallback<T>[]): JQueryDeferred<T>;
+    done(doneCallbacks1?: JQueryPromiseCallback<T>, ...doneCallbacks2: any[]): JQueryDeferred<T>;
+    done(doneCallbacks1?: JQueryPromiseCallback<T>[], ...doneCallbacks2: any[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object is rejected.
      * 
@@ -447,6 +453,9 @@ interface JQueryDeferred<T> extends JQueryPromise<T> {
      * @param failCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is rejected.
      */
     fail(failCallbacks1?: JQueryPromiseCallback<T>, ...failCallbacks2: JQueryPromiseCallback<T>[]): JQueryDeferred<T>;
+    fail(failCallbacks1?: JQueryPromiseCallback<T>[], ...failCallbacks2: JQueryPromiseCallback<T>[]): JQueryDeferred<T>;
+    fail(failCallbacks1?: JQueryPromiseCallback<T>, ...failCallbacks2: any[]): JQueryDeferred<T>;
+    fail(failCallbacks1?: JQueryPromiseCallback<T>[], ...failCallbacks2: any[]): JQueryDeferred<T>;
     /**
      * Add handlers to be called when the Deferred object generates progress notifications.
      * 

From caafcbc990c135f8c7720513c38f6128794b9656 Mon Sep 17 00:00:00 2001
From: MaceWindu <buzyka@gmail.com>
Date: Wed, 26 Mar 2014 21:44:54 +0100
Subject: [PATCH 211/309] a bit more definitions for jsPlumb. Still, this file
 miss a lot of definitions from jsPlumb

---
 jsplumb/jquery.jsPlumb.d.ts | 41 +++++++++++++++++++++++++++++--------
 1 file changed, 32 insertions(+), 9 deletions(-)

diff --git a/jsplumb/jquery.jsPlumb.d.ts b/jsplumb/jquery.jsPlumb.d.ts
index ed7bc8452..ffa26eea8 100644
--- a/jsplumb/jquery.jsPlumb.d.ts
+++ b/jsplumb/jquery.jsPlumb.d.ts
@@ -5,7 +5,9 @@
 
 /// <reference path="../jquery/jquery.d.ts"/>
 
-interface jsPlumb {
+declare var jsPlumb: jsPlumbInstance;
+
+interface jsPlumbInstance {
 	setRenderMode(renderMode: string): string;
 	bind(event: string, callback: (e) => void ): void;
 	unbind(event?: string): void;
@@ -17,16 +19,26 @@ interface jsPlumb {
 	addEndpoint(ep: string): any;
 	removeClass(el: any, clazz: string): void;
 	hasClass(el: any, clazz: string): void;
-	draggable(el: any, container?: DragContainer): void;
-	connect(connection: ConnectParams): void;
+    draggable(el: string, options?: DragOptions): jsPlumbInstance;
+    draggable(ids: string[], options?: DragOptions): jsPlumbInstance;
+    connect(connection: ConnectParams, referenceParams?: ConnectParams): Connection;
 	makeSource(el: string, options: SourceOptions): void;
 	makeTarget(el: string, options: TargetOptions): void;
 	repaintEverything(): void;
 	detachEveryConnection(): void;
 	detachAllConnections(el: string): void;
-	removeAllEndpoints(el: any): void;
+    removeAllEndpoints(el: string, recurse?: boolean): jsPlumbInstance;
+    removeAllEndpoints(el: Element, recurse?: boolean): jsPlumbInstance;
 	select(params: SelectParams): Connections;
-	getConnections(options?: any, flat?: any): any[];
+    getConnections(options?: any, flat?: any): any[];
+    deleteEndpoint(uuid: string, doNotRepaintAfterwards?: boolean): jsPlumbInstance;
+    deleteEndpoint(endpoint: Endpoint, doNotRepaintAfterwards?: boolean): jsPlumbInstance;
+    repaint(el: string): jsPlumbInstance;
+    repaint(el: Element): jsPlumbInstance;
+
+    SVG: string;
+    CANVAS: string;
+    VML: string;
 }
 
 interface Defaults {
@@ -36,6 +48,8 @@ interface Defaults {
 	ConnectionsDetachable?: boolean;
 	ReattachConnections?: boolean;
 	ConnectionOverlays?: any[][];
+    Container?: any; // string(selector or id) or element
+    DragOptions?: DragOptions;
 }
 
 interface PaintStyle {
@@ -62,8 +76,8 @@ interface Connections {
 }
 
 interface ConnectParams {
-	source: string;
-	target: string;
+    source?: any; // string, element or endpoint
+    target?: any; // string, element or endpoint
 	detachable?: boolean;
 	deleteEndpointsOnDetach?: boolean;
 	endPoint?: string;
@@ -72,8 +86,8 @@ interface ConnectParams {
 	label?: string;
 }
 
-interface DragContainer {
-	containment: string;
+interface DragOptions {
+	containment?: string;
 }
 
 interface SourceOptions {
@@ -103,3 +117,12 @@ interface SelectParams {
 	source: string;
 	target: string;
 }
+
+interface Connection {
+    setDetachable(detachable: boolean): void;
+    setParameter<T>(name: string, value: T): void;
+    endpoints: Endpoint[];
+}
+
+interface Endpoint {
+}
\ No newline at end of file

From 08e8430ce59073aaf47b9b9332c989c6bff04cf0 Mon Sep 17 00:00:00 2001
From: maanasa <maanasa83@gmail.com>
Date: Mon, 24 Mar 2014 15:29:49 +0530
Subject: [PATCH 212/309] Update typeahead.d.ts

added support for call typeahead(options, dataset) where options include hint, highlight and minLength all of which are optional.
---
 typeahead/typeahead.d.ts | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/typeahead/typeahead.d.ts b/typeahead/typeahead.d.ts
index 9ee948392..f6f387986 100644
--- a/typeahead/typeahead.d.ts
+++ b/typeahead/typeahead.d.ts
@@ -50,6 +50,16 @@ interface JQuery {
       * @param query The query to be set in case method 'setQuery' is used.
       */
     typeahead(methodName: string, query: string): JQuery;
+    
+    /**
+      * Accomodates specifying options such as hint and highlight.
+      * This is in correspondence to the examples mentioned in http://twitter.github.io/typeahead.js/examples/
+      *
+      * @constructor
+      * @param options ('hint' or 'highlight' or 'minLength' all of which are optional)
+      * @param dataset Array of datasets
+      */
+    typeahead(options: Twitter.Typeahead.Options, dataset: Twitter.Typeahead.Dataset): JQuery;
 }
 
 declare module Twitter.Typeahead {
@@ -243,4 +253,26 @@ declare module Twitter.Typeahead {
           */
         tokens: string[];
     }
+    
+     /**
+      * When initializing a typeahead, there are a number of options you can configure.
+      */
+    interface Options {
+      /**
+        * highlight:  If true, when suggestions are rendered, 
+        * pattern matches for the current query in text nodes will be wrapped in a strong element.
+        * Defaults to false. 
+        */
+      highlight?: boolean;
+
+      /**
+        * If false, the typeahead will not show a hint. Defaults to true.
+        */
+      hint?: boolean;
+
+      /**
+        * The minimum character length needed before suggestions start getting rendered. Defaults to 1.
+        */
+      minLength?: number;
+    }
 }

From 63199e8ecc6829b2097829aecd8ac726770aac2c Mon Sep 17 00:00:00 2001
From: maanasa <maanasa83@gmail.com>
Date: Wed, 26 Mar 2014 17:04:20 +0530
Subject: [PATCH 213/309] Update typeahead-tests.ts

---
 typeahead/typeahead-tests.ts | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/typeahead/typeahead-tests.ts b/typeahead/typeahead-tests.ts
index f93049a44..3a24fb152 100644
--- a/typeahead/typeahead-tests.ts
+++ b/typeahead/typeahead-tests.ts
@@ -71,3 +71,16 @@ $('.example-films .typeahead').typeahead([
         engine: Hogan
     }
 ]);
+
+//Basic substring search
+//Specifies options along with datasets. In this case the dataset uses a custom substring matcher function as its source
+$('#the-basics .typeahead').typeahead({
+  hint: true,
+  highlight: true,
+  minLength: 1
+},
+{
+  name: 'states',
+  displayKey: 'value',
+  source: substringMatcher(states)
+});

From b47ce62205575b22a07ccb7ec614fdb3cbf034b5 Mon Sep 17 00:00:00 2001
From: maanasa <maanasa83@gmail.com>
Date: Wed, 26 Mar 2014 17:45:30 +0530
Subject: [PATCH 214/309] Update typeahead-tests.ts

Adding tests for including options
---
 typeahead/typeahead-tests.ts | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/typeahead/typeahead-tests.ts b/typeahead/typeahead-tests.ts
index 3a24fb152..67fc8d31a 100644
--- a/typeahead/typeahead-tests.ts
+++ b/typeahead/typeahead-tests.ts
@@ -72,15 +72,16 @@ $('.example-films .typeahead').typeahead([
     }
 ]);
 
-//Basic substring search
-//Specifies options along with datasets. In this case the dataset uses a custom substring matcher function as its source
-$('#the-basics .typeahead').typeahead({
+// Countries - Modified the first test here to add options
+// Specifies options to display hint with a highlight and adds a minimum length restriction for search
+// Prefetches data, stores it in localStorage, and searches it on the client
+$('.example-countries .typeahead').typeahead({
   hint: true,
   highlight: true,
-  minLength: 1
+  minLength: 2
 },
 {
-  name: 'states',
-  displayKey: 'value',
-  source: substringMatcher(states)
+  name: 'countries',
+  prefetch: '../data/countries.json',
+  limit: 10
 });

From f53cbfcb026e5724fc6ed26ca9900e046b7b04c5 Mon Sep 17 00:00:00 2001
From: LiFeleSs <lifeless85@gmail.com>
Date: Thu, 27 Mar 2014 11:29:05 +0100
Subject: [PATCH 215/309] Element.transform() now return a transform

added the overload for Element.transform() without arguments
Fix for #1921
---
 svgjs/svgjs.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/svgjs/svgjs.d.ts b/svgjs/svgjs.d.ts
index ec3ffe5c5..f5ceb81f2 100644
--- a/svgjs/svgjs.d.ts
+++ b/svgjs/svgjs.d.ts
@@ -104,7 +104,7 @@ declare module svgjs {
         filter(adder:(filter:Filter)=>void):Element;        
 
         transform(t:Transform):Element;
-        
+        transform(): Transform;
         
         style(name:string, value:string):Element;
         style(obj:Object):Element;

From 5d66022fb81bb888e7dfb9bd7df2e0c3fb1ede2f Mon Sep 17 00:00:00 2001
From: Luigi Trabacchin <trabacchin.luigi@gmail.com>
Date: Thu, 27 Mar 2014 11:40:01 +0100
Subject: [PATCH 216/309] Added support for svgjs.draggable

---
 svgjs.draggable/svgjs.draggable.d.ts | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 svgjs.draggable/svgjs.draggable.d.ts

diff --git a/svgjs.draggable/svgjs.draggable.d.ts b/svgjs.draggable/svgjs.draggable.d.ts
new file mode 100644
index 000000000..67c38bffe
--- /dev/null
+++ b/svgjs.draggable/svgjs.draggable.d.ts
@@ -0,0 +1,7 @@
+declare module svgjs {
+	export interface Element {
+		draggable(): Element
+		draggable(obj: Object):Element
+		fixed(): Element
+	}
+}

From 1503788c8ddc432759793d7a765ca8a59471ed6d Mon Sep 17 00:00:00 2001
From: Panu Horsmalahti <panu.horsmalahti@iki.fi>
Date: Thu, 27 Mar 2014 13:09:09 +0200
Subject: [PATCH 217/309] Update Q.d.ts

Add nfapply defintion.

See API reference here: https://github.com/kriskowal/q/wiki/API-Reference
---
 q/Q.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/q/Q.d.ts b/q/Q.d.ts
index 85462503a..65b2b8223 100644
--- a/q/Q.d.ts
+++ b/q/Q.d.ts
@@ -209,6 +209,7 @@ declare module Q {
 
     export function nfbind<T>(nodeFunction: Function, ...args: any[]): (...args: any[]) => Promise<T>;
     export function nfcall<T>(nodeFunction: Function, ...args: any[]): Promise<T>;
+    export function nfapply<T>(nodeFunction: Function, args: any[]): Promise<T>;
 
     export function ninvoke<T>(nodeModule: any, functionName: string, ...args: any[]): Promise<T>;
     export function nsend<T>(nodeModule: any, functionName: string, ...args: any[]): Promise<T>;

From 8823d0b6dc723574a2b542e581cac02865d9094e Mon Sep 17 00:00:00 2001
From: Luigi Trabacchin <trabacchin.luigi@gmail.com>
Date: Thu, 27 Mar 2014 13:51:33 +0100
Subject: [PATCH 218/309] added callbacks

added callbacks methods for Element
---
 svgjs.draggable/svgjs.draggable.d.ts | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/svgjs.draggable/svgjs.draggable.d.ts b/svgjs.draggable/svgjs.draggable.d.ts
index 67c38bffe..68c204a7f 100644
--- a/svgjs.draggable/svgjs.draggable.d.ts
+++ b/svgjs.draggable/svgjs.draggable.d.ts
@@ -1,7 +1,20 @@
 declare module svgjs {
+	export module draggable {
+		export interface DragDelta {
+			x: number
+			y: number
+			zoom: number
+		}
+	}
+
 	export interface Element {
 		draggable(): Element
 		draggable(obj: Object):Element
 		fixed(): Element
+		beforedrag: (e) => any
+		dragstart: (delta: draggable.DragDelta, e) => any
+		dragmove: (delta: draggable.DragDelta, e) => any
+		dragend: (delta: draggable.DragDelta, e) => any
+
 	}
 }

From 4fbbc8c6e3694630317d1fdd66e4917db889cf88 Mon Sep 17 00:00:00 2001
From: Luigi Trabacchin <trabacchin.luigi@gmail.com>
Date: Thu, 27 Mar 2014 21:36:45 +0100
Subject: [PATCH 219/309] added a test for Element.transform()

Test if svgjs.Element.transform() correctly return an svgjs.Element.Transform
---
 svgjs/svgjs-tests.ts | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/svgjs/svgjs-tests.ts b/svgjs/svgjs-tests.ts
index fce9c3a74..60d07cab5 100644
--- a/svgjs/svgjs-tests.ts
+++ b/svgjs/svgjs-tests.ts
@@ -66,4 +66,23 @@ function renderSVG(data:string) {
         var uniqueId = "path"+index++
         path.attr({"path-id": uniqueId})
     })
-}
\ No newline at end of file
+}
+
+//Test if svgjs.Element.transform() correctly return an svgjs.Element.Transform
+function elementTransformShouldReturnTransformObject() {
+    /* create an svg drawing */
+    var div = document.createElement('div')
+    var draw = SVG(div)
+
+    /* draw a rectangle scale, rotate and skew it */
+    var rect = draw.rect(50,50).move(100,100).scale(0.5, 0.3).rotate(35).skew(10,25)
+    
+    /* first try to cast it */
+    var trans:svgjs.Transform = rect.transform()
+    /* then check values if they are correct */
+    if (trans.scaleX != 0.5) { throw "scaleX value is not correct" }
+    if (trans.scaleY != 0.3) { throw "scaleY value is not correct" }
+    if (trans.rotation != 35) { throw "rotation value is not correct" }
+    if (trans.skewX != 10) { throw "skewX value is not correct" }
+    if (trans.skewY != 25) { throw "skewY value is not correct" }
+}

From 99c6b472e7f2048fc5de04e487ef3024ab642c31 Mon Sep 17 00:00:00 2001
From: Luigi Trabacchin <trabacchin.luigi@gmail.com>
Date: Thu, 27 Mar 2014 22:30:08 +0100
Subject: [PATCH 220/309] defined the event type

this was not compiling because the event type was not defined
---
 svgjs.draggable/svgjs.draggable.d.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/svgjs.draggable/svgjs.draggable.d.ts b/svgjs.draggable/svgjs.draggable.d.ts
index 68c204a7f..76837f58e 100644
--- a/svgjs.draggable/svgjs.draggable.d.ts
+++ b/svgjs.draggable/svgjs.draggable.d.ts
@@ -11,10 +11,10 @@ declare module svgjs {
 		draggable(): Element
 		draggable(obj: Object):Element
 		fixed(): Element
-		beforedrag: (e) => any
-		dragstart: (delta: draggable.DragDelta, e) => any
-		dragmove: (delta: draggable.DragDelta, e) => any
-		dragend: (delta: draggable.DragDelta, e) => any
+		beforedrag: (event: MouseEvent) => any
+		dragstart: (delta: draggable.DragDelta, event: MouseEvent) => any
+		dragmove: (delta: draggable.DragDelta, event: MouseEvent) => any
+		dragend: (delta: draggable.DragDelta, event: MouseEvent) => any
 
 	}
 }

From 7c77089f1007a06985923b045b91522c3502b6f7 Mon Sep 17 00:00:00 2001
From: enternet <ad@ad.by>
Date: Fri, 28 Mar 2014 11:05:43 +0300
Subject: [PATCH 221/309] Projection.parallels()

Someone forgot to declare this very useful method.
---
 d3/d3.d.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/d3/d3.d.ts b/d3/d3.d.ts
index 50d9eb6e6..b5765b70f 100644
--- a/d3/d3.d.ts
+++ b/d3/d3.d.ts
@@ -3172,6 +3172,10 @@ declare module D3 {
                 (): Array<number>;
                 (location: Array<number>): Projection;
             };
+            parallels: {
+                (): Array<number>;
+                (location: Array<number>): Projection;
+            };
             translate: {
                 (): Array<number>;
                 (point: Array<number>): Projection;

From a7829a1fd977e3e51bd2a5921b78f75ef036a333 Mon Sep 17 00:00:00 2001
From: Troy Gerwien <yortus@gmail.com>
Date: Fri, 28 Mar 2014 22:32:20 +0800
Subject: [PATCH 222/309] referenceable types throughout node and express

All node modules and classes can be referenced by type name. External
module support remains unchanged, but now static type information is
available for all node modules and types without needing to go through
the external module definitions.

Similar for express.
---
 express/express.d.ts |    8 +-
 node/node.d.ts       | 2017 ++++++++++++++++++++++--------------------
 2 files changed, 1053 insertions(+), 972 deletions(-)

diff --git a/express/express.d.ts b/express/express.d.ts
index e18b7bc7d..b7331a43d 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -12,8 +12,10 @@
 
 /// <reference path="../node/node.d.ts" />
 
-declare module "express" { export = ExpressStatic; }
-declare function ExpressStatic(): ExpressStatic.Express
+declare module "express" { var _: ExpressStatic; export = _; }
+interface ExpressStatic{
+    (): ExpressStatic.Express
+}
 declare module ExpressStatic {
 
         export interface IRoute {
@@ -546,7 +548,7 @@ declare module ExpressStatic {
             (body: any): Response;
         }
 
-        export interface Response extends NodeHttp.ServerResponse {
+        export interface Response extends NodeJs.Http.ServerResponse {
             /**
              * Set status `code`.
              *
diff --git a/node/node.d.ts b/node/node.d.ts
index ddfb5b94a..f82ffe202 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -221,1041 +221,1120 @@ interface NodeTimer {
 
 /************************************************
 *                                               *
-*                   MODULES                     *
+*              MODULES - EXTERNAL               *
 *                                               *
 ************************************************/
-declare module "querystring" { export = NodeQueryString; }
-declare module NodeQueryString {
-    export function stringify(obj: any, sep?: string, eq?: string): string;
-    export function parse(str: string, sep?: string, eq?: string, options?: { maxKeys?: number; }): any;
-    export function escape(): any;
-    export function unescape(): any;
-}
 
-declare module "events" { export = NodeEvents; }
-declare module NodeEvents {
-    export class EventEmitter implements NodeEventEmitter {
-        static listenerCount(emitter: EventEmitter, event: string): number;
+declare module "querystring"    { var _: NodeJs.QueryString;    export = _; }
+declare module "events"         { var _: NodeJs.Events;         export = _; }
+declare module "http"           { var _: NodeJs.Http;           export = _; }
+declare module "cluster"        { var _: NodeJs.Cluster;        export = _; }
+declare module "zlib"           { var _: NodeJs.Zlib;           export = _; }
+declare module "os"             { var _: NodeJs.Os;             export = _; }
+declare module "https"          { var _: NodeJs.Https;          export = _; }
+declare module "punycode"       { var _: NodeJs.PunyCode;       export = _; }
+declare module "repl"           { var _: NodeJs.Repl;           export = _; }
+declare module "readline"       { var _: NodeJs.ReadLine;       export = _; }
+declare module "vm"             { var _: NodeJs.Vm;             export = _; }
+declare module "child_process"  { var _: NodeJs.ChildProcess;   export = _; }
+declare module "url"            { var _: NodeJs.Url;            export = _; }
+declare module "dns"            { var _: NodeJs.Dns;            export = _; }
+declare module "net"            { var _: NodeJs.Net;            export = _; }
+declare module "dgram"          { var _: NodeJs.Dgram;          export = _; }
+declare module "fs"             { var _: NodeJs.Fs;             export = _; }
+declare module "path"           { var _: NodeJs.Path;           export = _; }
+declare module "string_decoder" { var _: NodeJs.StringDecoder;  export = _; }
+declare module "tls"            { var _: NodeJs.Tls;            export = _; }
+declare module "crypto"         { var _: NodeJs.Crypto;         export = _; }
+declare module "stream"         { var _: NodeJs.Stream;         export = _; }
+declare module "util"           { var _: NodeJs.Util;           export = _; }
+declare module "assert"         { var _: NodeJs.Assert;         export = _; }
+declare module "tty"            { var _: NodeJs.Tty;            export = _; }
+declare module "domain"         { var _: NodeJs.Domain;         export = _; }
 
-        addListener(event: string, listener: Function): EventEmitter;
-        on(event: string, listener: Function): EventEmitter;
-        once(event: string, listener: Function): EventEmitter;
-        removeListener(event: string, listener: Function): EventEmitter;
-        removeAllListeners(event?: string): EventEmitter;
+/************************************************
+*                                               *
+*              MODULES - INTERNAL               *
+*                                               *
+************************************************/
+
+declare module NodeJs {
+
+    // "querystring" module
+    export interface QueryString {
+        stringify(obj: any, sep?: string, eq?: string): string;
+        parse(str: string, sep?: string, eq?: string, options?: { maxKeys?: number; }): any;
+        escape(): any;
+        unescape(): any;
+    }
+
+    // "events" module
+    export interface Events {
+        EventEmitter: Events.EventEmitterStatic;
+    }
+    export module Events {
+        export interface EventEmitterStatic {
+            listenerCount(emitter: EventEmitter, event: string): number;
+        }
+
+        export interface EventEmitter extends NodeEventEmitter {
+            addListener(event: string, listener: Function): EventEmitter;
+            on(event: string, listener: Function): EventEmitter;
+            once(event: string, listener: Function): EventEmitter;
+            removeListener(event: string, listener: Function): EventEmitter;
+            removeAllListeners(event?: string): EventEmitter;
+            setMaxListeners(n: number): void;
+            listeners(event: string): Function[];
+            emit(event: string, ...args: any[]): boolean;
+        }
+    }
+
+    // "http" module
+    export interface Http {
+        STATUS_CODES: any;
+        createServer(requestListener?: (request: Http.ServerRequest, response: Http.ServerResponse) =>void ): Http.Server;
+        createClient(port?: number, host?: string): any;
+        request(options: any, callback?: Function): Http.ClientRequest;
+        get(options: any, callback?: Function): Http.ClientRequest;
+        globalAgent: Http.Agent;
+    }
+    export module Http {
+
+        export interface Server extends NodeEventEmitter {
+            listen(port: number, hostname?: string, backlog?: number, callback?: Function): void;
+            listen(path: string, callback?: Function): void;
+            listen(handle: any, listeningListener?: Function): void;
+            close(cb?: any): void;
+            maxHeadersCount: number;
+        }
+        export interface ServerRequest extends NodeEventEmitter, ReadableStream {
+            method: string;
+            url: string;
+            headers: any;
+            trailers: string;
+            httpVersion: string;
+            setEncoding(encoding?: string): void;
+            pause(): void;
+            resume(): void;
+            connection: Net.Socket;
+        }
+        export interface ServerResponse extends NodeEventEmitter, WritableStream {
+            // Extended base methods
+            write(buffer: NodeBuffer): boolean;
+            write(buffer: NodeBuffer, cb?: Function): boolean;
+            write(str: string, cb?: Function): boolean;
+            write(str: string, encoding?: string, cb?: Function): boolean;
+            write(str: string, encoding?: string, fd?: string): boolean;
+
+            writeContinue(): void;
+            writeHead(statusCode: number, reasonPhrase?: string, headers?: any): void;
+            writeHead(statusCode: number, headers?: any): void;
+            statusCode: number;
+            setHeader(name: string, value: string): void;
+            sendDate: boolean;
+            getHeader(name: string): string;
+            removeHeader(name: string): void;
+            write(chunk: any, encoding?: string): any;
+            addTrailers(headers: any): void;
+
+            // Extended base methods
+            end(): void;
+            end(buffer: NodeBuffer, cb?: Function): void;
+            end(str: string, cb?: Function): void;
+            end(str: string, encoding?: string, cb?: Function): void;
+            end(data?: any, encoding?: string): void;
+        }
+        export interface ClientRequest extends NodeEventEmitter, WritableStream {
+            // Extended base methods
+            write(buffer: NodeBuffer): boolean;
+            write(buffer: NodeBuffer, cb?: Function): boolean;
+            write(str: string, cb?: Function): boolean;
+            write(str: string, encoding?: string, cb?: Function): boolean;
+            write(str: string, encoding?: string, fd?: string): boolean;
+
+            write(chunk: any, encoding?: string): void;
+            abort(): void;
+            setTimeout(timeout: number, callback?: Function): void;
+            setNoDelay(noDelay?: Function): void;
+            setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
+
+            // Extended base methods
+            end(): void;
+            end(buffer: NodeBuffer, cb?: Function): void;
+            end(str: string, cb?: Function): void;
+            end(str: string, encoding?: string, cb?: Function): void;
+            end(data?: any, encoding?: string): void;
+        }
+        export interface ClientResponse extends NodeEventEmitter, ReadableStream {
+            statusCode: number;
+            httpVersion: string;
+            headers: any;
+            trailers: any;
+            setEncoding(encoding?: string): void;
+            pause(): void;
+            resume(): void;
+        }
+        export interface Agent { maxSockets: number; sockets: any; requests: any; }
+    }
+
+    // "cluster" module
+    export interface Cluster {
+        settings: Cluster.ClusterSettings;
+        isMaster: boolean;
+        isWorker: boolean;
+        setupMaster(settings?: Cluster.ClusterSettings): void;
+        fork(env?: any): Worker;
+        disconnect(callback?: Function): void;
+        worker: Worker;
+        workers: Worker[];
+
+        // Event emitter
+        addListener(event: string, listener: Function): void;
+        on(event: string, listener: Function): any;
+        once(event: string, listener: Function): void;
+        removeListener(event: string, listener: Function): void;
+        removeAllListeners(event?: string): void;
         setMaxListeners(n: number): void;
         listeners(event: string): Function[];
         emit(event: string, ...args: any[]): boolean;
-   }
-}
-
-declare module "http" { export = NodeHttp; }
-declare module NodeHttp {
-
-    export interface Server extends NodeEventEmitter {
-        listen(port: number, hostname?: string, backlog?: number, callback?: Function): void;
-        listen(path: string, callback?: Function): void;
-        listen(handle: any, listeningListener?: Function): void;
-        close(cb?: any): void;
-        maxHeadersCount: number;
     }
-    export interface ServerRequest extends NodeEventEmitter, ReadableStream {
-        method: string;
-        url: string;
-        headers: any;
-        trailers: string;
-        httpVersion: string;
-        setEncoding(encoding?: string): void;
-        pause(): void;
-        resume(): void;
-        connection: NodeNet.Socket;
-    }
-    export interface ServerResponse extends NodeEventEmitter, WritableStream {
-        // Extended base methods
-        write(buffer: NodeBuffer): boolean;
-        write(buffer: NodeBuffer, cb?: Function): boolean;
-        write(str: string, cb?: Function): boolean;
-        write(str: string, encoding?: string, cb?: Function): boolean;
-        write(str: string, encoding?: string, fd?: string): boolean;
+    export module Cluster {
 
-        writeContinue(): void;
-        writeHead(statusCode: number, reasonPhrase?: string, headers?: any): void;
-        writeHead(statusCode: number, headers?: any): void;
-        statusCode: number;
-        setHeader(name: string, value: string): void;
-        sendDate: boolean;
-        getHeader(name: string): string;
-        removeHeader(name: string): void;
-        write(chunk: any, encoding?: string): any;
-        addTrailers(headers: any): void;
+        export interface ClusterSettings {
+            exec?: string;
+            args?: string[];
+            silent?: boolean;
+        }
 
-        // Extended base methods
-        end(): void;
-        end(buffer: NodeBuffer, cb?: Function): void;
-        end(str: string, cb?: Function): void;
-        end(str: string, encoding?: string, cb?: Function): void;
-        end(data?: any, encoding?: string): void;
-    }
-    export interface ClientRequest extends NodeEventEmitter, WritableStream {
-        // Extended base methods
-        write(buffer: NodeBuffer): boolean;
-        write(buffer: NodeBuffer, cb?: Function): boolean;
-        write(str: string, cb?: Function): boolean;
-        write(str: string, encoding?: string, cb?: Function): boolean;
-        write(str: string, encoding?: string, fd?: string): boolean;
-
-        write(chunk: any, encoding?: string): void;
-        abort(): void;
-        setTimeout(timeout: number, callback?: Function): void;
-        setNoDelay(noDelay?: Function): void;
-        setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
-
-        // Extended base methods
-        end(): void;
-        end(buffer: NodeBuffer, cb?: Function): void;
-        end(str: string, cb?: Function): void;
-        end(str: string, encoding?: string, cb?: Function): void;
-        end(data?: any, encoding?: string): void;
-    }
-    export interface ClientResponse extends NodeEventEmitter, ReadableStream {
-        statusCode: number;
-        httpVersion: string;
-        headers: any;
-        trailers: any;
-        setEncoding(encoding?: string): void;
-        pause(): void;
-        resume(): void;
-    }
-    export interface Agent { maxSockets: number; sockets: any; requests: any; }
-
-    export var STATUS_CODES: any;
-    export function createServer(requestListener?: (request: ServerRequest, response: ServerResponse) =>void ): Server;
-    export function createClient(port?: number, host?: string): any;
-    export function request(options: any, callback?: Function): ClientRequest;
-    export function get(options: any, callback?: Function): ClientRequest;
-    export var globalAgent: Agent;
-}
-
-declare module "cluster" { export = NodeCluster; }
-declare module NodeCluster {
-
-    export interface ClusterSettings {
-        exec?: string;
-        args?: string[];
-        silent?: boolean;
+        export interface Worker extends Events.EventEmitter {
+            id: string;
+            process: ChildProcess.ChildProcess;
+            suicide: boolean;
+            send(message: any, sendHandle?: any): void;
+            kill(signal?: string): void;
+            destroy(signal?: string): void;
+            disconnect(): void;
+        }
     }
 
-    export class Worker extends NodeEvents.EventEmitter {
-        id: string;
-        process: NodeChildProcess.ChildProcess;
-        suicide: boolean;
-        send(message: any, sendHandle?: any): void;
-        kill(signal?: string): void;
-        destroy(signal?: string): void;
-        disconnect(): void;
+    // "zlib" module
+    export interface Zlib {
+        createGzip(options?: Zlib.ZlibOptions): Zlib.Gzip;
+        createGunzip(options?: Zlib.ZlibOptions): Zlib.Gunzip;
+        createDeflate(options?: Zlib.ZlibOptions): Zlib.Deflate;
+        createInflate(options?: Zlib.ZlibOptions): Zlib.Inflate;
+        createDeflateRaw(options?: Zlib.ZlibOptions): Zlib.DeflateRaw;
+        createInflateRaw(options?: Zlib.ZlibOptions): Zlib.InflateRaw;
+        createUnzip(options?: Zlib.ZlibOptions): Zlib.Unzip;
+
+        deflate(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+        deflateRaw(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+        gzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+        gunzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+        inflate(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+        inflateRaw(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+        unzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+
+        // Constants
+        Z_NO_FLUSH: number;
+        Z_PARTIAL_FLUSH: number;
+        Z_SYNC_FLUSH: number;
+        Z_FULL_FLUSH: number;
+        Z_FINISH: number;
+        Z_BLOCK: number;
+        Z_TREES: number;
+        Z_OK: number;
+        Z_STREAM_END: number;
+        Z_NEED_DICT: number;
+        Z_ERRNO: number;
+        Z_STREAM_ERROR: number;
+        Z_DATA_ERROR: number;
+        Z_MEM_ERROR: number;
+        Z_BUF_ERROR: number;
+        Z_VERSION_ERROR: number;
+        Z_NO_COMPRESSION: number;
+        Z_BEST_SPEED: number;
+        Z_BEST_COMPRESSION: number;
+        Z_DEFAULT_COMPRESSION: number;
+        Z_FILTERED: number;
+        Z_HUFFMAN_ONLY: number;
+        Z_RLE: number;
+        Z_FIXED: number;
+        Z_DEFAULT_STRATEGY: number;
+        Z_BINARY: number;
+        Z_TEXT: number;
+        Z_ASCII: number;
+        Z_UNKNOWN: number;
+        Z_DEFLATED: number;
+        Z_NULL: number;
+    }
+    export module Zlib {
+
+        export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; }
+
+        export interface Gzip extends ReadWriteStream { }
+        export interface Gunzip extends ReadWriteStream { }
+        export interface Deflate extends ReadWriteStream { }
+        export interface Inflate extends ReadWriteStream { }
+        export interface DeflateRaw extends ReadWriteStream { }
+        export interface InflateRaw extends ReadWriteStream { }
+        export interface Unzip extends ReadWriteStream { }
     }
 
-    export var settings: ClusterSettings;
-    export var isMaster: boolean;
-    export var isWorker: boolean;
-    export function setupMaster(settings?: ClusterSettings): void;
-    export function fork(env?: any): Worker;
-    export function disconnect(callback?: Function): void;
-    export var worker: Worker;
-    export var workers: Worker[];
-
-    // Event emitter
-    export function addListener(event: string, listener: Function): void;
-    export function on(event: string, listener: Function): any;
-    export function once(event: string, listener: Function): void;
-    export function removeListener(event: string, listener: Function): void;
-    export function removeAllListeners(event?: string): void;
-    export function setMaxListeners(n: number): void;
-    export function listeners(event: string): Function[];
-    export function emit(event: string, ...args: any[]): boolean;
-}
-
-declare module "zlib" { export = NodeZlib; }
-declare module NodeZlib {
-
-    export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; }
-
-    export interface Gzip extends ReadWriteStream { }
-    export interface Gunzip extends ReadWriteStream { }
-    export interface Deflate extends ReadWriteStream { }
-    export interface Inflate extends ReadWriteStream { }
-    export interface DeflateRaw extends ReadWriteStream { }
-    export interface InflateRaw extends ReadWriteStream { }
-    export interface Unzip extends ReadWriteStream { }
-
-    export function createGzip(options?: ZlibOptions): Gzip;
-    export function createGunzip(options?: ZlibOptions): Gunzip;
-    export function createDeflate(options?: ZlibOptions): Deflate;
-    export function createInflate(options?: ZlibOptions): Inflate;
-    export function createDeflateRaw(options?: ZlibOptions): DeflateRaw;
-    export function createInflateRaw(options?: ZlibOptions): InflateRaw;
-    export function createUnzip(options?: ZlibOptions): Unzip;
-
-    export function deflate(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-    export function deflateRaw(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-    export function gzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-    export function gunzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-    export function inflate(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-    export function inflateRaw(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-    export function unzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-
-    // Constants
-    export var Z_NO_FLUSH: number;
-    export var Z_PARTIAL_FLUSH: number;
-    export var Z_SYNC_FLUSH: number;
-    export var Z_FULL_FLUSH: number;
-    export var Z_FINISH: number;
-    export var Z_BLOCK: number;
-    export var Z_TREES: number;
-    export var Z_OK: number;
-    export var Z_STREAM_END: number;
-    export var Z_NEED_DICT: number;
-    export var Z_ERRNO: number;
-    export var Z_STREAM_ERROR: number;
-    export var Z_DATA_ERROR: number;
-    export var Z_MEM_ERROR: number;
-    export var Z_BUF_ERROR: number;
-    export var Z_VERSION_ERROR: number;
-    export var Z_NO_COMPRESSION: number;
-    export var Z_BEST_SPEED: number;
-    export var Z_BEST_COMPRESSION: number;
-    export var Z_DEFAULT_COMPRESSION: number;
-    export var Z_FILTERED: number;
-    export var Z_HUFFMAN_ONLY: number;
-    export var Z_RLE: number;
-    export var Z_FIXED: number;
-    export var Z_DEFAULT_STRATEGY: number;
-    export var Z_BINARY: number;
-    export var Z_TEXT: number;
-    export var Z_ASCII: number;
-    export var Z_UNKNOWN: number;
-    export var Z_DEFLATED: number;
-    export var Z_NULL: number;
-}
-
-declare module "os" { export = NodeOs; }
-declare module NodeOs {
-    export function tmpDir(): string;
-    export function hostname(): string;
-    export function type(): string;
-    export function platform(): string;
-    export function arch(): string;
-    export function release(): string;
-    export function uptime(): number;
-    export function loadavg(): number[];
-    export function totalmem(): number;
-    export function freemem(): number;
-    export function cpus(): { model: string; speed: number; times: { user: number; nice: number; sys: number; idle: number; irq: number; }; }[];
-    export function networkInterfaces(): any;
-    export var EOL: string;
-}
-
-declare module "https" { export = NodeHttps; }
-declare module NodeHttps {
-
-    export interface ServerOptions {
-        pfx?: any;
-        key?: any;
-        passphrase?: string;
-        cert?: any;
-        ca?: any;
-        crl?: any;
-        ciphers?: string;
-        honorCipherOrder?: boolean;
-        requestCert?: boolean;
-        rejectUnauthorized?: boolean;
-        NPNProtocols?: any;
-        SNICallback?: (servername: string) => any;
+    // "os" module
+    export interface Os {
+        tmpDir(): string;
+        hostname(): string;
+        type(): string;
+        platform(): string;
+        arch(): string;
+        release(): string;
+        uptime(): number;
+        loadavg(): number[];
+        totalmem(): number;
+        freemem(): number;
+        cpus(): { model: string; speed: number; times: { user: number; nice: number; sys: number; idle: number; irq: number; }; }[];
+        networkInterfaces(): any;
+        EOL: string;
     }
 
-    export interface RequestOptions {
-        host?: string;
-        hostname?: string;
-        port?: number;
-        path?: string;
-        method?: string;
-        headers?: any;
-        auth?: string;
-        agent?: any;
-        pfx?: any;
-        key?: any;
-        passphrase?: string;
-        cert?: any;
-        ca?: any;
-        ciphers?: string;
-        rejectUnauthorized?: boolean;
+    // "https" module
+    export interface Https {
+        Agent: new(options?: Https.RequestOptions) => Https.Agent;
+
+        createServer(options: Https.ServerOptions, requestListener?: Function): Https.Server;
+        request(options: Https.RequestOptions, callback?: (res: NodeEventEmitter) => void): Http.ClientRequest;
+        get(options: Https.RequestOptions, callback?: (res: NodeEventEmitter) => void): Http.ClientRequest;
+        globalAgent: Https.Agent;
+    }
+    export module Https {
+
+        export interface ServerOptions {
+            pfx?: any;
+            key?: any;
+            passphrase?: string;
+            cert?: any;
+            ca?: any;
+            crl?: any;
+            ciphers?: string;
+            honorCipherOrder?: boolean;
+            requestCert?: boolean;
+            rejectUnauthorized?: boolean;
+            NPNProtocols?: any;
+            SNICallback?: (servername: string) => any;
+        }
+
+        export interface RequestOptions {
+            host?: string;
+            hostname?: string;
+            port?: number;
+            path?: string;
+            method?: string;
+            headers?: any;
+            auth?: string;
+            agent?: any;
+            pfx?: any;
+            key?: any;
+            passphrase?: string;
+            cert?: any;
+            ca?: any;
+            ciphers?: string;
+            rejectUnauthorized?: boolean;
+        }
+
+        export interface Agent {
+            maxSockets: number;
+            sockets: any;
+            requests: any;
+        }
+        export interface Server extends Tls.Server { }
     }
 
-    export interface Agent {
-        maxSockets: number;
-        sockets: any;
-        requests: any;
-    }
-    export var Agent: {
-        new (options?: RequestOptions): Agent;
-    };
-    export interface Server extends NodeTls.Server { }
-    export function createServer(options: ServerOptions, requestListener?: Function): Server;
-    export function request(options: RequestOptions, callback?: (res: NodeEventEmitter) => void): NodeHttp.ClientRequest;
-    export function get(options: RequestOptions, callback?: (res: NodeEventEmitter) => void): NodeHttp.ClientRequest;
-    export var globalAgent: Agent;
-}
-
-declare module "punycode" { export = NodePunyCode; }
-declare module NodePunyCode {
-    export function decode(string: string): string;
-    export function encode(string: string): string;
-    export function toUnicode(domain: string): string;
-    export function toASCII(domain: string): string;
-    export var ucs2: ucs2;
-    interface ucs2 {
+    // "punycode" module
+    export interface PunyCode {
         decode(string: string): string;
-        encode(codePoints: number[]): string;
-    }
-    export var version: any;
-}
-
-declare module "repl" { export = NodeRepl; }
-declare module NodeRepl {
-
-    export interface ReplOptions {
-        prompt?: string;
-        input?: ReadableStream;
-        output?: WritableStream;
-        terminal?: boolean;
-        eval?: Function;
-        useColors?: boolean;
-        useGlobal?: boolean;
-        ignoreUndefined?: boolean;
-        writer?: Function;
-    }
-    export function start(options: ReplOptions): NodeEventEmitter;
-}
-
-declare module "readline" { export = NodeReadLine; }
-declare module NodeReadLine {
-
-    export interface ReadLine extends NodeEventEmitter {
-        setPrompt(prompt: string, length: number): void;
-        prompt(preserveCursor?: boolean): void;
-        question(query: string, callback: Function): void;
-        pause(): void;
-        resume(): void;
-        close(): void;
-        write(data: any, key?: any): void;
-    }
-    export interface ReadLineOptions {
-        input: ReadableStream;
-        output: WritableStream;
-        completer?: Function;
-        terminal?: boolean;
-    }
-    export function createInterface(options: ReadLineOptions): ReadLine;
-}
-
-declare module "vm" { export = NodeVm; }
-declare module NodeVm {
-    export interface Context { }
-    export interface Script {
-        runInThisContext(): void;
-        runInNewContext(sandbox?: Context): void;
-    }
-    export function runInThisContext(code: string, filename?: string): void;
-    export function runInNewContext(code: string, sandbox?: Context, filename?: string): void;
-    export function runInContext(code: string, context: Context, filename?: string): void;
-    export function createContext(initSandbox?: Context): Context;
-    export function createScript(code: string, filename?: string): Script;
-}
-
-declare module "child_process" { export = NodeChildProcess; }
-declare module NodeChildProcess {
-
-    export interface ChildProcess extends NodeEventEmitter {
-        stdin: WritableStream;
-        stdout: ReadableStream;
-        stderr: ReadableStream;
-        pid: number;
-        kill(signal?: string): void;
-        send(message: any, sendHandle: any): void;
-        disconnect(): void;
+        encode(string: string): string;
+        toUnicode(domain: string): string;
+        toASCII(domain: string): string;
+        ucs2: {
+            decode(string: string): string;
+            encode(codePoints: number[]): string;
+        }
+        version: any;
     }
 
-    export function spawn(command: string, args?: string[], options?: {
-        cwd?: string;
-        stdio?: any;
-        custom?: any;
-        env?: any;
-        detached?: boolean;
-    }): ChildProcess;
-    export function exec(command: string, options: {
-        cwd?: string;
-        stdio?: any;
-        customFds?: any;
-        env?: any;
-        encoding?: string;
-        timeout?: number;
-        maxBuffer?: number;
-        killSignal?: string;
-    }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
-    export function exec(command: string, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
-    export function execFile(file: string, args: string[], options: {
-        cwd?: string;
-        stdio?: any;
-        customFds?: any;
-        env?: any;
-        encoding?: string;
-        timeout?: number;
-        maxBuffer?: string;
-        killSignal?: string;
-    }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
-    export function fork(modulePath: string, args?: string[], options?: {
-        cwd?: string;
-        env?: any;
-        encoding?: string;
-    }): ChildProcess;
-}
+    // "repl" module
+    export interface Repl {
+        start(options: Repl.ReplOptions): NodeEventEmitter;
+    }
+    export module Repl {
 
-declare module "url" { export = NodeUrl; }
-declare module NodeUrl {
+        export interface ReplOptions {
+            prompt?: string;
+            input?: ReadableStream;
+            output?: WritableStream;
+            terminal?: boolean;
+            eval?: Function;
+            useColors?: boolean;
+            useGlobal?: boolean;
+            ignoreUndefined?: boolean;
+            writer?: Function;
+        }
+    }
+
+    // "readline" module
+    export interface ReadLine {
+        createInterface(options: ReadLine.ReadLineOptions): ReadLine.ReadLine;
+    }
+    export module ReadLine {
+
+        export interface ReadLine extends NodeEventEmitter {
+            setPrompt(prompt: string, length: number): void;
+            prompt(preserveCursor?: boolean): void;
+            question(query: string, callback: Function): void;
+            pause(): void;
+            resume(): void;
+            close(): void;
+            write(data: any, key?: any): void;
+        }
+        export interface ReadLineOptions {
+            input: ReadableStream;
+            output: WritableStream;
+            completer?: Function;
+            terminal?: boolean;
+        }
+    }
+
+    // "vm" module
+    export interface Vm {
+        runInThisContext(code: string, filename?: string): void;
+        runInNewContext(code: string, sandbox?: Vm.Context, filename?: string): void;
+        runInContext(code: string, context: Vm.Context, filename?: string): void;
+        createContext(initSandbox?: Vm.Context): Vm.Context;
+        createScript(code: string, filename?: string): Vm.Script;
+    }
+    export module Vm {
+        export interface Context { }
+        export interface Script {
+            runInThisContext(): void;
+            runInNewContext(sandbox?: Context): void;
+        }
+    }
+
+    // "child_process" module
+    export interface ChildProcess {
+        spawn(command: string, args?: string[], options?: {
+            cwd?: string;
+            stdio?: any;
+            custom?: any;
+            env?: any;
+            detached?: boolean;
+        }): ChildProcess.ChildProcess;
+        exec(command: string, options: {
+            cwd?: string;
+            stdio?: any;
+            customFds?: any;
+            env?: any;
+            encoding?: string;
+            timeout?: number;
+            maxBuffer?: number;
+            killSignal?: string;
+        }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess.ChildProcess;
+        exec(command: string, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess.ChildProcess;
+        execFile(file: string, args: string[], options: {
+            cwd?: string;
+            stdio?: any;
+            customFds?: any;
+            env?: any;
+            encoding?: string;
+            timeout?: number;
+            maxBuffer?: string;
+            killSignal?: string;
+        }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess.ChildProcess;
+        fork(modulePath: string, args?: string[], options?: {
+            cwd?: string;
+            env?: any;
+            encoding?: string;
+        }): ChildProcess.ChildProcess;
+    }
+    export module ChildProcess {
+
+        export interface ChildProcess extends NodeEventEmitter {
+            stdin: WritableStream;
+            stdout: ReadableStream;
+            stderr: ReadableStream;
+            pid: number;
+            kill(signal?: string): void;
+            send(message: any, sendHandle: any): void;
+            disconnect(): void;
+        }
+    }
+
+    // "url" module
     export interface Url {
-        href: string;
-        protocol: string;
-        auth: string;
-        hostname: string;
-        port: string;
-        host: string;
-        pathname: string;
-        search: string;
-        query: string;
-        slashes: boolean;
+        parse(urlStr: string, parseQueryString?: boolean , slashesDenoteHost?: boolean ): Url.Url;
+        format(url: Url.UrlOptions): string;
+        resolve(from: string, to: string): string;
+    }
+    export module Url {
+        export interface Url {
+            href: string;
+            protocol: string;
+            auth: string;
+            hostname: string;
+            port: string;
+            host: string;
+            pathname: string;
+            search: string;
+            query: string;
+            slashes: boolean;
+        }
+
+        export interface UrlOptions {
+            protocol?: string;
+            auth?: string;
+            hostname?: string;
+            port?: string;
+            host?: string;
+            pathname?: string;
+            search?: string;
+            query?: any;
+        }
     }
 
-    export interface UrlOptions {
-        protocol?: string;
-        auth?: string;
-        hostname?: string;
-        port?: string;
-        host?: string;
-        pathname?: string;
-        search?: string;
-        query?: any;
+    // "dns" module
+    export interface Dns {
+        lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string;
+        lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string;
+        resolve(domain: string, rrtype: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+        resolve(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+        resolve4(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+        resolve6(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+        resolveMx(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+        resolveTxt(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+        resolveSrv(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+        resolveNs(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+        resolveCname(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+        reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[];
     }
 
-    export function parse(urlStr: string, parseQueryString?: boolean , slashesDenoteHost?: boolean ): Url;
-    export function format(url: UrlOptions): string;
-    export function resolve(from: string, to: string): string;
-}
+    // "net" module
+    export interface Net {
+        Socket: new(options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }) => Net.Socket;
 
-declare module "dns" { export = NodeDns; }
-declare module NodeDns {
-    export function lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string;
-    export function lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string;
-    export function resolve(domain: string, rrtype: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-    export function resolve(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-    export function resolve4(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-    export function resolve6(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-    export function resolveMx(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-    export function resolveTxt(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-    export function resolveSrv(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-    export function resolveNs(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-    export function resolveCname(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-    export function reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[];
-}
+        createServer(connectionListener?: (socket: Net.Socket) =>void ): Net.Server;
+        createServer(options?: { allowHalfOpen?: boolean; }, connectionListener?: (socket: Net.Socket) =>void ): Net.Server;
+        connect(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): Net.Socket;
+        connect(port: number, host?: string, connectionListener?: Function): Net.Socket;
+        connect(path: string, connectionListener?: Function): Net.Socket;
+        createConnection(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): Net.Socket;
+        createConnection(port: number, host?: string, connectionListener?: Function): Net.Socket;
+        createConnection(path: string, connectionListener?: Function): Net.Socket;
+        isIP(input: string): number;
+        isIPv4(input: string): boolean;
+        isIPv6(input: string): boolean;
+    }
+    export module Net {
 
-declare module "net" { export = NodeNet; }
-declare module NodeNet {
+        export interface Socket extends ReadWriteStream {
+            // Extended base methods
+            write(buffer: NodeBuffer): boolean;
+            write(buffer: NodeBuffer, cb?: Function): boolean;
+            write(str: string, cb?: Function): boolean;
+            write(str: string, encoding?: string, cb?: Function): boolean;
+            write(str: string, encoding?: string, fd?: string): boolean;
 
-    export interface Socket extends ReadWriteStream {
-        // Extended base methods
-        write(buffer: NodeBuffer): boolean;
-        write(buffer: NodeBuffer, cb?: Function): boolean;
-        write(str: string, cb?: Function): boolean;
-        write(str: string, encoding?: string, cb?: Function): boolean;
-        write(str: string, encoding?: string, fd?: string): boolean;
+            connect(port: number, host?: string, connectionListener?: Function): void;
+            connect(path: string, connectionListener?: Function): void;
+            bufferSize: number;
+            setEncoding(encoding?: string): void;
+            write(data: any, encoding?: string, callback?: Function): void;
+            destroy(): void;
+            pause(): void;
+            resume(): void;
+            setTimeout(timeout: number, callback?: Function): void;
+            setNoDelay(noDelay?: boolean): void;
+            setKeepAlive(enable?: boolean, initialDelay?: number): void;
+            address(): { port: number; family: string; address: string; };
+            remoteAddress: string;
+            remotePort: number;
+            bytesRead: number;
+            bytesWritten: number;
 
-        connect(port: number, host?: string, connectionListener?: Function): void;
-        connect(path: string, connectionListener?: Function): void;
-        bufferSize: number;
-        setEncoding(encoding?: string): void;
-        write(data: any, encoding?: string, callback?: Function): void;
-        destroy(): void;
-        pause(): void;
-        resume(): void;
-        setTimeout(timeout: number, callback?: Function): void;
-        setNoDelay(noDelay?: boolean): void;
-        setKeepAlive(enable?: boolean, initialDelay?: number): void;
-        address(): { port: number; family: string; address: string; };
-        remoteAddress: string;
-        remotePort: number;
-        bytesRead: number;
-        bytesWritten: number;
+            // Extended base methods
+            end(): void;
+            end(buffer: NodeBuffer, cb?: Function): void;
+            end(str: string, cb?: Function): void;
+            end(str: string, encoding?: string, cb?: Function): void;
+            end(data?: any, encoding?: string): void;
+        }
 
-        // Extended base methods
-        end(): void;
-        end(buffer: NodeBuffer, cb?: Function): void;
-        end(str: string, cb?: Function): void;
-        end(str: string, encoding?: string, cb?: Function): void;
-        end(data?: any, encoding?: string): void;
+        export interface Server extends Socket {
+            listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
+            listen(path: string, listeningListener?: Function): void;
+            listen(handle: any, listeningListener?: Function): void;
+            close(callback?: Function): void;
+            address(): { port: number; family: string; address: string; };
+            maxConnections: number;
+            connections: number;
+        }
     }
 
-    export var Socket: {
-        new (options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }): Socket;
-    };
-
-    export interface Server extends Socket {
-        listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
-        listen(path: string, listeningListener?: Function): void;
-        listen(handle: any, listeningListener?: Function): void;
-        close(callback?: Function): void;
-        address(): { port: number; family: string; address: string; };
-        maxConnections: number;
-        connections: number;
+    // "dgram" module
+    export interface Dgram {
+        createSocket(type: string, callback?: Function): Dgram.Socket;
     }
-    export function createServer(connectionListener?: (socket: Socket) =>void ): Server;
-    export function createServer(options?: { allowHalfOpen?: boolean; }, connectionListener?: (socket: Socket) =>void ): Server;
-    export function connect(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): Socket;
-    export function connect(port: number, host?: string, connectionListener?: Function): Socket;
-    export function connect(path: string, connectionListener?: Function): Socket;
-    export function createConnection(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): Socket;
-    export function createConnection(port: number, host?: string, connectionListener?: Function): Socket;
-    export function createConnection(path: string, connectionListener?: Function): Socket;
-    export function isIP(input: string): number;
-    export function isIPv4(input: string): boolean;
-    export function isIPv6(input: string): boolean;
-}
+    export module Dgram {
 
-declare module "dgram" { export = NodeDgram; }
-declare module NodeDgram {
-
-    export function createSocket(type: string, callback?: Function): Socket;
-
-    interface Socket extends NodeEventEmitter {
-        send(buf: NodeBuffer, offset: number, length: number, port: number, address: string, callback?: Function): void;
-        bind(port: number, address?: string): void;
-        close(): void;
-        address: { address: string; family: string; port: number; };
-        setBroadcast(flag: boolean): void;
-        setMulticastTTL(ttl: number): void;
-        setMulticastLoopback(flag: boolean): void;
-        addMembership(multicastAddress: string, multicastInterface?: string): void;
-        dropMembership(multicastAddress: string, multicastInterface?: string): void;
-    }
-}
-
-declare module "fs" { export = NodeFs; }
-declare module NodeFs {
-
-    interface Stats {
-        isFile(): boolean;
-        isDirectory(): boolean;
-        isBlockDevice(): boolean;
-        isCharacterDevice(): boolean;
-        isSymbolicLink(): boolean;
-        isFIFO(): boolean;
-        isSocket(): boolean;
-        dev: number;
-        ino: number;
-        mode: number;
-        nlink: number;
-        uid: number;
-        gid: number;
-        rdev: number;
-        size: number;
-        blksize: number;
-        blocks: number;
-        atime: Date;
-        mtime: Date;
-        ctime: Date;
+        interface Socket extends NodeEventEmitter {
+            send(buf: NodeBuffer, offset: number, length: number, port: number, address: string, callback?: Function): void;
+            bind(port: number, address?: string): void;
+            close(): void;
+            address: { address: string; family: string; port: number; };
+            setBroadcast(flag: boolean): void;
+            setMulticastTTL(ttl: number): void;
+            setMulticastLoopback(flag: boolean): void;
+            addMembership(multicastAddress: string, multicastInterface?: string): void;
+            dropMembership(multicastAddress: string, multicastInterface?: string): void;
+        }
     }
 
-    interface FSWatcher extends NodeEventEmitter {
-        close(): void;
+    // "fs" module
+    export interface Fs {
+        rename(oldPath: string, newPath: string, callback?: (err?: ErrnoException) => void): void;
+        renameSync(oldPath: string, newPath: string): void;
+        truncate(path: string, callback?: (err?: ErrnoException) => void): void;
+        truncate(path: string, len: number, callback?: (err?: ErrnoException) => void): void;
+        truncateSync(path: string, len?: number): void;
+        ftruncate(fd: number, callback?: (err?: ErrnoException) => void): void;
+        ftruncate(fd: number, len: number, callback?: (err?: ErrnoException) => void): void;
+        ftruncateSync(fd: number, len?: number): void;
+        chown(path: string, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
+        chownSync(path: string, uid: number, gid: number): void;
+        fchown(fd: number, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
+        fchownSync(fd: number, uid: number, gid: number): void;
+        lchown(path: string, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
+        lchownSync(path: string, uid: number, gid: number): void;
+        chmod(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
+        chmod(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
+        chmodSync(path: string, mode: number): void;
+        chmodSync(path: string, mode: string): void;
+        fchmod(fd: number, mode: number, callback?: (err?: ErrnoException) => void): void;
+        fchmod(fd: number, mode: string, callback?: (err?: ErrnoException) => void): void;
+        fchmodSync(fd: number, mode: number): void;
+        fchmodSync(fd: number, mode: string): void;
+        lchmod(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
+        lchmod(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
+        lchmodSync(path: string, mode: number): void;
+        lchmodSync(path: string, mode: string): void;
+        stat(path: string, callback?: (err: ErrnoException, stats: Fs.Stats) => any): void;
+        lstat(path: string, callback?: (err: ErrnoException, stats: Fs.Stats) => any): void;
+        fstat(fd: number, callback?: (err: ErrnoException, stats: Fs.Stats) => any): void;
+        statSync(path: string): Fs.Stats;
+        lstatSync(path: string): Fs.Stats;
+        fstatSync(fd: number): Fs.Stats;
+        link(srcpath: string, dstpath: string, callback?: (err?: ErrnoException) => void): void;
+        linkSync(srcpath: string, dstpath: string): void;
+        symlink(srcpath: string, dstpath: string, type?: string, callback?: (err?: ErrnoException) => void): void;
+        symlinkSync(srcpath: string, dstpath: string, type?: string): void;
+        readlink(path: string, callback?: (err: ErrnoException, linkString: string) => any): void;
+        readlinkSync(path: string): string;
+        realpath(path: string, callback?: (err: ErrnoException, resolvedPath: string) => any): void;
+        realpath(path: string, cache: {[path: string]: string}, callback: (err: ErrnoException, resolvedPath: string) =>any): void;
+        realpathSync(path: string, cache?: {[path: string]: string}): void;
+        unlink(path: string, callback?: (err?: ErrnoException) => void): void;
+        unlinkSync(path: string): void;
+        rmdir(path: string, callback?: (err?: ErrnoException) => void): void;
+        rmdirSync(path: string): void;
+        mkdir(path: string, callback?: (err?: ErrnoException) => void): void;
+        mkdir(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
+        mkdir(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
+        mkdirSync(path: string, mode?: number): void;
+        mkdirSync(path: string, mode?: string): void;
+        readdir(path: string, callback?: (err: ErrnoException, files: string[]) => void): void;
+        readdirSync(path: string): string[];
+        close(fd: number, callback?: (err?: ErrnoException) => void): void;
+        closeSync(fd: number): void;
+        open(path: string, flags: string, callback?: (err: ErrnoException, fd: number) => any): void;
+        open(path: string, flags: string, mode: number, callback?: (err: ErrnoException, fd: number) => any): void;
+        open(path: string, flags: string, mode: string, callback?: (err: ErrnoException, fd: number) => any): void;
+        openSync(path: string, flags: string, mode?: number): number;
+        openSync(path: string, flags: string, mode?: string): number;
+        utimes(path: string, atime: number, mtime: number, callback?: (err?: ErrnoException) => void): void;
+        utimesSync(path: string, atime: number, mtime: number): void;
+        futimes(fd: number, atime: number, mtime: number, callback?: (err?: ErrnoException) => void): void;
+        futimesSync(fd: number, atime: number, mtime: number): void;
+        fsync(fd: number, callback?: (err?: ErrnoException) => void): void;
+        fsyncSync(fd: number): void;
+        write(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, written: number, buffer: NodeBuffer) => void): void;
+        writeSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
+        read(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, bytesRead: number, buffer: NodeBuffer) => void): void;
+        readSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
+        readFile(filename: string, encoding: string, callback: (err: ErrnoException, data: string) => void): void;
+        readFile(filename: string, options: { encoding: string; flag?: string; }, callback: (err: ErrnoException, data: string) => void): void;
+        readFile(filename: string, options: { flag?: string; }, callback: (err: ErrnoException, data: NodeBuffer) => void): void;
+        readFile(filename: string, callback: (err: ErrnoException, data: NodeBuffer) => void ): void;
+        readFileSync(filename: string, encoding: string): string;
+        readFileSync(filename: string, options: { encoding: string; flag?: string; }): string;
+        readFileSync(filename: string, options?: { flag?: string; }): NodeBuffer;
+        writeFile(filename: string, data: any, callback?: (err: ErrnoException) => void): void;
+        writeFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: ErrnoException) => void): void;
+        writeFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void;
+        writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
+        writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void;
+        appendFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: ErrnoException) => void): void;
+        appendFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void;
+        appendFile(filename: string, data: any, callback?: (err: ErrnoException) => void): void;
+        appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
+        appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void;
+        watchFile(filename: string, listener: (curr: Fs.Stats, prev: Fs.Stats) => void): void;
+        watchFile(filename: string, options: { persistent?: boolean; interval?: number; }, listener: (curr: Fs.Stats, prev: Fs.Stats) => void): void;
+        unwatchFile(filename: string, listener?: (curr: Fs.Stats, prev: Fs.Stats) => void): void;
+        watch(filename: string, listener?: (event: string, filename: string) => any): Fs.FSWatcher;
+        watch(filename: string, options: { persistent?: boolean; }, listener?: (event: string, filename: string) => any): Fs.FSWatcher;
+        exists(path: string, callback?: (exists: boolean) => void): void;
+        existsSync(path: string): boolean;
+        createReadStream(path: string, options?: {
+            flags?: string;
+            encoding?: string;
+            fd?: string;
+            mode?: number;
+            bufferSize?: number;
+        }): Fs.ReadStream;
+        createReadStream(path: string, options?: {
+            flags?: string;
+            encoding?: string;
+            fd?: string;
+            mode?: string;
+            bufferSize?: number;
+        }): Fs.ReadStream;
+        createWriteStream(path: string, options?: {
+            flags?: string;
+            encoding?: string;
+            string?: string;
+        }): Fs.WriteStream;
+    }
+    export module Fs {
+
+        export interface Stats {
+            isFile(): boolean;
+            isDirectory(): boolean;
+            isBlockDevice(): boolean;
+            isCharacterDevice(): boolean;
+            isSymbolicLink(): boolean;
+            isFIFO(): boolean;
+            isSocket(): boolean;
+            dev: number;
+            ino: number;
+            mode: number;
+            nlink: number;
+            uid: number;
+            gid: number;
+            rdev: number;
+            size: number;
+            blksize: number;
+            blocks: number;
+            atime: Date;
+            mtime: Date;
+            ctime: Date;
+        }
+
+        export interface FSWatcher extends NodeEventEmitter {
+            close(): void;
+        }
+
+        export interface ReadStream extends ReadableStream { }
+        export interface WriteStream extends WritableStream { }
     }
 
-    export interface ReadStream extends ReadableStream { }
-    export interface WriteStream extends WritableStream { }
-
-    export function rename(oldPath: string, newPath: string, callback?: (err?: ErrnoException) => void): void;
-    export function renameSync(oldPath: string, newPath: string): void;
-    export function truncate(path: string, callback?: (err?: ErrnoException) => void): void;
-    export function truncate(path: string, len: number, callback?: (err?: ErrnoException) => void): void;
-    export function truncateSync(path: string, len?: number): void;
-    export function ftruncate(fd: number, callback?: (err?: ErrnoException) => void): void;
-    export function ftruncate(fd: number, len: number, callback?: (err?: ErrnoException) => void): void;
-    export function ftruncateSync(fd: number, len?: number): void;
-    export function chown(path: string, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
-    export function chownSync(path: string, uid: number, gid: number): void;
-    export function fchown(fd: number, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
-    export function fchownSync(fd: number, uid: number, gid: number): void;
-    export function lchown(path: string, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
-    export function lchownSync(path: string, uid: number, gid: number): void;
-    export function chmod(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
-    export function chmod(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
-    export function chmodSync(path: string, mode: number): void;
-    export function chmodSync(path: string, mode: string): void;
-    export function fchmod(fd: number, mode: number, callback?: (err?: ErrnoException) => void): void;
-    export function fchmod(fd: number, mode: string, callback?: (err?: ErrnoException) => void): void;
-    export function fchmodSync(fd: number, mode: number): void;
-    export function fchmodSync(fd: number, mode: string): void;
-    export function lchmod(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
-    export function lchmod(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
-    export function lchmodSync(path: string, mode: number): void;
-    export function lchmodSync(path: string, mode: string): void;
-    export function stat(path: string, callback?: (err: ErrnoException, stats: Stats) => any): void;
-    export function lstat(path: string, callback?: (err: ErrnoException, stats: Stats) => any): void;
-    export function fstat(fd: number, callback?: (err: ErrnoException, stats: Stats) => any): void;
-    export function statSync(path: string): Stats;
-    export function lstatSync(path: string): Stats;
-    export function fstatSync(fd: number): Stats;
-    export function link(srcpath: string, dstpath: string, callback?: (err?: ErrnoException) => void): void;
-    export function linkSync(srcpath: string, dstpath: string): void;
-    export function symlink(srcpath: string, dstpath: string, type?: string, callback?: (err?: ErrnoException) => void): void;
-    export function symlinkSync(srcpath: string, dstpath: string, type?: string): void;
-    export function readlink(path: string, callback?: (err: ErrnoException, linkString: string) => any): void;
-    export function readlinkSync(path: string): string;
-    export function realpath(path: string, callback?: (err: ErrnoException, resolvedPath: string) => any): void;
-    export function realpath(path: string, cache: {[path: string]: string}, callback: (err: ErrnoException, resolvedPath: string) =>any): void;
-    export function realpathSync(path: string, cache?: {[path: string]: string}): void;
-    export function unlink(path: string, callback?: (err?: ErrnoException) => void): void;
-    export function unlinkSync(path: string): void;
-    export function rmdir(path: string, callback?: (err?: ErrnoException) => void): void;
-    export function rmdirSync(path: string): void;
-    export function mkdir(path: string, callback?: (err?: ErrnoException) => void): void;
-    export function mkdir(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
-    export function mkdir(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
-    export function mkdirSync(path: string, mode?: number): void;
-    export function mkdirSync(path: string, mode?: string): void;
-    export function readdir(path: string, callback?: (err: ErrnoException, files: string[]) => void): void;
-    export function readdirSync(path: string): string[];
-    export function close(fd: number, callback?: (err?: ErrnoException) => void): void;
-    export function closeSync(fd: number): void;
-    export function open(path: string, flags: string, callback?: (err: ErrnoException, fd: number) => any): void;
-    export function open(path: string, flags: string, mode: number, callback?: (err: ErrnoException, fd: number) => any): void;
-    export function open(path: string, flags: string, mode: string, callback?: (err: ErrnoException, fd: number) => any): void;
-    export function openSync(path: string, flags: string, mode?: number): number;
-    export function openSync(path: string, flags: string, mode?: string): number;
-    export function utimes(path: string, atime: number, mtime: number, callback?: (err?: ErrnoException) => void): void;
-    export function utimesSync(path: string, atime: number, mtime: number): void;
-    export function futimes(fd: number, atime: number, mtime: number, callback?: (err?: ErrnoException) => void): void;
-    export function futimesSync(fd: number, atime: number, mtime: number): void;
-    export function fsync(fd: number, callback?: (err?: ErrnoException) => void): void;
-    export function fsyncSync(fd: number): void;
-    export function write(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, written: number, buffer: NodeBuffer) => void): void;
-    export function writeSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
-    export function read(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, bytesRead: number, buffer: NodeBuffer) => void): void;
-    export function readSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
-    export function readFile(filename: string, encoding: string, callback: (err: ErrnoException, data: string) => void): void;
-    export function readFile(filename: string, options: { encoding: string; flag?: string; }, callback: (err: ErrnoException, data: string) => void): void;
-    export function readFile(filename: string, options: { flag?: string; }, callback: (err: ErrnoException, data: NodeBuffer) => void): void;
-    export function readFile(filename: string, callback: (err: ErrnoException, data: NodeBuffer) => void ): void;
-    export function readFileSync(filename: string, encoding: string): string;
-    export function readFileSync(filename: string, options: { encoding: string; flag?: string; }): string;
-    export function readFileSync(filename: string, options?: { flag?: string; }): NodeBuffer;
-    export function writeFile(filename: string, data: any, callback?: (err: ErrnoException) => void): void;
-    export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: ErrnoException) => void): void;
-    export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void;
-    export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
-    export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void;
-    export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: ErrnoException) => void): void;
-    export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void;
-    export function appendFile(filename: string, data: any, callback?: (err: ErrnoException) => void): void;
-    export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
-    export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void;
-    export function watchFile(filename: string, listener: (curr: Stats, prev: Stats) => void): void;
-    export function watchFile(filename: string, options: { persistent?: boolean; interval?: number; }, listener: (curr: Stats, prev: Stats) => void): void;
-    export function unwatchFile(filename: string, listener?: (curr: Stats, prev: Stats) => void): void;
-    export function watch(filename: string, listener?: (event: string, filename: string) => any): FSWatcher;
-    export function watch(filename: string, options: { persistent?: boolean; }, listener?: (event: string, filename: string) => any): FSWatcher;
-    export function exists(path: string, callback?: (exists: boolean) => void): void;
-    export function existsSync(path: string): boolean;
-    export function createReadStream(path: string, options?: {
-        flags?: string;
-        encoding?: string;
-        fd?: string;
-        mode?: number;
-        bufferSize?: number;
-    }): ReadStream;
-    export function createReadStream(path: string, options?: {
-        flags?: string;
-        encoding?: string;
-        fd?: string;
-        mode?: string;
-        bufferSize?: number;
-    }): ReadStream;
-    export function createWriteStream(path: string, options?: {
-        flags?: string;
-        encoding?: string;
-        string?: string;
-    }): WriteStream;
-}
-
-declare module "path" { export = NodePath; }
-declare module NodePath {
-    export function normalize(p: string): string;
-    export function join(...paths: any[]): string;
-    export function resolve(...pathSegments: any[]): string;
-    export function relative(from: string, to: string): string;
-    export function dirname(p: string): string;
-    export function basename(p: string, ext?: string): string;
-    export function extname(p: string): string;
-    export var sep: string;
-}
-
-declare module "string_decoder" { export = NodeStringDecoder; }
-declare module NodeStringDecoder {
-    export interface NodeStringDecoder {
-        write(buffer: NodeBuffer): string;
-        detectIncompleteChar(buffer: NodeBuffer): number;
-    }
-    export var StringDecoder: {
-        new (encoding: string): NodeStringDecoder;
-    };
-}
-
-declare module "tls" { export = NodeTls; }
-declare module NodeTls {
-
-    var CLIENT_RENEG_LIMIT: number;
-    var CLIENT_RENEG_WINDOW: number;
-
-    export interface TlsOptions {
-        pfx?: any;   //string or buffer
-        key?: any;   //string or buffer
-        passphrase?: string;
-        cert?: any;
-        ca?: any;    //string or buffer
-        crl?: any;   //string or string array
-        ciphers?: string;
-        honorCipherOrder?: any;
-        requestCert?: boolean;
-        rejectUnauthorized?: boolean;
-        NPNProtocols?: any;  //array or Buffer;
-        SNICallback?: (servername: string) => any;
+    // "path" module
+    export interface Path {
+        normalize(p: string): string;
+        join(...paths: any[]): string;
+        resolve(...pathSegments: any[]): string;
+        relative(from: string, to: string): string;
+        dirname(p: string): string;
+        basename(p: string, ext?: string): string;
+        extname(p: string): string;
+        sep: string;
     }
 
-    export interface ConnectionOptions {
-        host?: string;
-        port?: number;
-        socket?: NodeNet.Socket;
-        pfx?: any;   //string | Buffer
-        key?: any;   //string | Buffer
-        passphrase?: string;
-        cert?: any;  //string | Buffer
-        ca?: any;    //Array of string | Buffer
-        rejectUnauthorized?: boolean;
-        NPNProtocols?: any;  //Array of string | Buffer
-        servername?: string;
+    // "string_decoder" module
+    export interface StringDecoder {
+        StringDecoder: new(encoding: string) => StringDecoder.StringDecoder;
+        
+    }
+    export module StringDecoder {
+        export interface StringDecoder {
+            write(buffer: NodeBuffer): string;
+            detectIncompleteChar(buffer: NodeBuffer): number;
+        }
     }
 
-    export interface Server extends NodeNet.Server {
-        // Extended base methods
-        listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
-        listen(path: string, listeningListener?: Function): void;
-        listen(handle: any, listeningListener?: Function): void;
+    // "tls" module
+    export interface Tls {
+        CLIENT_RENEG_LIMIT: number;
+        CLIENT_RENEG_WINDOW: number;
+        createServer(options: Tls.TlsOptions, secureConnectionListener?: (cleartextStream: Tls.ClearTextStream) =>void ): Tls.Server;
+        connect(options: Tls.TlsOptions, secureConnectionListener?: () =>void ): Tls.ClearTextStream;
+        connect(port: number, host?: string, options?: Tls.ConnectionOptions, secureConnectListener?: () =>void ): Tls.ClearTextStream;
+        connect(port: number, options?: Tls.ConnectionOptions, secureConnectListener?: () =>void ): Tls.ClearTextStream;
+        createSecurePair(credentials?: Crypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): Tls.SecurePair;
+    }
+    export module Tls {
 
-        listen(port: number, host?: string, callback?: Function): void;
-        close(): void;
-        address(): { port: number; family: string; address: string; };
-        addContext(hostName: string, credentials: {
+        export interface TlsOptions {
+            pfx?: any;   //string or buffer
+            key?: any;   //string or buffer
+            passphrase?: string;
+            cert?: any;
+            ca?: any;    //string or buffer
+            crl?: any;   //string or string array
+            ciphers?: string;
+            honorCipherOrder?: any;
+            requestCert?: boolean;
+            rejectUnauthorized?: boolean;
+            NPNProtocols?: any;  //array or Buffer;
+            SNICallback?: (servername: string) => any;
+        }
+
+        export interface ConnectionOptions {
+            host?: string;
+            port?: number;
+            socket?: Net.Socket;
+            pfx?: any;   //string | Buffer
+            key?: any;   //string | Buffer
+            passphrase?: string;
+            cert?: any;  //string | Buffer
+            ca?: any;    //Array of string | Buffer
+            rejectUnauthorized?: boolean;
+            NPNProtocols?: any;  //Array of string | Buffer
+            servername?: string;
+        }
+
+        export interface Server extends Net.Server {
+            // Extended base methods
+            listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
+            listen(path: string, listeningListener?: Function): void;
+            listen(handle: any, listeningListener?: Function): void;
+
+            listen(port: number, host?: string, callback?: Function): void;
+            close(): void;
+            address(): { port: number; family: string; address: string; };
+            addContext(hostName: string, credentials: {
+                key: string;
+                cert: string;
+                ca: string;
+            }): void;
+            maxConnections: number;
+            connections: number;
+        }
+
+        export interface ClearTextStream extends ReadWriteStream {
+            authorized: boolean;
+            authorizationError: Error;
+            getPeerCertificate(): any;
+            getCipher: {
+                name: string;
+                version: string;
+            };
+            address: {
+                port: number;
+                family: string;
+                address: string;
+            };
+            remoteAddress: string;
+            remotePort: number;
+        }
+
+        export interface SecurePair {
+            encrypted: any;
+            cleartext: any;
+        }
+    }
+
+    // "crypto" module
+    export interface Crypto {
+        createCredentials(details: Crypto.CredentialDetails): Crypto.Credentials;
+        createHash(algorithm: string): Crypto.Hash;
+        createHmac(algorithm: string, key: string): Crypto.Hmac;
+        createCipher(algorithm: string, password: any): Crypto.Cipher;
+        createCipheriv(algorithm: string, key: any, iv: any): Crypto.Cipher;
+        createSign(algorithm: string): Crypto.Signer;
+        createVerify(algorith: string): Crypto.Verify;
+        createDiffieHellman(prime_length: number): Crypto.DiffieHellman;
+        createDiffieHellman(prime: number, encoding?: string): Crypto.DiffieHellman;
+        getDiffieHellman(group_name: string): Crypto.DiffieHellman;
+        pbkdf2(password: string, salt: string, iterations: number, keylen: number, callback: (err: Error, derivedKey: string) => any): void;
+        randomBytes(size: number): NodeBuffer;
+        randomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
+        pseudoRandomBytes(size: number): NodeBuffer;
+        pseudoRandomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
+        
+    }
+    export module Crypto {
+        export interface CredentialDetails {
+            pfx: string;
             key: string;
+            passphrase: string;
             cert: string;
-            ca: string;
-        }): void;
-        maxConnections: number;
-        connections: number;
+            ca: any;    //string | string array
+            crl: any;   //string | string array
+            ciphers: string;
+        }
+        export interface Credentials { context?: any; }
+        export interface Hash {
+            update(data: any, input_encoding?: string): Hash;
+            digest(encoding?: string): string;
+        }
+        export interface Hmac {
+            update(data: any): void;
+            digest(encoding?: string): void;
+        }
+        export interface Cipher {
+            update(data: any, input_encoding?: string, output_encoding?: string): string;
+            final(output_encoding?: string): string;
+            setAutoPadding(auto_padding: boolean): void;
+            createDecipher(algorithm: string, password: any): Decipher;
+            createDecipheriv(algorithm: string, key: any, iv: any): Decipher;
+        }
+        export interface Decipher {
+            update(data: any, input_encoding?: string, output_encoding?: string): void;
+            final(output_encoding?: string): string;
+            setAutoPadding(auto_padding: boolean): void;
+        }
+        export interface Signer {
+            update(data: any): void;
+            sign(private_key: string, output_format: string): string;
+        }
+        export interface Verify {
+            update(data: any): void;
+            verify(object: string, signature: string, signature_format?: string): boolean;
+        }
+        export interface DiffieHellman {
+            generateKeys(encoding?: string): string;
+            computeSecret(other_public_key: string, input_encoding?: string, output_encoding?: string): string;
+            getPrime(encoding?: string): string;
+            getGenerator(encoding: string): string;
+            getPublicKey(encoding?: string): string;
+            getPrivateKey(encoding?: string): string;
+            setPublicKey(public_key: string, encoding?: string): void;
+            setPrivateKey(public_key: string, encoding?: string): void;
+        }
     }
 
-    export interface ClearTextStream extends ReadWriteStream {
-        authorized: boolean;
-        authorizationError: Error;
-        getPeerCertificate(): any;
-        getCipher: {
-            name: string;
-            version: string;
-        };
-        address: {
-            port: number;
-            family: string;
-            address: string;
-        };
-        remoteAddress: string;
-        remotePort: number;
+    // "stream" module
+    export interface Stream {
+        Readable: new(opts?: Stream.ReadableOptions) => Stream.Readable;
+        Writable: new(opts?: Stream.WritableOptions) => Stream.Writable;
+        Duplex: new(opts?: Stream.DuplexOptions) => Stream.Duplex;
+        Transform: new(opts?: Stream.TransformOptions) => Stream.Transform;
+    }
+    export module Stream {
+
+        export interface ReadableOptions {
+            highWaterMark?: number;
+            encoding?: string;
+            objectMode?: boolean;
+        }
+
+        export interface Readable extends Events.EventEmitter, ReadableStream {
+            readable: boolean;
+            _read(size: number): void;
+            read(size?: number): any;
+            setEncoding(encoding: string): void;
+            pause(): void;
+            resume(): void;
+            pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
+            unpipe<T extends WritableStream>(destination?: T): void;
+            unshift(chunk: string): void;
+            unshift(chunk: NodeBuffer): void;
+            wrap(oldStream: ReadableStream): ReadableStream;
+            push(chunk: any, encoding?: string): boolean;
+        }
+
+        export interface WritableOptions {
+            highWaterMark?: number;
+            decodeStrings?: boolean;
+        }
+
+        export interface Writable extends Events.EventEmitter, WritableStream {
+            writable: boolean;
+            _write(data: NodeBuffer, encoding: string, callback: Function): void;
+            _write(data: string, encoding: string, callback: Function): void;
+            write(buffer: NodeBuffer, cb?: Function): boolean;
+            write(str: string, cb?: Function): boolean;
+            write(str: string, encoding?: string, cb?: Function): boolean;
+            end(): void;
+            end(buffer: NodeBuffer, cb?: Function): void;
+            end(str: string, cb?: Function): void;
+            end(str: string, encoding?: string, cb?: Function): void;
+        }
+
+        export interface DuplexOptions extends ReadableOptions, WritableOptions {
+            allowHalfOpen?: boolean;
+        }
+
+        // Note: Duplex extends both Readable and Writable.
+        export interface Duplex extends Readable, ReadWriteStream {
+            writable: boolean;
+            _write(data: NodeBuffer, encoding: string, callback: Function): void;
+            _write(data: string, encoding: string, callback: Function): void;
+            write(buffer: NodeBuffer, cb?: Function): boolean;
+            write(str: string, cb?: Function): boolean;
+            write(str: string, encoding?: string, cb?: Function): boolean;
+            end(): void;
+            end(buffer: NodeBuffer, cb?: Function): void;
+            end(str: string, cb?: Function): void;
+            end(str: string, encoding?: string, cb?: Function): void;
+        }
+
+        export interface TransformOptions extends ReadableOptions, WritableOptions {}
+
+        // Note: Transform lacks the _read and _write methods of Readable/Writable.
+        export interface Transform extends Events.EventEmitter, ReadWriteStream {
+            readable: boolean;
+            writable: boolean;
+            _transform(chunk: NodeBuffer, encoding: string, callback: Function): void;
+            _transform(chunk: string, encoding: string, callback: Function): void;
+            _flush(callback: Function): void;
+            read(size?: number): any;
+            setEncoding(encoding: string): void;
+            pause(): void;
+            resume(): void;
+            pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
+            unpipe<T extends WritableStream>(destination?: T): void;
+            unshift(chunk: string): void;
+            unshift(chunk: NodeBuffer): void;
+            wrap(oldStream: ReadableStream): ReadableStream;
+            push(chunk: any, encoding?: string): boolean;
+            write(buffer: NodeBuffer, cb?: Function): boolean;
+            write(str: string, cb?: Function): boolean;
+            write(str: string, encoding?: string, cb?: Function): boolean;
+            end(): void;
+            end(buffer: NodeBuffer, cb?: Function): void;
+            end(str: string, cb?: Function): void;
+            end(str: string, encoding?: string, cb?: Function): void;
+        }
+
+        export interface PassThrough extends Transform {}
     }
 
-    export interface SecurePair {
-        encrypted: any;
-        cleartext: any;
+    // "util" module
+    export interface Util {
+        format(format: any, ...param: any[]): string;
+        debug(string: string): void;
+        error(...param: any[]): void;
+        puts(...param: any[]): void;
+        print(...param: any[]): void;
+        log(string: string): void;
+        inspect(object: any, showHidden?: boolean, depth?: number, color?: boolean): string;
+        inspect(object: any, options: Util.InspectOptions): string;
+        isArray(object: any): boolean;
+        isRegExp(object: any): boolean;
+        isDate(object: any): boolean;
+        isError(object: any): boolean;
+        inherits(constructor: any, superConstructor: any): void;
+    }
+    export module Util {
+        export interface InspectOptions {
+            showHidden?: boolean;
+            depth?: number;
+            colors?: boolean;
+            customInspect?: boolean;
+        }
     }
 
-    export function createServer(options: TlsOptions, secureConnectionListener?: (cleartextStream: ClearTextStream) =>void ): Server;
-    export function connect(options: TlsOptions, secureConnectionListener?: () =>void ): ClearTextStream;
-    export function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
-    export function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
-    export function createSecurePair(credentials?: NodeCrypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
-}
+    // "assert" module
+    export interface Assert {
+        (value: any, message?: string): void;
+        AssertionError: new(options?: Assert.AssertionErrorOptions) => Assert.AssertionError;
 
-declare module "crypto" { export = NodeCrypto; }
-declare module NodeCrypto {
-    export interface CredentialDetails {
-        pfx: string;
-        key: string;
-        passphrase: string;
-        cert: string;
-        ca: any;    //string | string array
-        crl: any;   //string | string array
-        ciphers: string;
-    }
-    export interface Credentials { context?: any; }
-    export function createCredentials(details: CredentialDetails): Credentials;
-    export function createHash(algorithm: string): Hash;
-    export function createHmac(algorithm: string, key: string): Hmac;
-    interface Hash {
-        update(data: any, input_encoding?: string): Hash;
-        digest(encoding?: string): string;
-    }
-    interface Hmac {
-        update(data: any): void;
-        digest(encoding?: string): void;
-    }
-    export function createCipher(algorithm: string, password: any): Cipher;
-    export function createCipheriv(algorithm: string, key: any, iv: any): Cipher;
-    interface Cipher {
-        update(data: any, input_encoding?: string, output_encoding?: string): string;
-        final(output_encoding?: string): string;
-        setAutoPadding(auto_padding: boolean): void;
-        createDecipher(algorithm: string, password: any): Decipher;
-        createDecipheriv(algorithm: string, key: any, iv: any): Decipher;
-    }
-    interface Decipher {
-        update(data: any, input_encoding?: string, output_encoding?: string): void;
-        final(output_encoding?: string): string;
-        setAutoPadding(auto_padding: boolean): void;
-    }
-    export function createSign(algorithm: string): Signer;
-    interface Signer {
-        update(data: any): void;
-        sign(private_key: string, output_format: string): string;
-    }
-    export function createVerify(algorith: string): Verify;
-    interface Verify {
-        update(data: any): void;
-        verify(object: string, signature: string, signature_format?: string): boolean;
-    }
-    export function createDiffieHellman(prime_length: number): DiffieHellman;
-    export function createDiffieHellman(prime: number, encoding?: string): DiffieHellman;
-    interface DiffieHellman {
-        generateKeys(encoding?: string): string;
-        computeSecret(other_public_key: string, input_encoding?: string, output_encoding?: string): string;
-        getPrime(encoding?: string): string;
-        getGenerator(encoding: string): string;
-        getPublicKey(encoding?: string): string;
-        getPrivateKey(encoding?: string): string;
-        setPublicKey(public_key: string, encoding?: string): void;
-        setPrivateKey(public_key: string, encoding?: string): void;
-    }
-    export function getDiffieHellman(group_name: string): DiffieHellman;
-    export function pbkdf2(password: string, salt: string, iterations: number, keylen: number, callback: (err: Error, derivedKey: string) => any): void;
-    export function randomBytes(size: number): NodeBuffer;
-    export function randomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
-    export function pseudoRandomBytes(size: number): NodeBuffer;
-    export function pseudoRandomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
-}
+        fail(actual?: any, expected?: any, message?: string, operator?: string): void;
+        ok(value: any, message?: string): void;
+        equal(actual: any, expected: any, message?: string): void;
+        notEqual(actual: any, expected: any, message?: string): void;
+        deepEqual(actual: any, expected: any, message?: string): void;
+        notDeepEqual(acutal: any, expected: any, message?: string): void;
+        strictEqual(actual: any, expected: any, message?: string): void;
+        notStrictEqual(actual: any, expected: any, message?: string): void;
+        throws: {
+            (block: Function, message?: string): void;
+            (block: Function, error: Function, message?: string): void;
+            (block: Function, error: RegExp, message?: string): void;
+            (block: Function, error: (err: any) => boolean, message?: string): void;
+        }
 
-declare module "stream" { export = NodeStream; }
-declare module NodeStream {
+        doesNotThrow: {
+            (block: Function, message?: string): void;
+            (block: Function, error: Function, message?: string): void;
+            (block: Function, error: RegExp, message?: string): void;
+            (block: Function, error: (err: any) => boolean, message?: string): void;
+        }
 
-    export interface ReadableOptions {
-        highWaterMark?: number;
-        encoding?: string;
-        objectMode?: boolean;
+        ifError(value: any): void;
     }
+    export module Assert {
 
-    export class Readable extends NodeEvents.EventEmitter implements ReadableStream {
-        readable: boolean;
-        constructor(opts?: ReadableOptions);
-        _read(size: number): void;
-        read(size?: number): any;
-        setEncoding(encoding: string): void;
-        pause(): void;
-        resume(): void;
-        pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
-        unpipe<T extends WritableStream>(destination?: T): void;
-        unshift(chunk: string): void;
-        unshift(chunk: NodeBuffer): void;
-        wrap(oldStream: ReadableStream): ReadableStream;
-        push(chunk: any, encoding?: string): boolean;
-    }
+        export interface AssertionErrorOptions {
+            message?: string;
+            actual?: any;
+            expected?: any;
+            operator?: string;
+            stackStartFunction?: Function
+        }
 
-    export interface WritableOptions {
-        highWaterMark?: number;
-        decodeStrings?: boolean;
-    }
-
-    export class Writable extends NodeEvents.EventEmitter implements WritableStream {
-        writable: boolean;
-        constructor(opts?: WritableOptions);
-        _write(data: NodeBuffer, encoding: string, callback: Function): void;
-        _write(data: string, encoding: string, callback: Function): void;
-        write(buffer: NodeBuffer, cb?: Function): boolean;
-        write(str: string, cb?: Function): boolean;
-        write(str: string, encoding?: string, cb?: Function): boolean;
-        end(): void;
-        end(buffer: NodeBuffer, cb?: Function): void;
-        end(str: string, cb?: Function): void;
-        end(str: string, encoding?: string, cb?: Function): void;
-    }
-
-    export interface DuplexOptions extends ReadableOptions, WritableOptions {
-        allowHalfOpen?: boolean;
-    }
-
-    // Note: Duplex extends both Readable and Writable.
-    export class Duplex extends Readable implements ReadWriteStream {
-        writable: boolean;
-        constructor(opts?: DuplexOptions);
-        _write(data: NodeBuffer, encoding: string, callback: Function): void;
-        _write(data: string, encoding: string, callback: Function): void;
-        write(buffer: NodeBuffer, cb?: Function): boolean;
-        write(str: string, cb?: Function): boolean;
-        write(str: string, encoding?: string, cb?: Function): boolean;
-        end(): void;
-        end(buffer: NodeBuffer, cb?: Function): void;
-        end(str: string, cb?: Function): void;
-        end(str: string, encoding?: string, cb?: Function): void;
-    }
-
-    export interface TransformOptions extends ReadableOptions, WritableOptions {}
-
-    // Note: Transform lacks the _read and _write methods of Readable/Writable.
-    export class Transform extends NodeEvents.EventEmitter implements ReadWriteStream {
-        readable: boolean;
-        writable: boolean;
-        constructor(opts?: TransformOptions);
-        _transform(chunk: NodeBuffer, encoding: string, callback: Function): void;
-        _transform(chunk: string, encoding: string, callback: Function): void;
-        _flush(callback: Function): void;
-        read(size?: number): any;
-        setEncoding(encoding: string): void;
-        pause(): void;
-        resume(): void;
-        pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
-        unpipe<T extends WritableStream>(destination?: T): void;
-        unshift(chunk: string): void;
-        unshift(chunk: NodeBuffer): void;
-        wrap(oldStream: ReadableStream): ReadableStream;
-        push(chunk: any, encoding?: string): boolean;
-        write(buffer: NodeBuffer, cb?: Function): boolean;
-        write(str: string, cb?: Function): boolean;
-        write(str: string, encoding?: string, cb?: Function): boolean;
-        end(): void;
-        end(buffer: NodeBuffer, cb?: Function): void;
-        end(str: string, cb?: Function): void;
-        end(str: string, encoding?: string, cb?: Function): void;
-    }
-
-    export class PassThrough extends Transform {}
-}
-
-declare module "util" { export = NodeUtil; }
-declare module NodeUtil {
-    export interface InspectOptions {
-        showHidden?: boolean;
-        depth?: number;
-        colors?: boolean;
-        customInspect?: boolean;
-    }
-
-    export function format(format: any, ...param: any[]): string;
-    export function debug(string: string): void;
-    export function error(...param: any[]): void;
-    export function puts(...param: any[]): void;
-    export function print(...param: any[]): void;
-    export function log(string: string): void;
-    export function inspect(object: any, showHidden?: boolean, depth?: number, color?: boolean): string;
-    export function inspect(object: any, options: InspectOptions): string;
-    export function isArray(object: any): boolean;
-    export function isRegExp(object: any): boolean;
-    export function isDate(object: any): boolean;
-    export function isError(object: any): boolean;
-    export function inherits(constructor: any, superConstructor: any): void;
-}
-
-declare module "assert" { export = NodeAssert; }
-declare function NodeAssert(value: any, message?: string): void;
-declare module NodeAssert {
-
-        export class AssertionError implements Error {
+        export interface AssertionError extends Error {
             name: string;
             message: string;
             actual: any;
             expected: any;
             operator: string;
             generatedMessage: boolean;
-
-            constructor(options?: {message?: string; actual?: any; expected?: any;
-                                  operator?: string; stackStartFunction?: Function});
         }
-
-        export function fail(actual?: any, expected?: any, message?: string, operator?: string): void;
-        export function ok(value: any, message?: string): void;
-        export function equal(actual: any, expected: any, message?: string): void;
-        export function notEqual(actual: any, expected: any, message?: string): void;
-        export function deepEqual(actual: any, expected: any, message?: string): void;
-        export function notDeepEqual(acutal: any, expected: any, message?: string): void;
-        export function strictEqual(actual: any, expected: any, message?: string): void;
-        export function notStrictEqual(actual: any, expected: any, message?: string): void;
-        export var throws: {
-            (block: Function, message?: string): void;
-            (block: Function, error: Function, message?: string): void;
-            (block: Function, error: RegExp, message?: string): void;
-            (block: Function, error: (err: any) => boolean, message?: string): void;
-        }
-
-        export var doesNotThrow: {
-            (block: Function, message?: string): void;
-            (block: Function, error: Function, message?: string): void;
-            (block: Function, error: RegExp, message?: string): void;
-            (block: Function, error: (err: any) => boolean, message?: string): void;
-        }
-
-        export function ifError(value: any): void;
-}
-
-declare module "tty" { export = NodeTty; }
-declare module NodeTty {
-
-    export function isatty(fd: number): boolean;
-    export interface ReadStream extends NodeNet.Socket {
-        isRaw: boolean;
-        setRawMode(mode: boolean): void;
-    }
-    export interface WriteStream extends NodeNet.Socket {
-        columns: number;
-        rows: number;
-    }
-}
-
-declare module "domain" { export = NodeDomain; }
-declare module NodeDomain {
-
-    export class Domain extends NodeEvents.EventEmitter {
-        run(fn: Function): void;
-        add(emitter: NodeEventEmitter): void;
-        remove(emitter: NodeEventEmitter): void;
-        bind(cb: (err: Error, data: any) => any): any;
-        intercept(cb: (data: any) => any): any;
-        dispose(): void;
-
-        addListener(event: string, listener: Function): Domain;
-        on(event: string, listener: Function): Domain;
-        once(event: string, listener: Function): Domain;
-        removeListener(event: string, listener: Function): Domain;
-        removeAllListeners(event?: string): Domain;
     }
 
-    export function create(): Domain;
+    // "tty" module
+    export interface Tty {
+        ReadStream: new() => Tty.ReadStream;
+        WriteStream: new() => Tty.WriteStream;
+        
+        isatty(fd: number): boolean;
+    }
+    export module Tty {
+
+        export interface ReadStream extends Net.Socket {
+            isRaw: boolean;
+            setRawMode(mode: boolean): void;
+        }
+        export interface WriteStream extends Net.Socket {
+            columns: number;
+            rows: number;
+        }
+    }
+
+    // "domain" module
+    export interface Domain {
+        Domain: new() => Domain.Domain;
+
+        create(): Domain.Domain;
+    }
+    export module Domain {
+
+        export interface Domain extends Events.EventEmitter {
+            run(fn: Function): void;
+            add(emitter: NodeEventEmitter): void;
+            remove(emitter: NodeEventEmitter): void;
+            bind(cb: (err: Error, data: any) => any): any;
+            intercept(cb: (data: any) => any): any;
+            dispose(): void;
+
+            addListener(event: string, listener: Function): Domain;
+            on(event: string, listener: Function): Domain;
+            once(event: string, listener: Function): Domain;
+            removeListener(event: string, listener: Function): Domain;
+            removeAllListeners(event?: string): Domain;
+        }
+
+    }
 }

From 3f1c041150162ead03ecf5218673c49e7a382334 Mon Sep 17 00:00:00 2001
From: MaceWindu <buzyka@gmail.com>
Date: Fri, 28 Mar 2014 17:32:16 +0100
Subject: [PATCH 223/309] Fix typo

---
 jquery/jquery.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index eadd8a492..290cdd2d4 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -288,7 +288,7 @@ interface JQueryGenericPromise<T> {
 }
 
 /**
- * Interface for the JQuery promise/deffered callbacks
+ * Interface for the JQuery promise/deferred callbacks
  */
 interface JQueryPromiseCallback<T> {
     (value?: T, ...args: any[]): void;

From bf8e60395f29fc7beb2e3af526d5e7562ceca894 Mon Sep 17 00:00:00 2001
From: Philip Bulley <philip@milkisevil.com>
Date: Fri, 28 Mar 2014 17:06:58 +0000
Subject: [PATCH 224/309] append() / before() support for ZeptoCollection arg

zepto.d.ts defines `append()` and `before()` methods for string, HTMLElement and HTMLElement[], but Zepto also supports ZeptoCollection. Added method overloads supporting ZeptoCollection.
---
 zepto/zepto.d.ts | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/zepto/zepto.d.ts b/zepto/zepto.d.ts
index eb217e5b9..10c1ff6d5 100644
--- a/zepto/zepto.d.ts
+++ b/zepto/zepto.d.ts
@@ -444,6 +444,11 @@ interface ZeptoCollection {
 	**/
 	after(content: HTMLElement): ZeptoCollection;
 
+	/**
+	* @see ZeptoCollection.after
+	**/
+	after(content: HTMLElement[]): ZeptoCollection;
+	
 	/**
 	* @see ZeptoCollection.after
 	**/
@@ -465,6 +470,11 @@ interface ZeptoCollection {
 	* @see ZeptoCollection.append
 	**/
 	append(content: HTMLElement[]): ZeptoCollection;
+	
+	/**
+	* @see ZeptoCollection.append
+	**/
+	append(content: ZeptoCollection): ZeptoCollection;
 
 	/**
 	* Append elements from the current collection to the target element. This is like append, but with reversed operands.
@@ -526,6 +536,11 @@ interface ZeptoCollection {
 	* @see ZeptoCollection.before
 	**/
 	before(content: HTMLElement[]): ZeptoCollection;
+	
+	/**
+	* @see ZeptoCollection.before
+	**/
+	before(content: ZeptoCollection): ZeptoCollection;
 
 	/**
 	* Get immediate children of each element in the current collection. If selector is given, filter the results to only include ones matching the CSS selector.

From 0c88531646cc82c975ffec791e1003590deda5eb Mon Sep 17 00:00:00 2001
From: Philip Bulley <philip@milkisevil.com>
Date: Fri, 28 Mar 2014 17:24:42 +0000
Subject: [PATCH 225/309] after() allows ZeptoCollection arg

---
 zepto/zepto.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/zepto/zepto.d.ts b/zepto/zepto.d.ts
index 10c1ff6d5..bc08565c2 100644
--- a/zepto/zepto.d.ts
+++ b/zepto/zepto.d.ts
@@ -452,7 +452,7 @@ interface ZeptoCollection {
 	/**
 	* @see ZeptoCollection.after
 	**/
-	after(content: HTMLElement[]): ZeptoCollection;
+	after(content: ZeptoCollection): ZeptoCollection;
 
 	/**
 	* Append content to the DOM inside each individual element in the collection. The content can be an HTML string, a DOM node or an array of nodes.

From c625577cb7a84eb5c4850ccce71e06149e1fc7fd Mon Sep 17 00:00:00 2001
From: Philip Bulley <philip@milkisevil.com>
Date: Fri, 28 Mar 2014 17:29:14 +0000
Subject: [PATCH 226/309] prepend() allows ZeptoCollection arg

---
 zepto/zepto.d.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/zepto/zepto.d.ts b/zepto/zepto.d.ts
index bc08565c2..3608ade9f 100644
--- a/zepto/zepto.d.ts
+++ b/zepto/zepto.d.ts
@@ -963,6 +963,12 @@ interface ZeptoCollection {
 	**/
 	prepend(content: HTMLElement[]): ZeptoCollection;
 
+	/**
+	* @see ZeptoCollection.prepend
+	* @param content
+	**/
+	prepend(content: ZeptoCollection): ZeptoCollection;
+
 	/**
 	* Prepend elements of the current collection inside each of the target elements. This is like prepend, only with reversed operands.
 	* @param content

From da3fcf9a8501354f5564c0965e18a06b75521674 Mon Sep 17 00:00:00 2001
From: Panu Horsmalahti <panu.horsmalahti@iki.fi>
Date: Sat, 29 Mar 2014 12:45:09 +0200
Subject: [PATCH 227/309] Update Q-tests.ts

Add tests for Q.nfapply and Q.nfcall.
---
 q/Q-tests.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/q/Q-tests.ts b/q/Q-tests.ts
index 22f33506e..6b69fb228 100644
--- a/q/Q-tests.ts
+++ b/q/Q-tests.ts
@@ -109,3 +109,9 @@ Q.allSettled([saveToDisk(), saveToCloud()]).spread(function (disk, cloud) {
     }
 }).done();
 
+var nodeStyle = (input: string, cb: Function) => {
+        cb(null, input);
+};
+
+Q.nfapply(nodeStyle, ["foo"]).done((result: string) => {});
+Q.nfcall(nodeStyle, "foo").done((result: string) => {});

From 368266b684bfa07c8d2ae1934e342add8be624aa Mon Sep 17 00:00:00 2001
From: Troy Gerwien <yortus@gmail.com>
Date: Sat, 29 Mar 2014 21:21:41 +0800
Subject: [PATCH 228/309] var-interface-module pattern now consistent

Everything (in both node and express) now follows the pattern:
```
declare module "external-name" {
import _ = InternalName.InnerName;
export = _;
}
declare module InternalName {
export var InnerName: InnerName;
export interface InnerName {
// functions and vars in here
}
export module InnerName {
// Must be non-instantiated - so only interfaces and modules in here
}
}

```
---
 express/express.d.ts | 130 ++++++++++-----------------
 node/node.d.ts       | 207 +++++++++++++++++++++++--------------------
 2 files changed, 160 insertions(+), 177 deletions(-)

diff --git a/express/express.d.ts b/express/express.d.ts
index b7331a43d..049871c35 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -12,13 +12,15 @@
 
 /// <reference path="../node/node.d.ts" />
 
-declare module "express" { var _: ExpressStatic; export = _; }
-interface ExpressStatic{
-    (): ExpressStatic.Express
+declare module "express" {
+    import _ = Express.Static;
+    export = _;
 }
-declare module ExpressStatic {
+declare module Express {
+    export var Static: Static;
+    export module Static {
 
-        export interface IRoute {
+        export interface Route {
             path: string;
 
             method: string;
@@ -32,17 +34,6 @@ declare module ExpressStatic {
             * populate `.params`.
             */
             match(path: string): boolean;
-        }
-
-        export class Route implements IRoute {
-            path: string;
-
-            method: string;
-
-            callbacks: Function[];
-
-            regexp: any;
-            match(path: string): boolean;
 
             /**
              * Initialize `Route` with the given HTTP `method`, `path`,
@@ -129,40 +120,10 @@ declare module ExpressStatic {
             patch(name: RegExp, ...handlers: RequestFunction[]): T;
         }
 
-        export class Router implements IRouter<Router> {
-          new (options?: any): Router;
+        export interface Router extends IRouter<Router> {
+            new (options?: any): Router;
 
-          middleware (): any;
-
-          param(name: string, fn: Function): Router;
-
-          param(name: any[], fn: Function): Router;
-
-          all(path: string, fn?: (req: Request, res: Response, next: Function) => any): Router;
-
-          all(path: string, ...callbacks: Function[]): void;
-
-          get(name: string): string;
-
-          get(name: string, ...handlers: RequestFunction[]): Router;
-
-          get(name: RegExp, ...handlers: RequestFunction[]): Router;
-
-          post(name: string, ...handlers: RequestFunction[]): Router;
-
-          post(name: RegExp, ...handlers: RequestFunction[]): Router;
-
-          put(name: string, ...handlers: RequestFunction[]): Router;
-
-          put(name: RegExp, ...handlers: RequestFunction[]): Router;
-
-          del(name: string, ...handlers: RequestFunction[]): Router;
-
-          del(name: RegExp, ...handlers: RequestFunction[]): Router;
-          
-          patch(name: string, ...handlers: RequestFunction[]): Router;
- 
-          patch(name: RegExp, ...handlers: RequestFunction[]): Router;
+            middleware (): any;
         }
 
         export interface Handler {
@@ -1125,7 +1086,7 @@ declare module ExpressStatic {
 
             listen(handle: any, listeningListener?: Function): void;
 
-            route: IRoute;
+            route: Route;
 
             router: string;
 
@@ -1174,6 +1135,9 @@ declare module ExpressStatic {
 
             response: Response;
         }
+    }
+    interface Static {
+        (): Express.Static.Express;
 
         /**
          * Body parser:
@@ -1202,7 +1166,7 @@ declare module ExpressStatic {
          *
          * @param options
          */
-        export function bodyParser(options?: any): Handler;
+        bodyParser(options?: any): Express.Static.Handler;
 
         /**
          * Error handler:
@@ -1225,7 +1189,7 @@ declare module ExpressStatic {
          *
          *   When accepted connect will output a nice html stack trace.
          */
-        export function errorHandler(opts?: any): Handler;
+        errorHandler(opts?: any): Express.Static.Handler;
 
         /**
          * Method Override:
@@ -1238,7 +1202,7 @@ declare module ExpressStatic {
          *
          * @param key
          */
-        export function methodOverride(key?: string): Handler;
+        methodOverride(key?: string): Express.Static.Handler;
 
         /**
          * Cookie parser:
@@ -1259,7 +1223,7 @@ declare module ExpressStatic {
          *
          * @param secret
          */
-        export function cookieParser(secret?: string): Handler;
+        cookieParser(secret?: string): Express.Static.Handler;
 
         /**
          * Session:
@@ -1396,7 +1360,7 @@ declare module ExpressStatic {
          *
          * @param options
          */
-        export function session(options?: any): Handler;
+        session(options?: any): Express.Static.Handler;
 
         /**
          * Hash the given `sess` object omitting changes
@@ -1404,7 +1368,7 @@ declare module ExpressStatic {
          *
          * @param sess
          */
-        export function hash(sess: string): string;
+        hash(sess: string): string;
 
         /**
          * Static:
@@ -1430,7 +1394,7 @@ declare module ExpressStatic {
          * @param root
          * @param options
          */
-        export function static(root: string, options?: any): Handler;
+        static(root: string, options?: any): Express.Static.Handler;
 
         /**
          * Basic Auth:
@@ -1462,11 +1426,11 @@ declare module ExpressStatic {
          * @param callback or username
          * @param realm
          */
-        export function basicAuth(callback: (user: string, pass: string, fn : Function) => void, realm?: string): Handler;
+        basicAuth(callback: (user: string, pass: string, fn : Function) => void, realm?: string): Express.Static.Handler;
 
-        export function basicAuth(callback: (user: string, pass: string) => boolean, realm?: string): Handler;
+        basicAuth(callback: (user: string, pass: string) => boolean, realm?: string): Express.Static.Handler;
 
-        export function basicAuth(user: string, pass: string, realm?: string): Handler;
+        basicAuth(user: string, pass: string, realm?: string): Express.Static.Handler;
 
         /**
          * Compress:
@@ -1495,7 +1459,7 @@ declare module ExpressStatic {
          *
          * @param options
          */
-        export function compress(options?: any): Handler;
+        compress(options?: any): Express.Static.Handler;
 
         /**
          * Cookie Session:
@@ -1522,7 +1486,7 @@ declare module ExpressStatic {
          *
          * @param options
          */
-        export function cookieSession(options?: any): Handler;
+        cookieSession(options?: any): Express.Static.Handler;
 
         /**
          * Anti CSRF:
@@ -1547,7 +1511,7 @@ declare module ExpressStatic {
          *
          * @param options
          */
-        export function csrf(options?: {value?: Function}): Handler;
+        csrf(options?: {value?: Function}): Express.Static.Handler;
 
         /**
          * Directory:
@@ -1563,7 +1527,7 @@ declare module ExpressStatic {
          * @param root
          * @param options
          */
-        export function directory(root: string, options?: any): Handler;
+        directory(root: string, options?: any): Express.Static.Handler;
 
         /**
          * Favicon:
@@ -1596,7 +1560,7 @@ declare module ExpressStatic {
          * @param path
          * @param options
          */
-        export function favicon(path?: string, options?: any): Handler;
+        favicon(path?: string, options?: any): Express.Static.Handler;
 
         /**
          * JSON:
@@ -1612,7 +1576,7 @@ declare module ExpressStatic {
          *
          * @param options
          */
-        export function json(options?: any): Handler;
+        json(options?: any): Express.Static.Handler;
 
         /**
          * Limit:
@@ -1626,9 +1590,9 @@ declare module ExpressStatic {
          *       .use(connect.limit('5.5mb'))
          *       .use(handleImageUpload)
          */
-        export function limit(bytes: number): Handler;
+        limit(bytes: number): Express.Static.Handler;
 
-        export function limit(bytes: string): Handler;
+        limit(bytes: string): Express.Static.Handler;
 
         /**
          * Logger:
@@ -1689,18 +1653,18 @@ declare module ExpressStatic {
          *
          *       connect.logger.format('name', 'string or function')
          */
-        export function logger(options: string): Handler;
+        logger(options: string): Express.Static.Handler;
 
-        export function logger(options: Function): Handler;
+        logger(options: Function): Express.Static.Handler;
 
-        export function logger(options?: any): Handler;
+        logger(options?: any): Express.Static.Handler;
 
         /**
          * Compile `fmt` into a function.
          *
          * @param fmt
          */
-        export function compile(fmt: string): Handler;
+        compile(fmt: string): Express.Static.Handler;
 
         /**
          * Define a token function with the given `name`,
@@ -1709,14 +1673,14 @@ declare module ExpressStatic {
          * @param name
          * @param fn
          */
-        export function token(name: string, fn: Function): any;
+        token(name: string, fn: Function): any;
 
         /**
          * Define a `fmt` with the given `name`.
          */
-        export function format(name: string, str: string): any;
+        format(name: string, str: string): any;
 
-        export function format(name: string, str: Function): any;
+        format(name: string, str: Function): any;
 
         /**
          * Query:
@@ -1734,7 +1698,7 @@ declare module ExpressStatic {
          *
          *  The `options` passed are provided to qs.parse function.
          */
-        export function query(options: any): Handler;
+        query(options: any): Express.Static.Handler;
 
         /**
          * Reponse time:
@@ -1742,7 +1706,7 @@ declare module ExpressStatic {
          * Adds the `X-Response-Time` header displaying the response
          * duration in milliseconds.
          */
-        export function responseTime(): Handler;
+        responseTime(): Express.Static.Handler;
 
         /**
          * Static cache:
@@ -1774,7 +1738,7 @@ declare module ExpressStatic {
          *   - `maxObjects`  max cache objects [128]
          *   - `maxLength`  max cache object length 256kb
          */
-        export function staticCache(options: any): Handler;
+        staticCache(options: any): Express.Static.Handler;
 
         /**
          * Timeout:
@@ -1787,7 +1751,7 @@ declare module ExpressStatic {
          * the response behaviour. This error has the `.timeout` property as
          * well as `.status == 408`.
          */
-        export function timeout(ms: number): Handler;
+        timeout(ms: number): Express.Static.Handler;
 
         /**
          * Vhost:
@@ -1805,10 +1769,10 @@ declare module ExpressStatic {
          * @param hostname
          * @param server
          */
-        export function vhost(hostname: string, server: any): Handler;
+        vhost(hostname: string, server: any): Express.Static.Handler;
 
-        export function urlencoded(): any;
+        urlencoded(): any;
 
-        export function multipart(): any;
+        multipart(): any;
+    }
 }
-
diff --git a/node/node.d.ts b/node/node.d.ts
index f82ffe202..f98400c46 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -225,32 +225,32 @@ interface NodeTimer {
 *                                               *
 ************************************************/
 
-declare module "querystring"    { var _: NodeJs.QueryString;    export = _; }
-declare module "events"         { var _: NodeJs.Events;         export = _; }
-declare module "http"           { var _: NodeJs.Http;           export = _; }
-declare module "cluster"        { var _: NodeJs.Cluster;        export = _; }
-declare module "zlib"           { var _: NodeJs.Zlib;           export = _; }
-declare module "os"             { var _: NodeJs.Os;             export = _; }
-declare module "https"          { var _: NodeJs.Https;          export = _; }
-declare module "punycode"       { var _: NodeJs.PunyCode;       export = _; }
-declare module "repl"           { var _: NodeJs.Repl;           export = _; }
-declare module "readline"       { var _: NodeJs.ReadLine;       export = _; }
-declare module "vm"             { var _: NodeJs.Vm;             export = _; }
-declare module "child_process"  { var _: NodeJs.ChildProcess;   export = _; }
-declare module "url"            { var _: NodeJs.Url;            export = _; }
-declare module "dns"            { var _: NodeJs.Dns;            export = _; }
-declare module "net"            { var _: NodeJs.Net;            export = _; }
-declare module "dgram"          { var _: NodeJs.Dgram;          export = _; }
-declare module "fs"             { var _: NodeJs.Fs;             export = _; }
-declare module "path"           { var _: NodeJs.Path;           export = _; }
-declare module "string_decoder" { var _: NodeJs.StringDecoder;  export = _; }
-declare module "tls"            { var _: NodeJs.Tls;            export = _; }
-declare module "crypto"         { var _: NodeJs.Crypto;         export = _; }
-declare module "stream"         { var _: NodeJs.Stream;         export = _; }
-declare module "util"           { var _: NodeJs.Util;           export = _; }
-declare module "assert"         { var _: NodeJs.Assert;         export = _; }
-declare module "tty"            { var _: NodeJs.Tty;            export = _; }
-declare module "domain"         { var _: NodeJs.Domain;         export = _; }
+declare module "querystring"    { import _ = NodeJs.QueryString;    export = _; }
+declare module "events"         { import _ = NodeJs.Events;         export = _; }
+declare module "http"           { import _ = NodeJs.Http;           export = _; }
+declare module "cluster"        { import _ = NodeJs.Cluster;        export = _; }
+declare module "zlib"           { import _ = NodeJs.Zlib;           export = _; }
+declare module "os"             { import _ = NodeJs.Os;             export = _; }
+declare module "https"          { import _ = NodeJs.Https;          export = _; }
+declare module "punycode"       { import _ = NodeJs.PunyCode;       export = _; }
+declare module "repl"           { import _ = NodeJs.Repl;           export = _; }
+declare module "readline"       { import _ = NodeJs.ReadLine;       export = _; }
+declare module "vm"             { import _ = NodeJs.Vm;             export = _; }
+declare module "child_process"  { import _ = NodeJs.ChildProcess;   export = _; }
+declare module "url"            { import _ = NodeJs.Url;            export = _; }
+declare module "dns"            { import _ = NodeJs.Dns;            export = _; }
+declare module "net"            { import _ = NodeJs.Net;            export = _; }
+declare module "dgram"          { import _ = NodeJs.Dgram;          export = _; }
+declare module "fs"             { import _ = NodeJs.Fs;             export = _; }
+declare module "path"           { import _ = NodeJs.Path;           export = _; }
+declare module "string_decoder" { import _ = NodeJs.StringDecoder;  export = _; }
+declare module "tls"            { import _ = NodeJs.Tls;            export = _; }
+declare module "crypto"         { import _ = NodeJs.Crypto;         export = _; }
+declare module "stream"         { import _ = NodeJs.Stream;         export = _; }
+declare module "util"           { import _ = NodeJs.Util;           export = _; }
+declare module "assert"         { import _ = NodeJs.Assert;         export = _; }
+declare module "tty"            { import _ = NodeJs.Tty;            export = _; }
+declare module "domain"         { import _ = NodeJs.Domain;         export = _; }
 
 /************************************************
 *                                               *
@@ -260,15 +260,20 @@ declare module "domain"         { var _: NodeJs.Domain;         export = _; }
 
 declare module NodeJs {
 
-    // "querystring" module
+
+    // ---------- "querystring" module ----------
+    export var QueryString: QueryString;
     export interface QueryString {
         stringify(obj: any, sep?: string, eq?: string): string;
         parse(str: string, sep?: string, eq?: string, options?: { maxKeys?: number; }): any;
         escape(): any;
         unescape(): any;
     }
+    export module QueryString { }
 
-    // "events" module
+
+    // ---------- "events" module ----------
+    export var Events: Events;
     export interface Events {
         EventEmitter: Events.EventEmitterStatic;
     }
@@ -276,7 +281,6 @@ declare module NodeJs {
         export interface EventEmitterStatic {
             listenerCount(emitter: EventEmitter, event: string): number;
         }
-
         export interface EventEmitter extends NodeEventEmitter {
             addListener(event: string, listener: Function): EventEmitter;
             on(event: string, listener: Function): EventEmitter;
@@ -289,7 +293,9 @@ declare module NodeJs {
         }
     }
 
-    // "http" module
+
+    // ---------- "http" module ----------
+    export var Http: Http;
     export interface Http {
         STATUS_CODES: any;
         createServer(requestListener?: (request: Http.ServerRequest, response: Http.ServerResponse) =>void ): Http.Server;
@@ -299,7 +305,6 @@ declare module NodeJs {
         globalAgent: Http.Agent;
     }
     export module Http {
-
         export interface Server extends NodeEventEmitter {
             listen(port: number, hostname?: string, backlog?: number, callback?: Function): void;
             listen(path: string, callback?: Function): void;
@@ -319,6 +324,7 @@ declare module NodeJs {
             connection: Net.Socket;
         }
         export interface ServerResponse extends NodeEventEmitter, WritableStream {
+
             // Extended base methods
             write(buffer: NodeBuffer): boolean;
             write(buffer: NodeBuffer, cb?: Function): boolean;
@@ -345,6 +351,7 @@ declare module NodeJs {
             end(data?: any, encoding?: string): void;
         }
         export interface ClientRequest extends NodeEventEmitter, WritableStream {
+
             // Extended base methods
             write(buffer: NodeBuffer): boolean;
             write(buffer: NodeBuffer, cb?: Function): boolean;
@@ -377,7 +384,9 @@ declare module NodeJs {
         export interface Agent { maxSockets: number; sockets: any; requests: any; }
     }
 
-    // "cluster" module
+
+    // ---------- "cluster" module ----------
+    export var Cluster: Cluster;
     export interface Cluster {
         settings: Cluster.ClusterSettings;
         isMaster: boolean;
@@ -399,13 +408,11 @@ declare module NodeJs {
         emit(event: string, ...args: any[]): boolean;
     }
     export module Cluster {
-
         export interface ClusterSettings {
             exec?: string;
             args?: string[];
             silent?: boolean;
         }
-
         export interface Worker extends Events.EventEmitter {
             id: string;
             process: ChildProcess.ChildProcess;
@@ -417,7 +424,9 @@ declare module NodeJs {
         }
     }
 
-    // "zlib" module
+
+    // ---------- "zlib" module ----------
+    export var Zlib: Zlib;
     export interface Zlib {
         createGzip(options?: Zlib.ZlibOptions): Zlib.Gzip;
         createGunzip(options?: Zlib.ZlibOptions): Zlib.Gunzip;
@@ -469,9 +478,7 @@ declare module NodeJs {
         Z_NULL: number;
     }
     export module Zlib {
-
         export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; }
-
         export interface Gzip extends ReadWriteStream { }
         export interface Gunzip extends ReadWriteStream { }
         export interface Deflate extends ReadWriteStream { }
@@ -481,7 +488,9 @@ declare module NodeJs {
         export interface Unzip extends ReadWriteStream { }
     }
 
-    // "os" module
+
+    // ---------- "os" module ----------
+    export var Os: Os;
     export interface Os {
         tmpDir(): string;
         hostname(): string;
@@ -497,8 +506,11 @@ declare module NodeJs {
         networkInterfaces(): any;
         EOL: string;
     }
+    export module Os { }
 
-    // "https" module
+
+    // ---------- "https" module ----------
+    export var Https: Https;
     export interface Https {
         Agent: new(options?: Https.RequestOptions) => Https.Agent;
 
@@ -508,7 +520,6 @@ declare module NodeJs {
         globalAgent: Https.Agent;
     }
     export module Https {
-
         export interface ServerOptions {
             pfx?: any;
             key?: any;
@@ -523,7 +534,6 @@ declare module NodeJs {
             NPNProtocols?: any;
             SNICallback?: (servername: string) => any;
         }
-
         export interface RequestOptions {
             host?: string;
             hostname?: string;
@@ -541,7 +551,6 @@ declare module NodeJs {
             ciphers?: string;
             rejectUnauthorized?: boolean;
         }
-
         export interface Agent {
             maxSockets: number;
             sockets: any;
@@ -550,7 +559,9 @@ declare module NodeJs {
         export interface Server extends Tls.Server { }
     }
 
-    // "punycode" module
+
+    // ---------- "punycode" module ----------
+    export var PunyCode: PunyCode;
     export interface PunyCode {
         decode(string: string): string;
         encode(string: string): string;
@@ -562,13 +573,15 @@ declare module NodeJs {
         }
         version: any;
     }
+    export module PunyCode { }
 
-    // "repl" module
+
+    // ---------- "repl" module ----------
+    export var Repl: Repl;
     export interface Repl {
         start(options: Repl.ReplOptions): NodeEventEmitter;
     }
     export module Repl {
-
         export interface ReplOptions {
             prompt?: string;
             input?: ReadableStream;
@@ -582,12 +595,13 @@ declare module NodeJs {
         }
     }
 
-    // "readline" module
+
+    // ---------- "readline" module ----------
+    export var ReadLine: ReadLine;
     export interface ReadLine {
         createInterface(options: ReadLine.ReadLineOptions): ReadLine.ReadLine;
     }
     export module ReadLine {
-
         export interface ReadLine extends NodeEventEmitter {
             setPrompt(prompt: string, length: number): void;
             prompt(preserveCursor?: boolean): void;
@@ -605,7 +619,9 @@ declare module NodeJs {
         }
     }
 
-    // "vm" module
+
+    // ---------- "vm" module ----------
+    export var Vm: Vm;
     export interface Vm {
         runInThisContext(code: string, filename?: string): void;
         runInNewContext(code: string, sandbox?: Vm.Context, filename?: string): void;
@@ -621,7 +637,9 @@ declare module NodeJs {
         }
     }
 
-    // "child_process" module
+
+    // ---------- "child_process" module ----------
+    export var ChildProcess: ChildProcess;
     export interface ChildProcess {
         spawn(command: string, args?: string[], options?: {
             cwd?: string;
@@ -658,7 +676,6 @@ declare module NodeJs {
         }): ChildProcess.ChildProcess;
     }
     export module ChildProcess {
-
         export interface ChildProcess extends NodeEventEmitter {
             stdin: WritableStream;
             stdout: ReadableStream;
@@ -670,7 +687,9 @@ declare module NodeJs {
         }
     }
 
-    // "url" module
+
+    // ---------- "url" module ----------
+    export var Url: Url;
     export interface Url {
         parse(urlStr: string, parseQueryString?: boolean , slashesDenoteHost?: boolean ): Url.Url;
         format(url: Url.UrlOptions): string;
@@ -689,7 +708,6 @@ declare module NodeJs {
             query: string;
             slashes: boolean;
         }
-
         export interface UrlOptions {
             protocol?: string;
             auth?: string;
@@ -702,7 +720,9 @@ declare module NodeJs {
         }
     }
 
-    // "dns" module
+
+    // ---------- "dns" module ----------
+    export var Dns: Dns;
     export interface Dns {
         lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string;
         lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string;
@@ -717,8 +737,11 @@ declare module NodeJs {
         resolveCname(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
         reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[];
     }
+    export module Dns { }
 
-    // "net" module
+
+    // ---------- "net" module ----------
+    export var Net: Net;
     export interface Net {
         Socket: new(options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }) => Net.Socket;
 
@@ -735,8 +758,8 @@ declare module NodeJs {
         isIPv6(input: string): boolean;
     }
     export module Net {
-
         export interface Socket extends ReadWriteStream {
+
             // Extended base methods
             write(buffer: NodeBuffer): boolean;
             write(buffer: NodeBuffer, cb?: Function): boolean;
@@ -768,7 +791,6 @@ declare module NodeJs {
             end(str: string, encoding?: string, cb?: Function): void;
             end(data?: any, encoding?: string): void;
         }
-
         export interface Server extends Socket {
             listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
             listen(path: string, listeningListener?: Function): void;
@@ -780,12 +802,13 @@ declare module NodeJs {
         }
     }
 
-    // "dgram" module
+
+    // ---------- "dgram" module ----------
+    export var Dgram: Dgram;
     export interface Dgram {
         createSocket(type: string, callback?: Function): Dgram.Socket;
     }
     export module Dgram {
-
         interface Socket extends NodeEventEmitter {
             send(buf: NodeBuffer, offset: number, length: number, port: number, address: string, callback?: Function): void;
             bind(port: number, address?: string): void;
@@ -799,7 +822,9 @@ declare module NodeJs {
         }
     }
 
-    // "fs" module
+
+    // ---------- "fs" module ----------
+    export var Fs: Fs;
     export interface Fs {
         rename(oldPath: string, newPath: string, callback?: (err?: ErrnoException) => void): void;
         renameSync(oldPath: string, newPath: string): void;
@@ -915,7 +940,6 @@ declare module NodeJs {
         }): Fs.WriteStream;
     }
     export module Fs {
-
         export interface Stats {
             isFile(): boolean;
             isDirectory(): boolean;
@@ -938,16 +962,16 @@ declare module NodeJs {
             mtime: Date;
             ctime: Date;
         }
-
         export interface FSWatcher extends NodeEventEmitter {
             close(): void;
         }
-
         export interface ReadStream extends ReadableStream { }
         export interface WriteStream extends WritableStream { }
     }
 
-    // "path" module
+
+    // ---------- "path" module ----------
+    export var Path: Path;
     export interface Path {
         normalize(p: string): string;
         join(...paths: any[]): string;
@@ -958,11 +982,13 @@ declare module NodeJs {
         extname(p: string): string;
         sep: string;
     }
+    export module Path { }
 
-    // "string_decoder" module
+
+    // ---------- "string_decoder" module ----------
+    export var StringDecoder: StringDecoder;
     export interface StringDecoder {
         StringDecoder: new(encoding: string) => StringDecoder.StringDecoder;
-        
     }
     export module StringDecoder {
         export interface StringDecoder {
@@ -971,7 +997,9 @@ declare module NodeJs {
         }
     }
 
-    // "tls" module
+
+    // ---------- "tls" module ----------
+    export var Tls: Tls;
     export interface Tls {
         CLIENT_RENEG_LIMIT: number;
         CLIENT_RENEG_WINDOW: number;
@@ -982,7 +1010,6 @@ declare module NodeJs {
         createSecurePair(credentials?: Crypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): Tls.SecurePair;
     }
     export module Tls {
-
         export interface TlsOptions {
             pfx?: any;   //string or buffer
             key?: any;   //string or buffer
@@ -997,7 +1024,6 @@ declare module NodeJs {
             NPNProtocols?: any;  //array or Buffer;
             SNICallback?: (servername: string) => any;
         }
-
         export interface ConnectionOptions {
             host?: string;
             port?: number;
@@ -1011,7 +1037,6 @@ declare module NodeJs {
             NPNProtocols?: any;  //Array of string | Buffer
             servername?: string;
         }
-
         export interface Server extends Net.Server {
             // Extended base methods
             listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
@@ -1029,7 +1054,6 @@ declare module NodeJs {
             maxConnections: number;
             connections: number;
         }
-
         export interface ClearTextStream extends ReadWriteStream {
             authorized: boolean;
             authorizationError: Error;
@@ -1046,14 +1070,15 @@ declare module NodeJs {
             remoteAddress: string;
             remotePort: number;
         }
-
         export interface SecurePair {
             encrypted: any;
             cleartext: any;
         }
     }
 
-    // "crypto" module
+
+    // ---------- "crypto" module ----------
+    export var Crypto: Crypto;
     export interface Crypto {
         createCredentials(details: Crypto.CredentialDetails): Crypto.Credentials;
         createHash(algorithm: string): Crypto.Hash;
@@ -1070,7 +1095,6 @@ declare module NodeJs {
         randomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
         pseudoRandomBytes(size: number): NodeBuffer;
         pseudoRandomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
-        
     }
     export module Crypto {
         export interface CredentialDetails {
@@ -1123,7 +1147,9 @@ declare module NodeJs {
         }
     }
 
-    // "stream" module
+
+    // ---------- "stream" module ----------
+    export var Stream: Stream;
     export interface Stream {
         Readable: new(opts?: Stream.ReadableOptions) => Stream.Readable;
         Writable: new(opts?: Stream.WritableOptions) => Stream.Writable;
@@ -1131,13 +1157,11 @@ declare module NodeJs {
         Transform: new(opts?: Stream.TransformOptions) => Stream.Transform;
     }
     export module Stream {
-
         export interface ReadableOptions {
             highWaterMark?: number;
             encoding?: string;
             objectMode?: boolean;
         }
-
         export interface Readable extends Events.EventEmitter, ReadableStream {
             readable: boolean;
             _read(size: number): void;
@@ -1152,12 +1176,10 @@ declare module NodeJs {
             wrap(oldStream: ReadableStream): ReadableStream;
             push(chunk: any, encoding?: string): boolean;
         }
-
         export interface WritableOptions {
             highWaterMark?: number;
             decodeStrings?: boolean;
         }
-
         export interface Writable extends Events.EventEmitter, WritableStream {
             writable: boolean;
             _write(data: NodeBuffer, encoding: string, callback: Function): void;
@@ -1170,7 +1192,6 @@ declare module NodeJs {
             end(str: string, cb?: Function): void;
             end(str: string, encoding?: string, cb?: Function): void;
         }
-
         export interface DuplexOptions extends ReadableOptions, WritableOptions {
             allowHalfOpen?: boolean;
         }
@@ -1188,7 +1209,6 @@ declare module NodeJs {
             end(str: string, cb?: Function): void;
             end(str: string, encoding?: string, cb?: Function): void;
         }
-
         export interface TransformOptions extends ReadableOptions, WritableOptions {}
 
         // Note: Transform lacks the _read and _write methods of Readable/Writable.
@@ -1216,11 +1236,12 @@ declare module NodeJs {
             end(str: string, cb?: Function): void;
             end(str: string, encoding?: string, cb?: Function): void;
         }
-
         export interface PassThrough extends Transform {}
     }
 
-    // "util" module
+
+    // ---------- "util" module ----------
+    export var Util: Util;
     export interface Util {
         format(format: any, ...param: any[]): string;
         debug(string: string): void;
@@ -1245,7 +1266,9 @@ declare module NodeJs {
         }
     }
 
-    // "assert" module
+
+    // ---------- "assert" module ----------
+    export var Assert: Assert;
     export interface Assert {
         (value: any, message?: string): void;
         AssertionError: new(options?: Assert.AssertionErrorOptions) => Assert.AssertionError;
@@ -1264,18 +1287,15 @@ declare module NodeJs {
             (block: Function, error: RegExp, message?: string): void;
             (block: Function, error: (err: any) => boolean, message?: string): void;
         }
-
         doesNotThrow: {
             (block: Function, message?: string): void;
             (block: Function, error: Function, message?: string): void;
             (block: Function, error: RegExp, message?: string): void;
             (block: Function, error: (err: any) => boolean, message?: string): void;
         }
-
         ifError(value: any): void;
     }
     export module Assert {
-
         export interface AssertionErrorOptions {
             message?: string;
             actual?: any;
@@ -1283,8 +1303,8 @@ declare module NodeJs {
             operator?: string;
             stackStartFunction?: Function
         }
-
         export interface AssertionError extends Error {
+            new(options?: AssertionErrorOptions): AssertionError;
             name: string;
             message: string;
             actual: any;
@@ -1294,15 +1314,15 @@ declare module NodeJs {
         }
     }
 
-    // "tty" module
+
+    // ---------- "tty" module ----------
+    export var Tty: Tty;
     export interface Tty {
         ReadStream: new() => Tty.ReadStream;
         WriteStream: new() => Tty.WriteStream;
-        
         isatty(fd: number): boolean;
     }
     export module Tty {
-
         export interface ReadStream extends Net.Socket {
             isRaw: boolean;
             setRawMode(mode: boolean): void;
@@ -1313,14 +1333,14 @@ declare module NodeJs {
         }
     }
 
-    // "domain" module
+
+    // ---------- "domain" module ----------
+    export var Domain: Domain;
     export interface Domain {
         Domain: new() => Domain.Domain;
-
         create(): Domain.Domain;
     }
     export module Domain {
-
         export interface Domain extends Events.EventEmitter {
             run(fn: Function): void;
             add(emitter: NodeEventEmitter): void;
@@ -1335,6 +1355,5 @@ declare module NodeJs {
             removeListener(event: string, listener: Function): Domain;
             removeAllListeners(event?: string): Domain;
         }
-
     }
 }

From 6f472b8f0920aa65960260a364c9e1577a862136 Mon Sep 17 00:00:00 2001
From: Troy Gerwien <yortus@gmail.com>
Date: Sun, 30 Mar 2014 10:05:57 +0800
Subject: [PATCH 229/309] WIP: all passing (bar assert) but needs more...

Need to remove superfluous typings - eg NodeJs.QueryString.escape should
not be valid
---
 express/express.d.ts | 157 +++++++++++++++++++++++++++++++------------
 node/node.d.ts       |  64 ++++++++++++------
 2 files changed, 159 insertions(+), 62 deletions(-)

diff --git a/express/express.d.ts b/express/express.d.ts
index 049871c35..f88df016b 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -17,10 +17,47 @@ declare module "express" {
     export = _;
 }
 declare module Express {
-    export var Static: Static;
+    export function Static(): Static.Express;
+    export interface Static {
+        (): Static.Express;
+        Route: new (method: string, path: string, callbacks: Function[], options: any) => Static.Route;
+        Router: new (options?: any) => Static.Router;
+        bodyParser(options?: any): Static.Handler;
+        errorHandler(opts?: any): Static.Handler;
+        methodOverride(key?: string): Static.Handler;
+        cookieParser(secret?: string): Static.Handler;
+        session(options?: any): Static.Handler;
+        hash(sess: string): string;
+        static(root: string, options?: any): Static.Handler;
+        basicAuth(callback: (user: string, pass: string, fn : Function) => void, realm?: string): Static.Handler;
+        basicAuth(callback: (user: string, pass: string) => boolean, realm?: string): Static.Handler;
+        basicAuth(user: string, pass: string, realm?: string): Static.Handler;
+        compress(options?: any): Static.Handler;
+        cookieSession(options?: any): Static.Handler;
+        csrf(options?: {value?: Function}): Static.Handler;
+        directory(root: string, options?: any): Static.Handler;
+        favicon(path?: string, options?: any): Static.Handler;
+        json(options?: any): Static.Handler;
+        limit(bytes: number): Static.Handler;
+        limit(bytes: string): Static.Handler;
+        logger(options: string): Static.Handler;
+        logger(options: Function): Static.Handler;
+        logger(options?: any): Static.Handler;
+        compile(fmt: string): Static.Handler;
+        token(name: string, fn: Function): any;
+        format(name: string, str: string): any;
+        format(name: string, str: Function): any;
+        query(options: any): Static.Handler;
+        responseTime(): Static.Handler;
+        staticCache(options: any): Static.Handler;
+        timeout(ms: number): Static.Handler;
+        vhost(hostname: string, server: any): Static.Handler;
+        urlencoded(): any;
+        multipart(): any;
+    }
     export module Static {
 
-        export interface Route {
+        interface IRoute {
             path: string;
 
             method: string;
@@ -34,6 +71,17 @@ declare module Express {
             * populate `.params`.
             */
             match(path: string): boolean;
+        }
+
+        class Route implements IRoute {
+            path: string;
+
+            method: string;
+
+            callbacks: Function[];
+
+            regexp: any;
+            match(path: string): boolean;
 
             /**
              * Initialize `Route` with the given HTTP `method`, `path`,
@@ -49,10 +97,10 @@ declare module Express {
              * @param callbacks
              * @param options
              */
-            new (method: string, path: string, callbacks: Function[], options: any): Route;
+            constructor (method: string, path: string, callbacks: Function[], options: any);
         }
 
-        export interface IRouter<T> {
+        interface IRouter<T> {
             /**
              * Map the given param placeholder `name`(s) to the given callback(s).
              *
@@ -97,8 +145,6 @@ declare module Express {
 
             all(path: string, ...callbacks: Function[]): void;
 
-            get(name: string): string;
-
             get(name: string, ...handlers: RequestFunction[]): T;
 
             get(name: RegExp, ...handlers: RequestFunction[]): T;
@@ -120,10 +166,38 @@ declare module Express {
             patch(name: RegExp, ...handlers: RequestFunction[]): T;
         }
 
-        export interface Router extends IRouter<Router> {
-            new (options?: any): Router;
+        export class Router implements IRouter<Router> {
+            constructor (options?: any);
 
             middleware (): any;
+
+            param(name: string, fn: Function): Router;
+
+            param(name: any[], fn: Function): Router;
+
+            all(path: string, fn?: (req: Request, res: Response, next: Function) => any): Router;
+
+            all(path: string, ...callbacks: Function[]): void;
+
+            get(name: string, ...handlers: RequestFunction[]): Router;
+
+            get(name: RegExp, ...handlers: RequestFunction[]): Router;
+
+            post(name: string, ...handlers: RequestFunction[]): Router;
+
+            post(name: RegExp, ...handlers: RequestFunction[]): Router;
+
+            put(name: string, ...handlers: RequestFunction[]): Router;
+
+            put(name: RegExp, ...handlers: RequestFunction[]): Router;
+
+            del(name: string, ...handlers: RequestFunction[]): Router;
+
+            del(name: RegExp, ...handlers: RequestFunction[]): Router;
+          
+            patch(name: string, ...handlers: RequestFunction[]): Router;
+ 
+            patch(name: RegExp, ...handlers: RequestFunction[]): Router;
         }
 
         export interface Handler {
@@ -1135,9 +1209,6 @@ declare module Express {
 
             response: Response;
         }
-    }
-    interface Static {
-        (): Express.Static.Express;
 
         /**
          * Body parser:
@@ -1166,7 +1237,7 @@ declare module Express {
          *
          * @param options
          */
-        bodyParser(options?: any): Express.Static.Handler;
+        export function bodyParser(options?: any): Handler;
 
         /**
          * Error handler:
@@ -1189,7 +1260,7 @@ declare module Express {
          *
          *   When accepted connect will output a nice html stack trace.
          */
-        errorHandler(opts?: any): Express.Static.Handler;
+        export function errorHandler(opts?: any): Handler;
 
         /**
          * Method Override:
@@ -1202,7 +1273,7 @@ declare module Express {
          *
          * @param key
          */
-        methodOverride(key?: string): Express.Static.Handler;
+        export function methodOverride(key?: string): Handler;
 
         /**
          * Cookie parser:
@@ -1223,7 +1294,7 @@ declare module Express {
          *
          * @param secret
          */
-        cookieParser(secret?: string): Express.Static.Handler;
+        export function cookieParser(secret?: string): Handler;
 
         /**
          * Session:
@@ -1360,7 +1431,7 @@ declare module Express {
          *
          * @param options
          */
-        session(options?: any): Express.Static.Handler;
+        export function session(options?: any): Handler;
 
         /**
          * Hash the given `sess` object omitting changes
@@ -1368,7 +1439,7 @@ declare module Express {
          *
          * @param sess
          */
-        hash(sess: string): string;
+        export function hash(sess: string): string;
 
         /**
          * Static:
@@ -1394,7 +1465,7 @@ declare module Express {
          * @param root
          * @param options
          */
-        static(root: string, options?: any): Express.Static.Handler;
+        export function static(root: string, options?: any): Handler;
 
         /**
          * Basic Auth:
@@ -1426,11 +1497,11 @@ declare module Express {
          * @param callback or username
          * @param realm
          */
-        basicAuth(callback: (user: string, pass: string, fn : Function) => void, realm?: string): Express.Static.Handler;
+        export function basicAuth(callback: (user: string, pass: string, fn : Function) => void, realm?: string): Handler;
 
-        basicAuth(callback: (user: string, pass: string) => boolean, realm?: string): Express.Static.Handler;
+        export function basicAuth(callback: (user: string, pass: string) => boolean, realm?: string): Handler;
 
-        basicAuth(user: string, pass: string, realm?: string): Express.Static.Handler;
+        export function basicAuth(user: string, pass: string, realm?: string): Handler;
 
         /**
          * Compress:
@@ -1459,7 +1530,7 @@ declare module Express {
          *
          * @param options
          */
-        compress(options?: any): Express.Static.Handler;
+        export function compress(options?: any): Handler;
 
         /**
          * Cookie Session:
@@ -1486,7 +1557,7 @@ declare module Express {
          *
          * @param options
          */
-        cookieSession(options?: any): Express.Static.Handler;
+        export function cookieSession(options?: any): Handler;
 
         /**
          * Anti CSRF:
@@ -1511,7 +1582,7 @@ declare module Express {
          *
          * @param options
          */
-        csrf(options?: {value?: Function}): Express.Static.Handler;
+        export function csrf(options?: {value?: Function}): Handler;
 
         /**
          * Directory:
@@ -1527,7 +1598,7 @@ declare module Express {
          * @param root
          * @param options
          */
-        directory(root: string, options?: any): Express.Static.Handler;
+        export function directory(root: string, options?: any): Handler;
 
         /**
          * Favicon:
@@ -1560,7 +1631,7 @@ declare module Express {
          * @param path
          * @param options
          */
-        favicon(path?: string, options?: any): Express.Static.Handler;
+        export function favicon(path?: string, options?: any): Handler;
 
         /**
          * JSON:
@@ -1576,7 +1647,7 @@ declare module Express {
          *
          * @param options
          */
-        json(options?: any): Express.Static.Handler;
+        export function json(options?: any): Handler;
 
         /**
          * Limit:
@@ -1590,9 +1661,9 @@ declare module Express {
          *       .use(connect.limit('5.5mb'))
          *       .use(handleImageUpload)
          */
-        limit(bytes: number): Express.Static.Handler;
+        export function limit(bytes: number): Handler;
 
-        limit(bytes: string): Express.Static.Handler;
+        export function limit(bytes: string): Handler;
 
         /**
          * Logger:
@@ -1653,18 +1724,18 @@ declare module Express {
          *
          *       connect.logger.format('name', 'string or function')
          */
-        logger(options: string): Express.Static.Handler;
+        export function logger(options: string): Handler;
 
-        logger(options: Function): Express.Static.Handler;
+        export function logger(options: Function): Handler;
 
-        logger(options?: any): Express.Static.Handler;
+        export function logger(options?: any): Handler;
 
         /**
          * Compile `fmt` into a function.
          *
          * @param fmt
          */
-        compile(fmt: string): Express.Static.Handler;
+        export function compile(fmt: string): Handler;
 
         /**
          * Define a token function with the given `name`,
@@ -1673,14 +1744,14 @@ declare module Express {
          * @param name
          * @param fn
          */
-        token(name: string, fn: Function): any;
+        export function token(name: string, fn: Function): any;
 
         /**
          * Define a `fmt` with the given `name`.
          */
-        format(name: string, str: string): any;
+        export function format(name: string, str: string): any;
 
-        format(name: string, str: Function): any;
+        export function format(name: string, str: Function): any;
 
         /**
          * Query:
@@ -1698,7 +1769,7 @@ declare module Express {
          *
          *  The `options` passed are provided to qs.parse function.
          */
-        query(options: any): Express.Static.Handler;
+        export function query(options: any): Handler;
 
         /**
          * Reponse time:
@@ -1706,7 +1777,7 @@ declare module Express {
          * Adds the `X-Response-Time` header displaying the response
          * duration in milliseconds.
          */
-        responseTime(): Express.Static.Handler;
+        export function responseTime(): Handler;
 
         /**
          * Static cache:
@@ -1738,7 +1809,7 @@ declare module Express {
          *   - `maxObjects`  max cache objects [128]
          *   - `maxLength`  max cache object length 256kb
          */
-        staticCache(options: any): Express.Static.Handler;
+        export function staticCache(options: any): Handler;
 
         /**
          * Timeout:
@@ -1751,7 +1822,7 @@ declare module Express {
          * the response behaviour. This error has the `.timeout` property as
          * well as `.status == 408`.
          */
-        timeout(ms: number): Express.Static.Handler;
+        export function timeout(ms: number): Handler;
 
         /**
          * Vhost:
@@ -1769,10 +1840,10 @@ declare module Express {
          * @param hostname
          * @param server
          */
-        vhost(hostname: string, server: any): Express.Static.Handler;
+        export function vhost(hostname: string, server: any): Handler;
 
-        urlencoded(): any;
+        export function urlencoded(): any;
 
-        multipart(): any;
+        export function multipart(): any;
     }
 }
diff --git a/node/node.d.ts b/node/node.d.ts
index f98400c46..edeecf9fa 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -273,15 +273,15 @@ declare module NodeJs {
 
 
     // ---------- "events" module ----------
-    export var Events: Events;
     export interface Events {
-        EventEmitter: Events.EventEmitterStatic;
+        EventEmitter: {
+            (): any // Correctly reflect the fact that this is a (constructor) function, without suggesting that instances can be obtained this way
+            listenerCount(emitter: Events.EventEmitter, event: string): number;
+        }
     }
     export module Events {
-        export interface EventEmitterStatic {
-            listenerCount(emitter: EventEmitter, event: string): number;
-        }
-        export interface EventEmitter extends NodeEventEmitter {
+        export class EventEmitter implements NodeEventEmitter {
+            static listenerCount(emitter: EventEmitter, event: string): number;
             addListener(event: string, listener: Function): EventEmitter;
             on(event: string, listener: Function): EventEmitter;
             once(event: string, listener: Function): EventEmitter;
@@ -386,8 +386,10 @@ declare module NodeJs {
 
 
     // ---------- "cluster" module ----------
-    export var Cluster: Cluster;
     export interface Cluster {
+        // NB: This is necessary duplicataion of the definitions in the Cluster module below. It is required
+        // so that type information is available both through pure types (eg NodeJs.Cluster),
+        // as well as through typed variables (eg var cluster)
         settings: Cluster.ClusterSettings;
         isMaster: boolean;
         isWorker: boolean;
@@ -406,14 +408,37 @@ declare module NodeJs {
         setMaxListeners(n: number): void;
         listeners(event: string): Function[];
         emit(event: string, ...args: any[]): boolean;
+
+        Worker: {
+            (): any // Correctly reflect the fact that this is a (constructor) function, without suggesting that instances can be obtained this way
+        }
     }
     export module Cluster {
+        export var settings: Cluster.ClusterSettings;
+        export var isMaster: boolean;
+        export var isWorker: boolean;
+        export function setupMaster(settings?: Cluster.ClusterSettings): void;
+        export function fork(env?: any): Worker;
+        export function disconnect(callback?: Function): void;
+        export var worker: Worker;
+        export var workers: Worker[];
+
+        // Event emitter
+        export function addListener(event: string, listener: Function): void;
+        export function on(event: string, listener: Function): any;
+        export function once(event: string, listener: Function): void;
+        export function removeListener(event: string, listener: Function): void;
+        export function removeAllListeners(event?: string): void;
+        export function setMaxListeners(n: number): void;
+        export function listeners(event: string): Function[];
+        export function emit(event: string, ...args: any[]): boolean;
+
         export interface ClusterSettings {
             exec?: string;
             args?: string[];
             silent?: boolean;
         }
-        export interface Worker extends Events.EventEmitter {
+        export class Worker extends Events.EventEmitter {
             id: string;
             process: ChildProcess.ChildProcess;
             suicide: boolean;
@@ -1149,7 +1174,6 @@ declare module NodeJs {
 
 
     // ---------- "stream" module ----------
-    export var Stream: Stream;
     export interface Stream {
         Readable: new(opts?: Stream.ReadableOptions) => Stream.Readable;
         Writable: new(opts?: Stream.WritableOptions) => Stream.Writable;
@@ -1162,7 +1186,8 @@ declare module NodeJs {
             encoding?: string;
             objectMode?: boolean;
         }
-        export interface Readable extends Events.EventEmitter, ReadableStream {
+        export class Readable extends Events.EventEmitter implements ReadableStream {
+            constructor(opts?: ReadableOptions);
             readable: boolean;
             _read(size: number): void;
             read(size?: number): any;
@@ -1180,7 +1205,8 @@ declare module NodeJs {
             highWaterMark?: number;
             decodeStrings?: boolean;
         }
-        export interface Writable extends Events.EventEmitter, WritableStream {
+        export class Writable extends Events.EventEmitter implements WritableStream {
+            constructor(opts?: WritableOptions);
             writable: boolean;
             _write(data: NodeBuffer, encoding: string, callback: Function): void;
             _write(data: string, encoding: string, callback: Function): void;
@@ -1197,7 +1223,8 @@ declare module NodeJs {
         }
 
         // Note: Duplex extends both Readable and Writable.
-        export interface Duplex extends Readable, ReadWriteStream {
+        export class Duplex extends Readable implements ReadWriteStream {
+            constructor(opts?: DuplexOptions);
             writable: boolean;
             _write(data: NodeBuffer, encoding: string, callback: Function): void;
             _write(data: string, encoding: string, callback: Function): void;
@@ -1212,7 +1239,8 @@ declare module NodeJs {
         export interface TransformOptions extends ReadableOptions, WritableOptions {}
 
         // Note: Transform lacks the _read and _write methods of Readable/Writable.
-        export interface Transform extends Events.EventEmitter, ReadWriteStream {
+        export class Transform extends Events.EventEmitter implements ReadWriteStream {
+            constructor(opts?: TransformOptions);
             readable: boolean;
             writable: boolean;
             _transform(chunk: NodeBuffer, encoding: string, callback: Function): void;
@@ -1236,7 +1264,7 @@ declare module NodeJs {
             end(str: string, cb?: Function): void;
             end(str: string, encoding?: string, cb?: Function): void;
         }
-        export interface PassThrough extends Transform {}
+        export class PassThrough extends Transform {}
     }
 
 
@@ -1268,7 +1296,6 @@ declare module NodeJs {
 
 
     // ---------- "assert" module ----------
-    export var Assert: Assert;
     export interface Assert {
         (value: any, message?: string): void;
         AssertionError: new(options?: Assert.AssertionErrorOptions) => Assert.AssertionError;
@@ -1303,8 +1330,8 @@ declare module NodeJs {
             operator?: string;
             stackStartFunction?: Function
         }
-        export interface AssertionError extends Error {
-            new(options?: AssertionErrorOptions): AssertionError;
+        export class AssertionError implements Error {
+            constructor(options?: AssertionErrorOptions);
             name: string;
             message: string;
             actual: any;
@@ -1335,13 +1362,12 @@ declare module NodeJs {
 
 
     // ---------- "domain" module ----------
-    export var Domain: Domain;
     export interface Domain {
         Domain: new() => Domain.Domain;
         create(): Domain.Domain;
     }
     export module Domain {
-        export interface Domain extends Events.EventEmitter {
+        export class Domain extends Events.EventEmitter {
             run(fn: Function): void;
             add(emitter: NodeEventEmitter): void;
             remove(emitter: NodeEventEmitter): void;

From f5a20d6c3ed6656c1ec91542626877dc040f857c Mon Sep 17 00:00:00 2001
From: satoru kimura <s_kimura@sa.il24.net>
Date: Sun, 30 Mar 2014 13:47:28 +0900
Subject: [PATCH 230/309] Fixed a problem that causes a conflict when used
 tweenjs and preloadjs at the same time.

---
 preloadjs/preloadjs.d.ts | 7 +++++++
 tweenjs/tweenjs.d.ts     | 7 +++++++
 2 files changed, 14 insertions(+)

diff --git a/preloadjs/preloadjs.d.ts b/preloadjs/preloadjs.d.ts
index f5904fa8c..142e939b6 100644
--- a/preloadjs/preloadjs.d.ts
+++ b/preloadjs/preloadjs.d.ts
@@ -72,11 +72,18 @@ declare module createjs {
         static version: string;
     }
     
+    /*
+        NOTE: It is commented out because it conflicts with SamplePlugin class of TweenJS.
+              this class is mainly for documentation purposes.
+              http://www.createjs.com/Docs/PreloadJS/classes/SamplePlugin.html
+    */
+    /*
     export class SamplePlugin {
         static fileLoadHandler(event: Object): void;
         static getPreloadHandlers(): Object;
         static preloadHandler(src: string, type: string, id: string, data: any, basePath: string, queue: LoadQueue): any;
     }
+    */
 
     export class TagLoader extends AbstractLoader {
         constructor (item: Object);
diff --git a/tweenjs/tweenjs.d.ts b/tweenjs/tweenjs.d.ts
index a53dd8e20..775a05a20 100644
--- a/tweenjs/tweenjs.d.ts
+++ b/tweenjs/tweenjs.d.ts
@@ -75,6 +75,12 @@ declare module createjs {
         static install(): Object;
     }
 
+    /*
+        NOTE: It is commented out because it conflicts with SamplePlugin Class of PreloadJS.
+              this class is mainly for documentation purposes.
+        http://www.createjs.com/Docs/TweenJS/classes/SamplePlugin.html
+    */
+    /*
     export class SamplePlugin {
         constructor();
 
@@ -87,6 +93,7 @@ declare module createjs {
         static install(): void;
         static tween(tween: Tween, prop: string, value: any, startValues: Object, endValues: Object, ratio: number, wait: boolean, end: boolean): any;
     }
+    */
 
     export class Timeline extends EventDispatcher {
         constructor (tweens: Tween[], labels: Object, props: Object);

From c2b67de6aa0241be340ae0873210dbbcadf9a945 Mon Sep 17 00:00:00 2001
From: Troy Gerwien <yortus@gmail.com>
Date: Sun, 30 Mar 2014 21:56:50 +0800
Subject: [PATCH 231/309] Fixed assert, added comments, rechecked all

- Added comments explaining the rationale/method of exposing into both
'type' and 'member' declaration spaces (see TLR 2.3) with example
- Made the pattern consistent in both definition files
- Fixed "assert" by adding 'export function Assert...'
- Triple-checked with DT tests and additional tests
---
 express/express.d.ts | 15 +++++++-
 node/node.d.ts       | 87 +++++++++++++++++++++++++++++---------------
 2 files changed, 71 insertions(+), 31 deletions(-)

diff --git a/express/express.d.ts b/express/express.d.ts
index f88df016b..dc18cc58e 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -17,7 +17,19 @@ declare module "express" {
     export = _;
 }
 declare module Express {
-    export function Static(): Static.Express;
+    // NB: All typings in Express.Static are exposed in dual declaration spaces
+    // (i.e. as 'types' and as 'members' - see TypeScript Language Spec section 2.3)
+    // so that type information is available in both of the following scenarios:
+    //
+    //          // Normal import:
+    //          import express = require('express');
+    //          var app = express();
+    //          app.use(express.urlencoded());
+    //
+    //          // Typed variable:
+    //          var express: Express.Static = someExpr() // a wrapped, mocked or otherwise obtained ref
+    //          var app = express();
+    //          app.use(express.urlencoded());
     export interface Static {
         (): Static.Express;
         Route: new (method: string, path: string, callbacks: Function[], options: any) => Static.Route;
@@ -55,6 +67,7 @@ declare module Express {
         urlencoded(): any;
         multipart(): any;
     }
+    export function Static(): Static.Express;
     export module Static {
 
         interface IRoute {
diff --git a/node/node.d.ts b/node/node.d.ts
index edeecf9fa..b84ef7912 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -259,23 +259,34 @@ declare module "domain"         { import _ = NodeJs.Domain;         export = _;
 ************************************************/
 
 declare module NodeJs {
+    // NB: All typings in this namespace are exposed in dual declaration spaces
+    // (i.e. as 'types' and as 'members' - see TypeScript Language Spec section 2.3)
+    // so that type information is available in both of the following scenarios:
+    //
+    //          // Normal import:
+    //          import http = require('http');
+    //          http.createServer((req, res) => {...})
+    //
+    //          // Typed variable:
+    //          var http: NodeJs.Http = someExpr() // a wrapped, mocked or otherwise obtained ref
+    //          http.createServer((req, res) => {...})
 
 
     // ---------- "querystring" module ----------
-    export var QueryString: QueryString;
     export interface QueryString {
         stringify(obj: any, sep?: string, eq?: string): string;
         parse(str: string, sep?: string, eq?: string, options?: { maxKeys?: number; }): any;
         escape(): any;
         unescape(): any;
     }
-    export module QueryString { }
+    export var QueryString: QueryString;
 
 
     // ---------- "events" module ----------
     export interface Events {
         EventEmitter: {
-            (): any // Correctly reflect the fact that this is a (constructor) function, without suggesting that instances can be obtained this way
+            (): any // Correctly reflect the fact that this is a (constructor) function,
+                    // without suggesting that instances can be obtained this way
             listenerCount(emitter: Events.EventEmitter, event: string): number;
         }
     }
@@ -295,7 +306,6 @@ declare module NodeJs {
 
 
     // ---------- "http" module ----------
-    export var Http: Http;
     export interface Http {
         STATUS_CODES: any;
         createServer(requestListener?: (request: Http.ServerRequest, response: Http.ServerResponse) =>void ): Http.Server;
@@ -304,6 +314,7 @@ declare module NodeJs {
         get(options: any, callback?: Function): Http.ClientRequest;
         globalAgent: Http.Agent;
     }
+    export var Http: Http;
     export module Http {
         export interface Server extends NodeEventEmitter {
             listen(port: number, hostname?: string, backlog?: number, callback?: Function): void;
@@ -387,9 +398,6 @@ declare module NodeJs {
 
     // ---------- "cluster" module ----------
     export interface Cluster {
-        // NB: This is necessary duplicataion of the definitions in the Cluster module below. It is required
-        // so that type information is available both through pure types (eg NodeJs.Cluster),
-        // as well as through typed variables (eg var cluster)
         settings: Cluster.ClusterSettings;
         isMaster: boolean;
         isWorker: boolean;
@@ -451,7 +459,6 @@ declare module NodeJs {
 
 
     // ---------- "zlib" module ----------
-    export var Zlib: Zlib;
     export interface Zlib {
         createGzip(options?: Zlib.ZlibOptions): Zlib.Gzip;
         createGunzip(options?: Zlib.ZlibOptions): Zlib.Gunzip;
@@ -502,6 +509,7 @@ declare module NodeJs {
         Z_DEFLATED: number;
         Z_NULL: number;
     }
+    export var Zlib: Zlib;
     export module Zlib {
         export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; }
         export interface Gzip extends ReadWriteStream { }
@@ -515,7 +523,6 @@ declare module NodeJs {
 
 
     // ---------- "os" module ----------
-    export var Os: Os;
     export interface Os {
         tmpDir(): string;
         hostname(): string;
@@ -531,11 +538,10 @@ declare module NodeJs {
         networkInterfaces(): any;
         EOL: string;
     }
-    export module Os { }
+    export var Os: Os;
 
 
     // ---------- "https" module ----------
-    export var Https: Https;
     export interface Https {
         Agent: new(options?: Https.RequestOptions) => Https.Agent;
 
@@ -544,6 +550,7 @@ declare module NodeJs {
         get(options: Https.RequestOptions, callback?: (res: NodeEventEmitter) => void): Http.ClientRequest;
         globalAgent: Https.Agent;
     }
+    export var Https: Https;
     export module Https {
         export interface ServerOptions {
             pfx?: any;
@@ -586,7 +593,6 @@ declare module NodeJs {
 
 
     // ---------- "punycode" module ----------
-    export var PunyCode: PunyCode;
     export interface PunyCode {
         decode(string: string): string;
         encode(string: string): string;
@@ -598,14 +604,14 @@ declare module NodeJs {
         }
         version: any;
     }
-    export module PunyCode { }
+    export var PunyCode: PunyCode;
 
 
     // ---------- "repl" module ----------
-    export var Repl: Repl;
     export interface Repl {
         start(options: Repl.ReplOptions): NodeEventEmitter;
     }
+    export var Repl: Repl;
     export module Repl {
         export interface ReplOptions {
             prompt?: string;
@@ -622,10 +628,10 @@ declare module NodeJs {
 
 
     // ---------- "readline" module ----------
-    export var ReadLine: ReadLine;
     export interface ReadLine {
         createInterface(options: ReadLine.ReadLineOptions): ReadLine.ReadLine;
     }
+    export var ReadLine: ReadLine;
     export module ReadLine {
         export interface ReadLine extends NodeEventEmitter {
             setPrompt(prompt: string, length: number): void;
@@ -646,7 +652,6 @@ declare module NodeJs {
 
 
     // ---------- "vm" module ----------
-    export var Vm: Vm;
     export interface Vm {
         runInThisContext(code: string, filename?: string): void;
         runInNewContext(code: string, sandbox?: Vm.Context, filename?: string): void;
@@ -654,6 +659,7 @@ declare module NodeJs {
         createContext(initSandbox?: Vm.Context): Vm.Context;
         createScript(code: string, filename?: string): Vm.Script;
     }
+    export var Vm: Vm;
     export module Vm {
         export interface Context { }
         export interface Script {
@@ -664,7 +670,6 @@ declare module NodeJs {
 
 
     // ---------- "child_process" module ----------
-    export var ChildProcess: ChildProcess;
     export interface ChildProcess {
         spawn(command: string, args?: string[], options?: {
             cwd?: string;
@@ -700,6 +705,7 @@ declare module NodeJs {
             encoding?: string;
         }): ChildProcess.ChildProcess;
     }
+    export var ChildProcess: ChildProcess;
     export module ChildProcess {
         export interface ChildProcess extends NodeEventEmitter {
             stdin: WritableStream;
@@ -714,12 +720,12 @@ declare module NodeJs {
 
 
     // ---------- "url" module ----------
-    export var Url: Url;
     export interface Url {
         parse(urlStr: string, parseQueryString?: boolean , slashesDenoteHost?: boolean ): Url.Url;
         format(url: Url.UrlOptions): string;
         resolve(from: string, to: string): string;
     }
+    export var Url: Url;
     export module Url {
         export interface Url {
             href: string;
@@ -747,7 +753,6 @@ declare module NodeJs {
 
 
     // ---------- "dns" module ----------
-    export var Dns: Dns;
     export interface Dns {
         lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string;
         lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string;
@@ -762,11 +767,10 @@ declare module NodeJs {
         resolveCname(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
         reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[];
     }
-    export module Dns { }
+    export var Dns: Dns;
 
 
     // ---------- "net" module ----------
-    export var Net: Net;
     export interface Net {
         Socket: new(options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }) => Net.Socket;
 
@@ -782,6 +786,7 @@ declare module NodeJs {
         isIPv4(input: string): boolean;
         isIPv6(input: string): boolean;
     }
+    export var Net: Net;
     export module Net {
         export interface Socket extends ReadWriteStream {
 
@@ -829,10 +834,10 @@ declare module NodeJs {
 
 
     // ---------- "dgram" module ----------
-    export var Dgram: Dgram;
     export interface Dgram {
         createSocket(type: string, callback?: Function): Dgram.Socket;
     }
+    export var Dgram: Dgram;
     export module Dgram {
         interface Socket extends NodeEventEmitter {
             send(buf: NodeBuffer, offset: number, length: number, port: number, address: string, callback?: Function): void;
@@ -849,7 +854,6 @@ declare module NodeJs {
 
 
     // ---------- "fs" module ----------
-    export var Fs: Fs;
     export interface Fs {
         rename(oldPath: string, newPath: string, callback?: (err?: ErrnoException) => void): void;
         renameSync(oldPath: string, newPath: string): void;
@@ -964,6 +968,7 @@ declare module NodeJs {
             string?: string;
         }): Fs.WriteStream;
     }
+    export var Fs: Fs;
     export module Fs {
         export interface Stats {
             isFile(): boolean;
@@ -996,7 +1001,6 @@ declare module NodeJs {
 
 
     // ---------- "path" module ----------
-    export var Path: Path;
     export interface Path {
         normalize(p: string): string;
         join(...paths: any[]): string;
@@ -1007,14 +1011,14 @@ declare module NodeJs {
         extname(p: string): string;
         sep: string;
     }
-    export module Path { }
+    export var Path: Path;
 
 
     // ---------- "string_decoder" module ----------
-    export var StringDecoder: StringDecoder;
     export interface StringDecoder {
         StringDecoder: new(encoding: string) => StringDecoder.StringDecoder;
     }
+    export var StringDecoder: StringDecoder;
     export module StringDecoder {
         export interface StringDecoder {
             write(buffer: NodeBuffer): string;
@@ -1024,7 +1028,6 @@ declare module NodeJs {
 
 
     // ---------- "tls" module ----------
-    export var Tls: Tls;
     export interface Tls {
         CLIENT_RENEG_LIMIT: number;
         CLIENT_RENEG_WINDOW: number;
@@ -1034,6 +1037,7 @@ declare module NodeJs {
         connect(port: number, options?: Tls.ConnectionOptions, secureConnectListener?: () =>void ): Tls.ClearTextStream;
         createSecurePair(credentials?: Crypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): Tls.SecurePair;
     }
+    export var Tls: Tls;
     export module Tls {
         export interface TlsOptions {
             pfx?: any;   //string or buffer
@@ -1103,7 +1107,6 @@ declare module NodeJs {
 
 
     // ---------- "crypto" module ----------
-    export var Crypto: Crypto;
     export interface Crypto {
         createCredentials(details: Crypto.CredentialDetails): Crypto.Credentials;
         createHash(algorithm: string): Crypto.Hash;
@@ -1121,6 +1124,7 @@ declare module NodeJs {
         pseudoRandomBytes(size: number): NodeBuffer;
         pseudoRandomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
     }
+    export var Crypto: Crypto;
     export module Crypto {
         export interface CredentialDetails {
             pfx: string;
@@ -1269,7 +1273,6 @@ declare module NodeJs {
 
 
     // ---------- "util" module ----------
-    export var Util: Util;
     export interface Util {
         format(format: any, ...param: any[]): string;
         debug(string: string): void;
@@ -1285,6 +1288,7 @@ declare module NodeJs {
         isError(object: any): boolean;
         inherits(constructor: any, superConstructor: any): void;
     }
+    export var Util: Util;
     export module Util {
         export interface InspectOptions {
             showHidden?: boolean;
@@ -1322,7 +1326,30 @@ declare module NodeJs {
         }
         ifError(value: any): void;
     }
+    export function Assert(value: any, message?: string): void;
     export module Assert {
+        export function fail(actual?: any, expected?: any, message?: string, operator?: string): void;
+        export function ok(value: any, message?: string): void;
+        export function equal(actual: any, expected: any, message?: string): void;
+        export function notEqual(actual: any, expected: any, message?: string): void;
+        export function deepEqual(actual: any, expected: any, message?: string): void;
+        export function notDeepEqual(acutal: any, expected: any, message?: string): void;
+        export function strictEqual(actual: any, expected: any, message?: string): void;
+        export function notStrictEqual(actual: any, expected: any, message?: string): void;
+        export var throws: {
+            (block: Function, message?: string): void;
+            (block: Function, error: Function, message?: string): void;
+            (block: Function, error: RegExp, message?: string): void;
+            (block: Function, error: (err: any) => boolean, message?: string): void;
+        }
+        export var doesNotThrow: {
+            (block: Function, message?: string): void;
+            (block: Function, error: Function, message?: string): void;
+            (block: Function, error: RegExp, message?: string): void;
+            (block: Function, error: (err: any) => boolean, message?: string): void;
+        }
+        export function ifError(value: any): void;
+
         export interface AssertionErrorOptions {
             message?: string;
             actual?: any;
@@ -1343,12 +1370,12 @@ declare module NodeJs {
 
 
     // ---------- "tty" module ----------
-    export var Tty: Tty;
     export interface Tty {
         ReadStream: new() => Tty.ReadStream;
         WriteStream: new() => Tty.WriteStream;
         isatty(fd: number): boolean;
     }
+    export var Tty: Tty;
     export module Tty {
         export interface ReadStream extends Net.Socket {
             isRaw: boolean;

From 6a320ef21154df84894960f1a155ef733a9e04da Mon Sep 17 00:00:00 2001
From: yortus <yortus@gmail.com>
Date: Mon, 31 Mar 2014 11:10:37 +0800
Subject: [PATCH 232/309] EventEmitter can be new()d

---
 node/node.d.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/node/node.d.ts b/node/node.d.ts
index b84ef7912..25e6c45f2 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -285,8 +285,7 @@ declare module NodeJs {
     // ---------- "events" module ----------
     export interface Events {
         EventEmitter: {
-            (): any // Correctly reflect the fact that this is a (constructor) function,
-                    // without suggesting that instances can be obtained this way
+            new(): Events.EventEmitter;
             listenerCount(emitter: Events.EventEmitter, event: string): number;
         }
     }
@@ -418,7 +417,8 @@ declare module NodeJs {
         emit(event: string, ...args: any[]): boolean;
 
         Worker: {
-            (): any // Correctly reflect the fact that this is a (constructor) function, without suggesting that instances can be obtained this way
+            (): any;    // Correctly reflect the fact that this is a (constructor) function,
+                        // without suggesting that instances can be obtained this way
         }
     }
     export module Cluster {

From 69bd32f4c1cadfa49e2a223373c72c6c59a9c37c Mon Sep 17 00:00:00 2001
From: yortus <yortus@gmail.com>
Date: Mon, 31 Mar 2014 15:18:53 +0800
Subject: [PATCH 233/309] pure internal modules + external shim

- The top-level modules Express and NodeJs are now 'pure' ie
non-instantiated, due to removal of all vars, functions, and classes
- Where the above change breaks existing typings which access types via
external module references, a shim has been added to make this continue
working unchanged
- A single namespace _ExternalShim_ is added but this can be reused
across all typings that need shimming
---
 express/express.d.ts | 3517 +++++++++++++++++++++---------------------
 node/node.d.ts       |  218 ++-
 2 files changed, 1863 insertions(+), 1872 deletions(-)

diff --git a/express/express.d.ts b/express/express.d.ts
index dc18cc58e..2f1bdeee2 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -12,1851 +12,1854 @@
 
 /// <reference path="../node/node.d.ts" />
 
+
+/************************************************
+*                                               *
+*                EXTERNAL MODULE                *
+*                                               *
+************************************************/
+
 declare module "express" {
-    import _ = Express.Static;
-    export = _;
+    import M = _ExternalShim_._Express_;
+    export = M;
 }
+
+
+/************************************************
+*                                               *
+*           EXTERNAL - INTERNAL SHIM            *
+*                                               *
+************************************************/
+
+// NB: This module exists so that 'pure' (ie non-instantiated) internal modules may
+// be declared in parallel with external modules, without breaking code that relies
+// on certain behaviours of external modules. It's a shim to support type definitions
+// that are already out there which use the pattern exemplified below:
+//
+//      declare module "mymodule" {
+//          import express   = require('express');
+//          ...
+//          request?: express.Request;
+//
+// Note that the type 'Request' is accessed via the variable 'express', meaning that
+// Request must be not just a type, but also a property on 'express'. The 'pure' typings
+// declared in the Express module below don't support this usage. With the _ExternalTypes_
+// shim, the above code will continue working unchanged. New type definitions should
+// prefer something like:
+//
+//      declare module "mymodule" {
+//          ...
+//          request?: Express.Request;
+//
+// If all typings switch to using the pure internal types in Express, this shim can be removed.
+declare module _ExternalShim_ {
+    export var _Express_: Express;
+    export module _Express_ {
+        export interface Request extends Express.Request { }
+        export interface Response extends Express.Response { }
+        export interface Express extends Express.Express { }
+        export interface Application extends Express.Application { }
+    }
+}
+
+
+/************************************************
+*                                               *
+*                INTERNAL MODULE                *
+*                                               *
+************************************************/
+
 declare module Express {
-    // NB: All typings in Express.Static are exposed in dual declaration spaces
-    // (i.e. as 'types' and as 'members' - see TypeScript Language Spec section 2.3)
-    // so that type information is available in both of the following scenarios:
-    //
-    //          // Normal import:
-    //          import express = require('express');
-    //          var app = express();
-    //          app.use(express.urlencoded());
-    //
-    //          // Typed variable:
-    //          var express: Express.Static = someExpr() // a wrapped, mocked or otherwise obtained ref
-    //          var app = express();
-    //          app.use(express.urlencoded());
-    export interface Static {
-        (): Static.Express;
-        Route: new (method: string, path: string, callbacks: Function[], options: any) => Static.Route;
-        Router: new (options?: any) => Static.Router;
-        bodyParser(options?: any): Static.Handler;
-        errorHandler(opts?: any): Static.Handler;
-        methodOverride(key?: string): Static.Handler;
-        cookieParser(secret?: string): Static.Handler;
-        session(options?: any): Static.Handler;
-        hash(sess: string): string;
-        static(root: string, options?: any): Static.Handler;
-        basicAuth(callback: (user: string, pass: string, fn : Function) => void, realm?: string): Static.Handler;
-        basicAuth(callback: (user: string, pass: string) => boolean, realm?: string): Static.Handler;
-        basicAuth(user: string, pass: string, realm?: string): Static.Handler;
-        compress(options?: any): Static.Handler;
-        cookieSession(options?: any): Static.Handler;
-        csrf(options?: {value?: Function}): Static.Handler;
-        directory(root: string, options?: any): Static.Handler;
-        favicon(path?: string, options?: any): Static.Handler;
-        json(options?: any): Static.Handler;
-        limit(bytes: number): Static.Handler;
-        limit(bytes: string): Static.Handler;
-        logger(options: string): Static.Handler;
-        logger(options: Function): Static.Handler;
-        logger(options?: any): Static.Handler;
-        compile(fmt: string): Static.Handler;
-        token(name: string, fn: Function): any;
-        format(name: string, str: string): any;
-        format(name: string, str: Function): any;
-        query(options: any): Static.Handler;
-        responseTime(): Static.Handler;
-        staticCache(options: any): Static.Handler;
-        timeout(ms: number): Static.Handler;
-        vhost(hostname: string, server: any): Static.Handler;
-        urlencoded(): any;
-        multipart(): any;
+
+    export interface IRoute {
+        path: string;
+
+        method: string;
+
+        callbacks: Function[];
+
+        regexp: any;
+
+        /**
+        * Check if this route matches `path`, if so
+        * populate `.params`.
+        */
+        match(path: string): boolean;
     }
-    export function Static(): Static.Express;
-    export module Static {
 
-        interface IRoute {
-            path: string;
+    export interface Route extends IRoute {
+        path: string;
 
-            method: string;
+        method: string;
 
-            callbacks: Function[];
+        callbacks: Function[];
 
-            regexp: any;
+        regexp: any;
+        match(path: string): boolean;
+    }
 
-            /**
-            * Check if this route matches `path`, if so
-            * populate `.params`.
+    export interface IRouter<T> {
+        /**
+            * Map the given param placeholder `name`(s) to the given callback(s).
+            *
+            * Parameter mapping is used to provide pre-conditions to routes
+            * which use normalized placeholders. For example a _:user_id_ parameter
+            * could automatically load a user's information from the database without
+            * any additional code,
+            *
+            * The callback uses the samesignature as middleware, the only differencing
+            * being that the value of the placeholder is passed, in this case the _id_
+            * of the user. Once the `next()` function is invoked, just like middleware
+            * it will continue on to execute the route, or subsequent parameter functions.
+            *
+            *      app.param('user_id', function(req, res, next, id){
+            *        User.find(id, function(err, user){
+            *          if (err) {
+            *            next(err);
+            *          } else if (user) {
+            *            req.user = user;
+            *            next();
+            *          } else {
+            *            next(new Error('failed to load user'));
+            *          }
+            *        });
+            *      });
+            *
+            * @param name
+            * @param fn
             */
-            match(path: string): boolean;
-        }
+        param(name: string, fn: Function): T;
 
-        class Route implements IRoute {
-            path: string;
+        param(name: string[], fn: Function): T;
 
-            method: string;
+        /**
+            * Special-cased "all" method, applying the given route `path`,
+            * middleware, and callback to _every_ HTTP method.
+            *
+            * @param path
+            * @param fn
+            */
+        all(path: string, fn?: (req: Request, res: Response, next: Function) => any): T;
 
-            callbacks: Function[];
+        all(path: string, ...callbacks: Function[]): void;
 
-            regexp: any;
-            match(path: string): boolean;
+        get(name: string, ...handlers: RequestFunction[]): T;
 
-            /**
-             * Initialize `Route` with the given HTTP `method`, `path`,
-             * and an array of `callbacks` and `options`.
-             *
-             * Options:
-             *
-             *   - `sensitive`    enable case-sensitive routes
-             *   - `strict`       enable strict matching for trailing slashes
-             *
-             * @param method
-             * @param path
-             * @param callbacks
-             * @param options
-             */
-            constructor (method: string, path: string, callbacks: Function[], options: any);
-        }
+        get(name: RegExp, ...handlers: RequestFunction[]): T;
 
-        interface IRouter<T> {
-            /**
-             * Map the given param placeholder `name`(s) to the given callback(s).
-             *
-             * Parameter mapping is used to provide pre-conditions to routes
-             * which use normalized placeholders. For example a _:user_id_ parameter
-             * could automatically load a user's information from the database without
-             * any additional code,
-             *
-             * The callback uses the samesignature as middleware, the only differencing
-             * being that the value of the placeholder is passed, in this case the _id_
-             * of the user. Once the `next()` function is invoked, just like middleware
-             * it will continue on to execute the route, or subsequent parameter functions.
-             *
-             *      app.param('user_id', function(req, res, next, id){
-             *        User.find(id, function(err, user){
-             *          if (err) {
-             *            next(err);
-             *          } else if (user) {
-             *            req.user = user;
-             *            next();
-             *          } else {
-             *            next(new Error('failed to load user'));
-             *          }
-             *        });
-             *      });
-             *
-             * @param name
-             * @param fn
-             */
-            param(name: string, fn: Function): T;
+        post(name: string, ...handlers: RequestFunction[]): T;
 
-            param(name: string[], fn: Function): T;
+        post(name: RegExp, ...handlers: RequestFunction[]): T;
 
-            /**
-             * Special-cased "all" method, applying the given route `path`,
-             * middleware, and callback to _every_ HTTP method.
-             *
-             * @param path
-             * @param fn
-             */
-            all(path: string, fn?: (req: Request, res: Response, next: Function) => any): T;
+        put(name: string, ...handlers: RequestFunction[]): T;
 
-            all(path: string, ...callbacks: Function[]): void;
+        put(name: RegExp, ...handlers: RequestFunction[]): T;
 
-            get(name: string, ...handlers: RequestFunction[]): T;
+        del(name: string, ...handlers: RequestFunction[]): T;
 
-            get(name: RegExp, ...handlers: RequestFunction[]): T;
-
-            post(name: string, ...handlers: RequestFunction[]): T;
-
-            post(name: RegExp, ...handlers: RequestFunction[]): T;
-
-            put(name: string, ...handlers: RequestFunction[]): T;
-
-            put(name: RegExp, ...handlers: RequestFunction[]): T;
-
-            del(name: string, ...handlers: RequestFunction[]): T;
-
-            del(name: RegExp, ...handlers: RequestFunction[]): T;
+        del(name: RegExp, ...handlers: RequestFunction[]): T;
             
-            patch(name: string, ...handlers: RequestFunction[]): T;
+        patch(name: string, ...handlers: RequestFunction[]): T;
  
-            patch(name: RegExp, ...handlers: RequestFunction[]): T;
-        }
+        patch(name: RegExp, ...handlers: RequestFunction[]): T;
+    }
 
-        export class Router implements IRouter<Router> {
-            constructor (options?: any);
+    export interface Router extends IRouter<Router> {
+        middleware (): any;
 
-            middleware (): any;
+        param(name: string, fn: Function): Router;
 
-            param(name: string, fn: Function): Router;
+        param(name: any[], fn: Function): Router;
 
-            param(name: any[], fn: Function): Router;
+        all(path: string, fn?: (req: Request, res: Response, next: Function) => any): Router;
 
-            all(path: string, fn?: (req: Request, res: Response, next: Function) => any): Router;
+        all(path: string, ...callbacks: Function[]): void;
 
-            all(path: string, ...callbacks: Function[]): void;
+        get(name: string, ...handlers: RequestFunction[]): Router;
 
-            get(name: string, ...handlers: RequestFunction[]): Router;
+        get(name: RegExp, ...handlers: RequestFunction[]): Router;
 
-            get(name: RegExp, ...handlers: RequestFunction[]): Router;
+        post(name: string, ...handlers: RequestFunction[]): Router;
 
-            post(name: string, ...handlers: RequestFunction[]): Router;
+        post(name: RegExp, ...handlers: RequestFunction[]): Router;
 
-            post(name: RegExp, ...handlers: RequestFunction[]): Router;
+        put(name: string, ...handlers: RequestFunction[]): Router;
 
-            put(name: string, ...handlers: RequestFunction[]): Router;
+        put(name: RegExp, ...handlers: RequestFunction[]): Router;
 
-            put(name: RegExp, ...handlers: RequestFunction[]): Router;
+        del(name: string, ...handlers: RequestFunction[]): Router;
 
-            del(name: string, ...handlers: RequestFunction[]): Router;
-
-            del(name: RegExp, ...handlers: RequestFunction[]): Router;
+        del(name: RegExp, ...handlers: RequestFunction[]): Router;
           
-            patch(name: string, ...handlers: RequestFunction[]): Router;
+        patch(name: string, ...handlers: RequestFunction[]): Router;
  
-            patch(name: RegExp, ...handlers: RequestFunction[]): Router;
-        }
-
-        export interface Handler {
-            (req: Request, res: Response, next?: Function): void;
-        }
-
-        export interface CookieOptions {
-            maxAge?: number;
-            signed?: boolean;
-            expires?: Date;
-            httpOnly?: boolean;
-            path?: string;
-            domain?: string;
-            secure?: boolean;
-        }
-
-        export interface Errback { (err: Error): void; }
-
-        export interface Session {
-            /**
-             * Update reset `.cookie.maxAge` to prevent
-             * the cookie from expiring when the
-             * session is still active.
-             *
-             * @return {Session} for chaining
-             * @api public
-             */
-            touch(): Session;
-
-            /**
-             * Reset `.maxAge` to `.originalMaxAge`.
-             */
-            resetMaxAge(): Session;
-
-            /**
-             * Save the session data with optional callback `fn(err)`.
-             */
-            save(fn: Function): Session;
-
-            /**
-             * Re-loads the session data _without_ altering
-             * the maxAge properties. Invokes the callback `fn(err)`,
-             * after which time if no exception has occurred the
-             * `req.session` property will be a new `Session` object,
-             * although representing the same session.
-             */
-            reload(fn: Function): Session;
-
-            /**
-             * Destroy `this` session.
-             */
-            destroy(fn: Function): Session;
-
-            /**
-             * Regenerate this request's session.
-             */
-            regenerate(fn: Function): Session;
-
-            user: any;
-
-            error: string;
-
-            success: string;
-
-            views: any;
-
-            count: number;
-        }
-
-        export interface Request {
-
-            session: Session;
-
-            /**
-             * Return request header.
-             *
-             * The `Referrer` header field is special-cased,
-             * both `Referrer` and `Referer` are interchangeable.
-             *
-             * Examples:
-             *
-             *     req.get('Content-Type');
-             *     // => "text/plain"
-             *
-             *     req.get('content-type');
-             *     // => "text/plain"
-             *
-             *     req.get('Something');
-             *     // => undefined
-             *
-             * Aliased as `req.header()`.
-             *
-             * @param name
-             */
-            get (name: string): string;
-
-            header(name: string): string;
-
-            headers: string[];
-
-            /**
-             * Check if the given `type(s)` is acceptable, returning
-             * the best match when true, otherwise `undefined`, in which
-             * case you should respond with 406 "Not Acceptable".
-             *
-             * The `type` value may be a single mime type string
-             * such as "application/json", the extension name
-             * such as "json", a comma-delimted list such as "json, html, text/plain",
-             * or an array `["json", "html", "text/plain"]`. When a list
-             * or array is given the _best_ match, if any is returned.
-             *
-             * Examples:
-             *
-             *     // Accept: text/html
-             *     req.accepts('html');
-             *     // => "html"
-             *
-             *     // Accept: text/*, application/json
-             *     req.accepts('html');
-             *     // => "html"
-             *     req.accepts('text/html');
-             *     // => "text/html"
-             *     req.accepts('json, text');
-             *     // => "json"
-             *     req.accepts('application/json');
-             *     // => "application/json"
-             *
-             *     // Accept: text/*, application/json
-             *     req.accepts('image/png');
-             *     req.accepts('png');
-             *     // => undefined
-             *
-             *     // Accept: text/*;q=.5, application/json
-             *     req.accepts(['html', 'json']);
-             *     req.accepts('html, json');
-             *     // => "json"
-             */
-            accepts(type: string): string;
-
-            accepts(type: string[]): string;
-
-            /**
-             * Check if the given `charset` is acceptable,
-             * otherwise you should respond with 406 "Not Acceptable".
-             *
-             * @param charset
-             */
-            acceptsCharset(charset: string): boolean;
-
-            /**
-             * Check if the given `lang` is acceptable,
-             * otherwise you should respond with 406 "Not Acceptable".
-             *
-             * @param lang
-             */
-            acceptsLanguage(lang: string): boolean;
-
-            /**
-             * Parse Range header field,
-             * capping to the given `size`.
-             *
-             * Unspecified ranges such as "0-" require
-             * knowledge of your resource length. In
-             * the case of a byte range this is of course
-             * the total number of bytes. If the Range
-             * header field is not given `null` is returned,
-             * `-1` when unsatisfiable, `-2` when syntactically invalid.
-             *
-             * NOTE: remember that ranges are inclusive, so
-             * for example "Range: users=0-3" should respond
-             * with 4 users when available, not 3.
-             *
-             * @param size
-             */
-            range(size: number): any[];
-
-            /**
-             * Return an array of Accepted media types
-             * ordered from highest quality to lowest.
-             */
-            accepted: MediaType[];
-
-            /**
-             * Return an array of Accepted languages
-             * ordered from highest quality to lowest.
-             *
-             * Examples:
-             *
-             *     Accept-Language: en;q=.5, en-us
-             *     ['en-us', 'en']
-             */
-            acceptedLanguages: any[];
-
-            /**
-             * Return an array of Accepted charsets
-             * ordered from highest quality to lowest.
-             *
-             * Examples:
-             *
-             *     Accept-Charset: iso-8859-5;q=.2, unicode-1-1;q=0.8
-             *     ['unicode-1-1', 'iso-8859-5']
-             */
-            acceptedCharsets: any[];
-
-            /**
-             * Return the value of param `name` when present or `defaultValue`.
-             *
-             *  - Checks route placeholders, ex: _/user/:id_
-             *  - Checks body params, ex: id=12, {"id":12}
-             *  - Checks query string params, ex: ?id=12
-             *
-             * To utilize request bodies, `req.body`
-             * should be an object. This can be done by using
-             * the `connect.bodyParser()` middleware.
-             *
-             * @param name
-             * @param defaultValue
-             */
-            param(name: string, defaultValue?: any): string;
-
-            /**
-             * Check if the incoming request contains the "Content-Type"
-             * header field, and it contains the give mime `type`.
-             *
-             * Examples:
-             *
-             *      // With Content-Type: text/html; charset=utf-8
-             *      req.is('html');
-             *      req.is('text/html');
-             *      req.is('text/*');
-             *      // => true
-             *
-             *      // When Content-Type is application/json
-             *      req.is('json');
-             *      req.is('application/json');
-             *      req.is('application/*');
-             *      // => true
-             *
-             *      req.is('html');
-             *      // => false
-             *
-             * @param type
-             */
-            is(type: string): boolean;
-
-            /**
-             * Return the protocol string "http" or "https"
-             * when requested with TLS. When the "trust proxy"
-             * setting is enabled the "X-Forwarded-Proto" header
-             * field will be trusted. If you're running behind
-             * a reverse proxy that supplies https for you this
-             * may be enabled.
-             */
-            protocol: string;
-
-            /**
-             * Short-hand for:
-             *
-             *    req.protocol == 'https'
-             */
-            secure: boolean;
-
-            /**
-             * Return the remote address, or when
-             * "trust proxy" is `true` return
-             * the upstream addr.
-             */
-            ip: string;
-
-            /**
-             * When "trust proxy" is `true`, parse
-             * the "X-Forwarded-For" ip address list.
-             *
-             * For example if the value were "client, proxy1, proxy2"
-             * you would receive the array `["client", "proxy1", "proxy2"]`
-             * where "proxy2" is the furthest down-stream.
-             */
-            ips: string[];
-
-            /**
-             * Return basic auth credentials.
-             *
-             * Examples:
-             *
-             *    // http://tobi:hello@example.com
-             *    req.auth
-             *    // => { username: 'tobi', password: 'hello' }
-             */
-            auth: any;
-
-            /**
-             * Return subdomains as an array.
-             *
-             * Subdomains are the dot-separated parts of the host before the main domain of
-             * the app. By default, the domain of the app is assumed to be the last two
-             * parts of the host. This can be changed by setting "subdomain offset".
-             *
-             * For example, if the domain is "tobi.ferrets.example.com":
-             * If "subdomain offset" is not set, req.subdomains is `["ferrets", "tobi"]`.
-             * If "subdomain offset" is 3, req.subdomains is `["tobi"]`.
-             */
-            subdomains: string[];
-
-            /**
-             * Short-hand for `url.parse(req.url).pathname`.
-             */
-            path: string;
-
-            /**
-             * Parse the "Host" header field hostname.
-             */
-            host: string;
-
-            /**
-             * Check if the request is fresh, aka
-             * Last-Modified and/or the ETag
-             * still match.
-             */
-            fresh: boolean;
-
-            /**
-             * Check if the request is stale, aka
-             * "Last-Modified" and / or the "ETag" for the
-             * resource has changed.
-             */
-            stale: boolean;
-
-            /**
-             * Check if the request was an _XMLHttpRequest_.
-             */
-            xhr: boolean;
-
-            //body: { username: string; password: string; remember: boolean; title: string; };
-            body: any;
-
-            //cookies: { string; remember: boolean; };
-            cookies: any;
-
-            /**
-             * Used to generate an anti-CSRF token.
-             * Placed by the CSRF protection middleware.
-             */
-            csrfToken(): string;
-
-            method: string;
-
-            params: any;
-
-            user: any;
-
-            authenticatedUser: any;
-
-            files: any;
-
-            /**
-             * Clear cookie `name`.
-             *
-             * @param name
-             * @param options
-             */
-            clearCookie(name: string, options?: any): Response;
-
-            query: any;
-
-            route: any;
-
-            signedCookies: any;
-
-            originalUrl: string;
-
-            url: string;
-        }
-
-        export interface MediaType {
-            value: string;
-            quality: number;
-            type: string;
-            subtype:  string;
-        }
-
-        export interface Send {
-            (status: number, body?: any): Response;
-            (body: any): Response;
-        }
-
-        export interface Response extends NodeJs.Http.ServerResponse {
-            /**
-             * Set status `code`.
-             *
-             * @param code
-             */
-            status(code: number): Response;
-
-            /**
-             * Set Link header field with the given `links`.
-             *
-             * Examples:
-             *
-             *    res.links({
-             *      next: 'http://api.example.com/users?page=2',
-             *      last: 'http://api.example.com/users?page=5'
-             *    });
-             *
-             * @param links
-             */
-            links(links: any): Response;
-
-            /**
-             * Send a response.
-             *
-             * Examples:
-             *
-             *     res.send(new Buffer('wahoo'));
-             *     res.send({ some: 'json' });
-             *     res.send('<p>some html</p>');
-             *     res.send(404, 'Sorry, cant find that');
-             *     res.send(404);
-             */
-            send: Send;
-
-            /**
-             * Send JSON response.
-             *
-             * Examples:
-             *
-             *     res.json(null);
-             *     res.json({ user: 'tj' });
-             *     res.json(500, 'oh noes!');
-             *     res.json(404, 'I dont have that');
-             */
-            json: Send;
-
-            /**
-             * Send JSON response with JSONP callback support.
-             *
-             * Examples:
-             *
-             *     res.jsonp(null);
-             *     res.jsonp({ user: 'tj' });
-             *     res.jsonp(500, 'oh noes!');
-             *     res.jsonp(404, 'I dont have that');
-             */
-            jsonp: Send;
-
-            /**
-             * Transfer the file at the given `path`.
-             *
-             * Automatically sets the _Content-Type_ response header field.
-             * The callback `fn(err)` is invoked when the transfer is complete
-             * or when an error occurs. Be sure to check `res.sentHeader`
-             * if you wish to attempt responding, as the header and some data
-             * may have already been transferred.
-             *
-             * Options:
-             *
-             *   - `maxAge` defaulting to 0
-             *   - `root`   root directory for relative filenames
-             *
-             * Examples:
-             *
-             *  The following example illustrates how `res.sendfile()` may
-             *  be used as an alternative for the `static()` middleware for
-             *  dynamic situations. The code backing `res.sendfile()` is actually
-             *  the same code, so HTTP cache support etc is identical.
-             *
-             *     app.get('/user/:uid/photos/:file', function(req, res){
-             *       var uid = req.params.uid
-             *         , file = req.params.file;
-             *
-             *       req.user.mayViewFilesFrom(uid, function(yes){
-             *         if (yes) {
-             *           res.sendfile('/uploads/' + uid + '/' + file);
-             *         } else {
-             *           res.send(403, 'Sorry! you cant see that.');
-             *         }
-             *       });
-             *     });
-             */
-            sendfile(path: string): void;
-
-            sendfile(path: string, options: any): void;
-
-            sendfile(path: string, fn: Errback): void;
-
-            sendfile(path: string, options: any, fn: Errback): void;
-
-            /**
-             * Transfer the file at the given `path` as an attachment.
-             *
-             * Optionally providing an alternate attachment `filename`,
-             * and optional callback `fn(err)`. The callback is invoked
-             * when the data transfer is complete, or when an error has
-             * ocurred. Be sure to check `res.headerSent` if you plan to respond.
-             *
-             * This method uses `res.sendfile()`.
-             */
-            download(path: string): void;
-
-            download(path: string, filename: string): void;
-
-            download(path: string, fn: Errback): void;
-
-            download(path: string, filename: string, fn: Errback): void;
-
-            /**
-             * Set _Content-Type_ response header with `type` through `mime.lookup()`
-             * when it does not contain "/", or set the Content-Type to `type` otherwise.
-             *
-             * Examples:
-             *
-             *     res.type('.html');
-             *     res.type('html');
-             *     res.type('json');
-             *     res.type('application/json');
-             *     res.type('png');
-             *
-             * @param type
-             */
-            contentType(type: string): Response;
-
-            /**
-             * Set _Content-Type_ response header with `type` through `mime.lookup()`
-             * when it does not contain "/", or set the Content-Type to `type` otherwise.
-             *
-             * Examples:
-             *
-             *     res.type('.html');
-             *     res.type('html');
-             *     res.type('json');
-             *     res.type('application/json');
-             *     res.type('png');
-             *
-             * @param type
-             */
-            type(type: string): Response;
-
-            /**
-             * Respond to the Acceptable formats using an `obj`
-             * of mime-type callbacks.
-             *
-             * This method uses `req.accepted`, an array of
-             * acceptable types ordered by their quality values.
-             * When "Accept" is not present the _first_ callback
-             * is invoked, otherwise the first match is used. When
-             * no match is performed the server responds with
-             * 406 "Not Acceptable".
-             *
-             * Content-Type is set for you, however if you choose
-             * you may alter this within the callback using `res.type()`
-             * or `res.set('Content-Type', ...)`.
-             *
-             *    res.format({
-             *      'text/plain': function(){
-             *        res.send('hey');
-             *      },
-             *
-             *      'text/html': function(){
-             *        res.send('<p>hey</p>');
-             *      },
-             *
-             *      'appliation/json': function(){
-             *        res.send({ message: 'hey' });
-             *      }
-             *    });
-             *
-             * In addition to canonicalized MIME types you may
-             * also use extnames mapped to these types:
-             *
-             *    res.format({
-             *      text: function(){
-             *        res.send('hey');
-             *      },
-             *
-             *      html: function(){
-             *        res.send('<p>hey</p>');
-             *      },
-             *
-             *      json: function(){
-             *        res.send({ message: 'hey' });
-             *      }
-             *    });
-             *
-             * By default Express passes an `Error`
-             * with a `.status` of 406 to `next(err)`
-             * if a match is not made. If you provide
-             * a `.default` callback it will be invoked
-             * instead.
-             *
-             * @param obj
-             */
-            format(obj: any): Response;
-
-            /**
-             * Set _Content-Disposition_ header to _attachment_ with optional `filename`.
-             *
-             * @param filename
-             */
-            attachment(filename?: string): Response;
-
-            /**
-             * Set header `field` to `val`, or pass
-             * an object of header fields.
-             *
-             * Examples:
-             *
-             *    res.set('Foo', ['bar', 'baz']);
-             *    res.set('Accept', 'application/json');
-             *    res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
-             *
-             * Aliased as `res.header()`.
-             */
-            set (field: any): Response;
-
-            set (field: string, value?: string): Response;
-
-            header(field: any): Response;
-
-            header(field: string, value?: string): Response;
-
-            /**
-             * Get value for header `field`.
-             *
-             * @param field
-             */
-            get (field: string): string;
-
-            /**
-             * Clear cookie `name`.
-             *
-             * @param name
-             * @param options
-             */
-            clearCookie(name: string, options?: any): Response;
-
-            /**
-             * Set cookie `name` to `val`, with the given `options`.
-             *
-             * Options:
-             *
-             *    - `maxAge`   max-age in milliseconds, converted to `expires`
-             *    - `signed`   sign the cookie
-             *    - `path`     defaults to "/"
-             *
-             * Examples:
-             *
-             *    // "Remember Me" for 15 minutes
-             *    res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });
-             *
-             *    // save as above
-             *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
-             */
-            cookie(name: string, val: string, options: CookieOptions): Response;
-
-            cookie(name: string, val: any, options: CookieOptions): Response;
-
-            cookie(name: string, val: any): Response;
-
-            /**
-             * Set the location header to `url`.
-             *
-             * The given `url` can also be the name of a mapped url, for
-             * example by default express supports "back" which redirects
-             * to the _Referrer_ or _Referer_ headers or "/".
-             *
-             * Examples:
-             *
-             *    res.location('/foo/bar').;
-             *    res.location('http://example.com');
-             *    res.location('../login'); // /blog/post/1 -> /blog/login
-             *
-             * Mounting:
-             *
-             *   When an application is mounted and `res.location()`
-             *   is given a path that does _not_ lead with "/" it becomes
-             *   relative to the mount-point. For example if the application
-             *   is mounted at "/blog", the following would become "/blog/login".
-             *
-             *      res.location('login');
-             *
-             *   While the leading slash would result in a location of "/login":
-             *
-             *      res.location('/login');
-             *
-             * @param url
-             */
-            location(url: string): Response;
-
-            /**
-             * Redirect to the given `url` with optional response `status`
-             * defaulting to 302.
-             *
-             * The resulting `url` is determined by `res.location()`, so
-             * it will play nicely with mounted apps, relative paths,
-             * `"back"` etc.
-             *
-             * Examples:
-             *
-             *    res.redirect('/foo/bar');
-             *    res.redirect('http://example.com');
-             *    res.redirect(301, 'http://example.com');
-             *    res.redirect('http://example.com', 301);
-             *    res.redirect('../login'); // /blog/post/1 -> /blog/login
-             */
-            redirect(url: string): void;
-
-            redirect(status: number, url: string): void;
-
-            redirect(url: string, status: number): void;
-
-            /**
-             * Render `view` with the given `options` and optional callback `fn`.
-             * When a callback function is given a response will _not_ be made
-             * automatically, otherwise a response of _200_ and _text/html_ is given.
-             *
-             * Options:
-             *
-             *  - `cache`     boolean hinting to the engine it should cache
-             *  - `filename`  filename of the view being rendered
-             */
-
-            render(view: string, options?: Object, callback?: (err: Error, html: string) => void ): void;
-            
-            render(view: string, callback?: (err: Error, html: string) => void ): void;
-
-            locals: any;
-
-            charset: string;
-        }
-
-        export interface RequestFunction {
-            (req: Request, res: Response, next: Function): any;
-        }
-
-        export interface Application extends IRouter<Application> {
-            /**
-             * Initialize the server.
-             *
-             *   - setup default configuration
-             *   - setup default middleware
-             *   - setup route reflection methods
-             */
-            init(): void;
-
-            /**
-             * Initialize application configuration.
-             */
-            defaultConfiguration(): void;
-
-            /**
-             * Proxy `connect#use()` to apply settings to
-             * mounted applications.
-            **/
-            use(route: string, callback?: Function): Application;
-
-            use(route: string, server: Application): Application;
-
-            use(callback: Function): Application;
-
-            use(server: Application): Application;
-
-            /**
-             * Register the given template engine callback `fn`
-             * as `ext`.
-             *
-             * By default will `require()` the engine based on the
-             * file extension. For example if you try to render
-             * a "foo.jade" file Express will invoke the following internally:
-             *
-             *     app.engine('jade', require('jade').__express);
-             *
-             * For engines that do not provide `.__express` out of the box,
-             * or if you wish to "map" a different extension to the template engine
-             * you may use this method. For example mapping the EJS template engine to
-             * ".html" files:
-             *
-             *     app.engine('html', require('ejs').renderFile);
-             *
-             * In this case EJS provides a `.renderFile()` method with
-             * the same signature that Express expects: `(path, options, callback)`,
-             * though note that it aliases this method as `ejs.__express` internally
-             * so if you're using ".ejs" extensions you dont need to do anything.
-             *
-             * Some template engines do not follow this convention, the
-             * [Consolidate.js](https://github.com/visionmedia/consolidate.js)
-             * library was created to map all of node's popular template
-             * engines to follow this convention, thus allowing them to
-             * work seamlessly within Express.
-             */
-            engine(ext: string, fn: Function): Application;
-
-            param(name: string, fn: Function): Application;
-
-            param(name: string[], fn: Function): Application;
-
-            /**
-             * Assign `setting` to `val`, or return `setting`'s value.
-             *
-             *    app.set('foo', 'bar');
-             *    app.get('foo');
-             *    // => "bar"
-             *
-             * Mounted servers inherit their parent server's settings.
-             *
-             * @param setting
-             * @param val
-             */
-            set (setting: string, val: string): Application;
-
-            /**
-             * Return the app's absolute pathname
-             * based on the parent(s) that have
-             * mounted it.
-             *
-             * For example if the application was
-             * mounted as "/admin", which itself
-             * was mounted as "/blog" then the
-             * return value would be "/blog/admin".
-             */
-            path(): string;
-
-            /**
-             * Check if `setting` is enabled (truthy).
-             *
-             *    app.enabled('foo')
-             *    // => false
-             *
-             *    app.enable('foo')
-             *    app.enabled('foo')
-             *    // => true
-             */
-            enabled(setting: string): boolean;
-
-            /**
-             * Check if `setting` is disabled.
-             *
-             *    app.disabled('foo')
-             *    // => true
-             *
-             *    app.enable('foo')
-             *    app.disabled('foo')
-             *    // => false
-             *
-             * @param setting
-             */
-            disabled(setting: string): boolean;
-
-            /**
-             * Enable `setting`.
-             *
-             * @param setting
-             */
-            enable(setting: string): Application;
-
-            /**
-             * Disable `setting`.
-             *
-             * @param setting
-             */
-            disable(setting: string): Application;
-
-            /**
-             * Configure callback for zero or more envs,
-             * when no `env` is specified that callback will
-             * be invoked for all environments. Any combination
-             * can be used multiple times, in any order desired.
-             *
-             * Examples:
-             *
-             *    app.configure(function(){
-             *      // executed for all envs
-             *    });
-             *
-             *    app.configure('stage', function(){
-             *      // executed staging env
-             *    });
-             *
-             *    app.configure('stage', 'production', function(){
-             *      // executed for stage and production
-             *    });
-             *
-             * Note:
-             *
-             *  These callbacks are invoked immediately, and
-             *  are effectively sugar for the following:
-             *
-             *     var env = process.env.NODE_ENV || 'development';
-             *
-             *      switch (env) {
-             *        case 'development':
-             *          ...
-             *          break;
-             *        case 'stage':
-             *          ...
-             *          break;
-             *        case 'production':
-             *          ...
-             *          break;
-             *      }
-             *
-             * @param env
-             * @param fn
-             */
-            configure(env: string, fn: Function): Application;
-
-            configure(env0: string, env1: string, fn: Function): Application;
-
-            configure(env0: string, env1: string, env2: string, fn: Function): Application;
-
-            configure(env0: string, env1: string, env2: string, env3: string, fn: Function): Application;
-
-            configure(env0: string, env1: string, env2: string, env3: string, env4: string, fn: Function): Application;
-
-            configure(fn: Function): Application;
-
-
-            /**
-             * Render the given view `name` name with `options`
-             * and a callback accepting an error and the
-             * rendered template string.
-             *
-             * Example:
-             *
-             *    app.render('email', { name: 'Tobi' }, function(err, html){
-             *      // ...
-             *    })
-             *
-             * @param name
-             * @param options or fn
-             * @param fn
-             */
-            render(name: string, options?: Object, callback?: (err: Error, html: string) => void): void;
-            
-            render(name: string, callback: (err: Error, html: string) => void): void;
-
-
-            /**
-             * Listen for connections.
-             *
-             * A node `http.Server` is returned, with this
-             * application (which is a `Function`) as its
-             * callback. If you wish to create both an HTTP
-             * and HTTPS server you may do so with the "http"
-             * and "https" modules as shown here:
-             *
-             *    var http = require('http')
-             *      , https = require('https')
-             *      , express = require('express')
-             *      , app = express();
-             *
-             *    http.createServer(app).listen(80);
-             *    https.createServer({ ... }, app).listen(443);
-             */
-            listen(port: number, hostname: string, backlog: number, callback?: Function): void;
-
-            listen(port: number, hostname: string, callback?: Function): void;
-
-            listen(port: number, callback?: Function): void;
-
-            listen(path: string, callback?: Function): void;
-
-            listen(handle: any, listeningListener?: Function): void;
-
-            route: Route;
-
-            router: string;
-
-            settings: any;
-
-            resource: any;
-
-            map: any;
-
-            locals: any;
-
-            /**
-             * The app.routes object houses all of the routes defined mapped by the
-             * associated HTTP verb. This object may be used for introspection
-             * capabilities, for example Express uses this internally not only for
-             * routing but to provide default OPTIONS behaviour unless app.options()
-             * is used. Your application or framework may also remove routes by
-             * simply by removing them from this object.
-             */
-            routes: any;
-        }
-
-        export interface Express extends Application {
-            /**
-             * Framework version.
-             */
-            version: string;
-
-            /**
-             * Expose mime.
-             */
-            mime: string;
-
-            (): Application;
-
-            /**
-            * Create an express application.
+        patch(name: RegExp, ...handlers: RequestFunction[]): Router;
+    }
+
+    export interface Handler {
+        (req: Request, res: Response, next?: Function): void;
+    }
+
+    export interface CookieOptions {
+        maxAge?: number;
+        signed?: boolean;
+        expires?: Date;
+        httpOnly?: boolean;
+        path?: string;
+        domain?: string;
+        secure?: boolean;
+    }
+
+    export interface Errback { (err: Error): void; }
+
+    export interface Session {
+        /**
+            * Update reset `.cookie.maxAge` to prevent
+            * the cookie from expiring when the
+            * session is still active.
+            *
+            * @return {Session} for chaining
+            * @api public
             */
-            createApplication(): Application;
-
-            createServer(): Application;
-
-            application: any;
-
-            request: Request;
-
-            response: Response;
-        }
+        touch(): Session;
 
         /**
-         * Body parser:
-         * 
-         *   Parse request bodies, supports _application/json_,
-         *   _application/x-www-form-urlencoded_, and _multipart/form-data_.
-         *
-         *   This is equivalent to: 
-         *
-         *     app.use(connect.json());
-         *     app.use(connect.urlencoded());
-         *     app.use(connect.multipart());
-         *
-         * Examples:
-         *
-         *      connect()
-         *        .use(connect.bodyParser())
-         *        .use(function(req, res) {
-         *          res.end('viewing user ' + req.body.user.name);
-         *        });
-         *
-         *      $ curl -d 'user[name]=tj' http://local/
-         *      $ curl -d '{"user":{"name":"tj"}}' -H "Content-Type: application/json" http://local/
-         *
-         *  View [json](json.html), [urlencoded](urlencoded.html), and [multipart](multipart.html) for more info.
-         *
-         * @param options
-         */
-        export function bodyParser(options?: any): Handler;
+            * Reset `.maxAge` to `.originalMaxAge`.
+            */
+        resetMaxAge(): Session;
 
         /**
-         * Error handler:
-         *
-         * Development error handler, providing stack traces
-         * and error message responses for requests accepting text, html,
-         * or json.
-         *
-         * Text:
-         *
-         *   By default, and when _text/plain_ is accepted a simple stack trace
-         *   or error message will be returned.
-         *
-         * JSON:
-         *
-         *   When _application/json_ is accepted, connect will respond with
-         *   an object in the form of `{ "error": error }`.
-         *
-         * HTML:
-         *
-         *   When accepted connect will output a nice html stack trace.
-         */
-        export function errorHandler(opts?: any): Handler;
+            * Save the session data with optional callback `fn(err)`.
+            */
+        save(fn: Function): Session;
 
         /**
-         * Method Override:
-         * 
-         * Provides faux HTTP method support.
-         * 
-         * Pass an optional `key` to use when checking for
-         * a method override, othewise defaults to _\_method_.
-         * The original method is available via `req.originalMethod`.
-         *
-         * @param key
-         */
-        export function methodOverride(key?: string): Handler;
+            * Re-loads the session data _without_ altering
+            * the maxAge properties. Invokes the callback `fn(err)`,
+            * after which time if no exception has occurred the
+            * `req.session` property will be a new `Session` object,
+            * although representing the same session.
+            */
+        reload(fn: Function): Session;
 
         /**
-         * Cookie parser:
-         *
-         * Parse _Cookie_ header and populate `req.cookies`
-         * with an object keyed by the cookie names. Optionally
-         * you may enabled signed cookie support by passing
-         * a `secret` string, which assigns `req.secret` so
-         * it may be used by other middleware.
-         *
-         * Examples:
-         *
-         *     connect()
-         *       .use(connect.cookieParser('optional secret string'))
-         *       .use(function(req, res, next){
-         *         res.end(JSON.stringify(req.cookies));
-         *       })
-         *
-         * @param secret
-         */
-        export function cookieParser(secret?: string): Handler;
+            * Destroy `this` session.
+            */
+        destroy(fn: Function): Session;
 
         /**
-         * Session:
-         * 
-         *   Setup session store with the given `options`.
-         *
-         *   Session data is _not_ saved in the cookie itself, however
-         *   cookies are used, so we must use the [cookieParser()](cookieParser.html)
-         *   middleware _before_ `session()`.
-         *
-         * Examples:
-         *
-         *     connect()
-         *       .use(connect.cookieParser())
-         *       .use(connect.session({ secret: 'keyboard cat', key: 'sid', cookie: { secure: true }}))
-         *
-         * Options:
-         *
-         *   - `key` cookie name defaulting to `connect.sid`
-         *   - `store` session store instance
-         *   - `secret` session cookie is signed with this secret to prevent tampering
-         *   - `cookie` session cookie settings, defaulting to `{ path: '/', httpOnly: true, maxAge: null }`
-         *   - `proxy` trust the reverse proxy when setting secure cookies (via "x-forwarded-proto")
-         *
-         * Cookie option:
-         *
-         *  By default `cookie.maxAge` is `null`, meaning no "expires" parameter is set
-         *  so the cookie becomes a browser-session cookie. When the user closes the 
-         *  browser the cookie (and session) will be removed.
-         *
-         * ## req.session
-         *
-         *  To store or access session data, simply use the request property `req.session`,
-         *  which is (generally) serialized as JSON by the store, so nested objects 
-         *  are typically fine. For example below is a user-specific view counter:
-         *
-         *       connect()
-         *         .use(connect.favicon())
-         *         .use(connect.cookieParser())
-         *         .use(connect.session({ secret: 'keyboard cat', cookie: { maxAge: 60000 }}))
-         *         .use(function(req, res, next){
-         *           var sess = req.session;
-         *           if (sess.views) {
-         *             res.setHeader('Content-Type', 'text/html');
-         *             res.write('<p>views: ' + sess.views + '</p>');
-         *             res.write('<p>expires in: ' + (sess.cookie.maxAge / 1000) + 's</p>');
-         *             res.end();
-         *             sess.views++;
-         *           } else {
-         *             sess.views = 1;
-         *             res.end('welcome to the session demo. refresh!');
-         *           }
-         *         }
-         *       )).listen(3000);
-         *
-         * ## Session#regenerate()
-         *
-         *  To regenerate the session simply invoke the method, once complete
-         *  a new SID and `Session` instance will be initialized at `req.session`.
-         *
-         *      req.session.regenerate(function(err){
-         *        // will have a new session here
-         *      });
-         *
-         * ## Session#destroy()
-         *
-         *  Destroys the session, removing `req.session`, will be re-generated next request.
-         *
-         *      req.session.destroy(function(err){
-         *        // cannot access session here
-         *      });
-         * 
-         * ## Session#reload()
-         *
-         *  Reloads the session data.
-         *
-         *      req.session.reload(function(err){
-         *        // session updated
-         *      });
-         *
-         * ## Session#save()
-         *
-         *  Save the session.
-         *
-         *      req.session.save(function(err){
-         *        // session saved
-         *      });
-         *
-         * ## Session#touch()
-         *
-         *   Updates the `.maxAge` property. Typically this is
-         *   not necessary to call, as the session middleware does this for you.
-         *
-         * ## Session#cookie
-         *
-         *  Each session has a unique cookie object accompany it. This allows
-         *  you to alter the session cookie per visitor. For example we can
-         *  set `req.session.cookie.expires` to `false` to enable the cookie
-         *  to remain for only the duration of the user-agent.
-         *
-         * ## Session#maxAge
-         *
-         *  Alternatively `req.session.cookie.maxAge` will return the time
-         *  remaining in milliseconds, which we may also re-assign a new value
-         *  to adjust the `.expires` property appropriately. The following
-         *  are essentially equivalent
-         *
-         *     var hour = 3600000;
-         *     req.session.cookie.expires = new Date(Date.now() + hour);
-         *     req.session.cookie.maxAge = hour;
-         *
-         * For example when `maxAge` is set to `60000` (one minute), and 30 seconds
-         * has elapsed it will return `30000` until the current request has completed,
-         * at which time `req.session.touch()` is called to reset `req.session.maxAge`
-         * to its original value.
-         *
-         *     req.session.cookie.maxAge;
-         *     // => 30000
-         *
-         * Session Store Implementation:
-         *
-         * Every session store _must_ implement the following methods
-         *
-         *    - `.get(sid, callback)`
-         *    - `.set(sid, session, callback)`
-         *    - `.destroy(sid, callback)`
-         *
-         * Recommended methods include, but are not limited to:
-         *
-         *    - `.length(callback)`
-         *    - `.clear(callback)`
-         *
-         * For an example implementation view the [connect-redis](http://github.com/visionmedia/connect-redis) repo.
-         *
-         * @param options
-         */
-        export function session(options?: any): Handler;
+            * Regenerate this request's session.
+            */
+        regenerate(fn: Function): Session;
+
+        user: any;
+
+        error: string;
+
+        success: string;
+
+        views: any;
+
+        count: number;
+    }
+
+    export interface Request {
+
+        session: Session;
 
         /**
-         * Hash the given `sess` object omitting changes
-         * to `.cookie`.
-         *
-         * @param sess
-         */
-        export function hash(sess: string): string;
+            * Return request header.
+            *
+            * The `Referrer` header field is special-cased,
+            * both `Referrer` and `Referer` are interchangeable.
+            *
+            * Examples:
+            *
+            *     req.get('Content-Type');
+            *     // => "text/plain"
+            *
+            *     req.get('content-type');
+            *     // => "text/plain"
+            *
+            *     req.get('Something');
+            *     // => undefined
+            *
+            * Aliased as `req.header()`.
+            *
+            * @param name
+            */
+        get (name: string): string;
+
+        header(name: string): string;
+
+        headers: string[];
 
         /**
-         * Static:
-         *
-         *   Static file server with the given `root` path.
-         *
-         * Examples:
-         *
-         *     var oneDay = 86400000;
-         *
-         *     connect()
-         *       .use(connect.static(__dirname + '/public'))
-         *
-         *     connect()
-         *       .use(connect.static(__dirname + '/public', { maxAge: oneDay }))
-         *
-         * Options:
-         *
-         *    - `maxAge`     Browser cache maxAge in milliseconds. defaults to 0
-         *    - `hidden`     Allow transfer of hidden files. defaults to false
-         *    - `redirect`   Redirect to trailing "/" when the pathname is a dir. defaults to true
-         *
-         * @param root
-         * @param options
-         */
-        export function static(root: string, options?: any): Handler;
+            * Check if the given `type(s)` is acceptable, returning
+            * the best match when true, otherwise `undefined`, in which
+            * case you should respond with 406 "Not Acceptable".
+            *
+            * The `type` value may be a single mime type string
+            * such as "application/json", the extension name
+            * such as "json", a comma-delimted list such as "json, html, text/plain",
+            * or an array `["json", "html", "text/plain"]`. When a list
+            * or array is given the _best_ match, if any is returned.
+            *
+            * Examples:
+            *
+            *     // Accept: text/html
+            *     req.accepts('html');
+            *     // => "html"
+            *
+            *     // Accept: text/*, application/json
+            *     req.accepts('html');
+            *     // => "html"
+            *     req.accepts('text/html');
+            *     // => "text/html"
+            *     req.accepts('json, text');
+            *     // => "json"
+            *     req.accepts('application/json');
+            *     // => "application/json"
+            *
+            *     // Accept: text/*, application/json
+            *     req.accepts('image/png');
+            *     req.accepts('png');
+            *     // => undefined
+            *
+            *     // Accept: text/*;q=.5, application/json
+            *     req.accepts(['html', 'json']);
+            *     req.accepts('html, json');
+            *     // => "json"
+            */
+        accepts(type: string): string;
+
+        accepts(type: string[]): string;
 
         /**
-         * Basic Auth:
-         *
-         * Enfore basic authentication by providing a `callback(user, pass)`,
-         * which must return `true` in order to gain access. Alternatively an async
-         * method is provided as well, invoking `callback(user, pass, callback)`. Populates
-         * `req.user`. The final alternative is simply passing username / password
-         * strings.
-         *
-         *  Simple username and password
-         *
-         *     connect(connect.basicAuth('username', 'password'));
-         *
-         *  Callback verification
-         *
-         *     connect()
-         *       .use(connect.basicAuth(function(user, pass){
-         *         return 'tj' == user & 'wahoo' == pass;
-         *       }))
-         *
-         *  Async callback verification, accepting `fn(err, user)`.
-         *
-         *     connect()
-         *       .use(connect.basicAuth(function(user, pass, fn){
-         *         User.authenticate({ user: user, pass: pass }, fn);
-         *       }))
-         *
-         * @param callback or username
-         * @param realm
-         */
-        export function basicAuth(callback: (user: string, pass: string, fn : Function) => void, realm?: string): Handler;
-
-        export function basicAuth(callback: (user: string, pass: string) => boolean, realm?: string): Handler;
-
-        export function basicAuth(user: string, pass: string, realm?: string): Handler;
+            * Check if the given `charset` is acceptable,
+            * otherwise you should respond with 406 "Not Acceptable".
+            *
+            * @param charset
+            */
+        acceptsCharset(charset: string): boolean;
 
         /**
-         * Compress:
-         *
-         * Compress response data with gzip/deflate.
-         *
-         * Filter:
-         *
-         *  A `filter` callback function may be passed to
-         *  replace the default logic of:
-         *
-         *     exports.filter = function(req, res){
-         *       return /json|text|javascript/.test(res.getHeader('Content-Type'));
-         *     };
-         *
-         * Options:
-         *
-         *  All remaining options are passed to the gzip/deflate
-         *  creation functions. Consult node's docs for additional details.
-         *
-         *   - `chunkSize` (default: 16*1024)
-         *   - `windowBits`
-         *   - `level`: 0-9 where 0 is no compression, and 9 is slow but best compression
-         *   - `memLevel`: 1-9 low is slower but uses less memory, high is fast but uses more
-         *   - `strategy`: compression strategy
-         *
-         * @param options
-         */
-        export function compress(options?: any): Handler;
+            * Check if the given `lang` is acceptable,
+            * otherwise you should respond with 406 "Not Acceptable".
+            *
+            * @param lang
+            */
+        acceptsLanguage(lang: string): boolean;
 
         /**
-         * Cookie Session:
-         *
-         *   Cookie session middleware.
-         *
-         *      var app = connect();
-         *      app.use(connect.cookieParser());
-         *      app.use(connect.cookieSession({ secret: 'tobo!', cookie: { maxAge: 60 * 60 * 1000 }}));
-         *
-         * Options:
-         *
-         *   - `key` cookie name defaulting to `connect.sess`
-         *   - `secret` prevents cookie tampering
-         *   - `cookie` session cookie settings, defaulting to `{ path: '/', httpOnly: true, maxAge: null }`
-         *   - `proxy` trust the reverse proxy when setting secure cookies (via "x-forwarded-proto")
-         *
-         * Clearing sessions:
-         *
-         *  To clear the session simply set its value to `null`,
-         *  `cookieSession()` will then respond with a 1970 Set-Cookie.
-         *
-         *     req.session = null;
-         *
-         * @param options
-         */
-        export function cookieSession(options?: any): Handler;
+            * Parse Range header field,
+            * capping to the given `size`.
+            *
+            * Unspecified ranges such as "0-" require
+            * knowledge of your resource length. In
+            * the case of a byte range this is of course
+            * the total number of bytes. If the Range
+            * header field is not given `null` is returned,
+            * `-1` when unsatisfiable, `-2` when syntactically invalid.
+            *
+            * NOTE: remember that ranges are inclusive, so
+            * for example "Range: users=0-3" should respond
+            * with 4 users when available, not 3.
+            *
+            * @param size
+            */
+        range(size: number): any[];
 
         /**
-         * Anti CSRF:
-         *
-         * CSRF protection middleware.
-         *
-         * This middleware adds a `req.csrfToken()` function to make a token
-         * which should be added to requests which mutate
-         * state, within a hidden form field, query-string etc. This
-         * token is validated against the visitor's session.
-         *
-         * The default `value` function checks `req.body` generated
-         * by the `bodyParser()` middleware, `req.query` generated
-         * by `query()`, and the "X-CSRF-Token" header field.
-         *
-         * This middleware requires session support, thus should be added
-         * somewhere _below_ `session()` and `cookieParser()`.
-         *
-         * Options:
-         *
-         *    - `value` a function accepting the request, returning the token
-         *
-         * @param options
-         */
-        export function csrf(options?: {value?: Function}): Handler;
+            * Return an array of Accepted media types
+            * ordered from highest quality to lowest.
+            */
+        accepted: MediaType[];
 
         /**
-         * Directory:
-         *
-         * Serve directory listings with the given `root` path.
-         *
-         * Options:
-         *
-         *  - `hidden` display hidden (dot) files. Defaults to false.
-         *  - `icons`  display icons. Defaults to false.
-         *  - `filter` Apply this filter function to files. Defaults to false.
-         *
-         * @param root
-         * @param options
-         */
-        export function directory(root: string, options?: any): Handler;
+            * Return an array of Accepted languages
+            * ordered from highest quality to lowest.
+            *
+            * Examples:
+            *
+            *     Accept-Language: en;q=.5, en-us
+            *     ['en-us', 'en']
+            */
+        acceptedLanguages: any[];
 
         /**
-         * Favicon:
-         *
-         * By default serves the connect favicon, or the favicon
-         * located by the given `path`.
-         *
-         * Options:
-         *
-         *   - `maxAge`  cache-control max-age directive, defaulting to 1 day
-         *
-         * Examples:
-         *
-         *   Serve default favicon:
-         *
-         *     connect()
-         *       .use(connect.favicon())
-         *
-         *   Serve favicon before logging for brevity:
-         *
-         *     connect()
-         *       .use(connect.favicon())
-         *       .use(connect.logger('dev'))
-         *
-         *   Serve custom favicon:
-         *
-         *     connect()
-         *       .use(connect.favicon('public/favicon.ico))
-         *
-         * @param path
-         * @param options
-         */
-        export function favicon(path?: string, options?: any): Handler;
+            * Return an array of Accepted charsets
+            * ordered from highest quality to lowest.
+            *
+            * Examples:
+            *
+            *     Accept-Charset: iso-8859-5;q=.2, unicode-1-1;q=0.8
+            *     ['unicode-1-1', 'iso-8859-5']
+            */
+        acceptedCharsets: any[];
 
         /**
-         * JSON:
-         *
-         * Parse JSON request bodies, providing the
-         * parsed object as `req.body`.
-         *
-         * Options:
-         *
-         *   - `strict`  when `false` anything `JSON.parse()` accepts will be parsed
-         *   - `reviver`  used as the second "reviver" argument for JSON.parse
-         *   - `limit`  byte limit disabled by default
-         *
-         * @param options
-         */
-        export function json(options?: any): Handler;
+            * Return the value of param `name` when present or `defaultValue`.
+            *
+            *  - Checks route placeholders, ex: _/user/:id_
+            *  - Checks body params, ex: id=12, {"id":12}
+            *  - Checks query string params, ex: ?id=12
+            *
+            * To utilize request bodies, `req.body`
+            * should be an object. This can be done by using
+            * the `connect.bodyParser()` middleware.
+            *
+            * @param name
+            * @param defaultValue
+            */
+        param(name: string, defaultValue?: any): string;
 
         /**
-         * Limit:
-         *
-         *   Limit request bodies to the given size in `bytes`.
-         *
-         *   A string representation of the bytesize may also be passed,
-         *   for example "5mb", "200kb", "1gb", etc.
-         *
-         *     connect()
-         *       .use(connect.limit('5.5mb'))
-         *       .use(handleImageUpload)
-         */
-        export function limit(bytes: number): Handler;
-
-        export function limit(bytes: string): Handler;
+            * Check if the incoming request contains the "Content-Type"
+            * header field, and it contains the give mime `type`.
+            *
+            * Examples:
+            *
+            *      // With Content-Type: text/html; charset=utf-8
+            *      req.is('html');
+            *      req.is('text/html');
+            *      req.is('text/*');
+            *      // => true
+            *
+            *      // When Content-Type is application/json
+            *      req.is('json');
+            *      req.is('application/json');
+            *      req.is('application/*');
+            *      // => true
+            *
+            *      req.is('html');
+            *      // => false
+            *
+            * @param type
+            */
+        is(type: string): boolean;
 
         /**
-         * Logger:
-         *
-         * Log requests with the given `options` or a `format` string.
-         *
-         * Options:
-         *
-         *   - `format`  Format string, see below for tokens
-         *   - `stream`  Output stream, defaults to _stdout_
-         *   - `buffer`  Buffer duration, defaults to 1000ms when _true_
-         *   - `immediate`  Write log line on request instead of response (for response times)
-         *
-         * Tokens:
-         *
-         *   - `:req[header]` ex: `:req[Accept]`
-         *   - `:res[header]` ex: `:res[Content-Length]`
-         *   - `:http-version`
-         *   - `:response-time`
-         *   - `:remote-addr`
-         *   - `:date`
-         *   - `:method`
-         *   - `:url`
-         *   - `:referrer`
-         *   - `:user-agent`
-         *   - `:status`
-         *
-         * Formats:
-         *
-         *   Pre-defined formats that ship with connect:
-         *
-         *    - `default` ':remote-addr - - [:date] ":method :url HTTP/:http-version" :status :res[content-length] ":referrer" ":user-agent"'
-         *    - `short` ':remote-addr - :method :url HTTP/:http-version :status :res[content-length] - :response-time ms'
-         *    - `tiny`  ':method :url :status :res[content-length] - :response-time ms'
-         *    - `dev` concise output colored by response status for development use
-         *
-         * Examples:
-         *
-         *      connect.logger() // default
-         *      connect.logger('short')
-         *      connect.logger('tiny')
-         *      connect.logger({ immediate: true, format: 'dev' })
-         *      connect.logger(':method :url - :referrer')
-         *      connect.logger(':req[content-type] -> :res[content-type]')
-         *      connect.logger(function(tokens, req, res){ return 'some format string' })
-         *
-         * Defining Tokens:
-         *
-         *   To define a token, simply invoke `connect.logger.token()` with the
-         *   name and a callback function. The value returned is then available
-         *   as ":type" in this case.
-         *
-         *      connect.logger.token('type', function(req, res){ return req.headers['content-type']; })
-         *
-         * Defining Formats:
-         *
-         *   All default formats are defined this way, however it's public API as well:
-         *
-         *       connect.logger.format('name', 'string or function')
-         */
-        export function logger(options: string): Handler;
-
-        export function logger(options: Function): Handler;
-
-        export function logger(options?: any): Handler;
+            * Return the protocol string "http" or "https"
+            * when requested with TLS. When the "trust proxy"
+            * setting is enabled the "X-Forwarded-Proto" header
+            * field will be trusted. If you're running behind
+            * a reverse proxy that supplies https for you this
+            * may be enabled.
+            */
+        protocol: string;
 
         /**
-         * Compile `fmt` into a function.
-         *
-         * @param fmt
-         */
-        export function compile(fmt: string): Handler;
+            * Short-hand for:
+            *
+            *    req.protocol == 'https'
+            */
+        secure: boolean;
 
         /**
-         * Define a token function with the given `name`,
-         * and callback `fn(req, res)`.
-         *
-         * @param name
-         * @param fn
-         */
-        export function token(name: string, fn: Function): any;
+            * Return the remote address, or when
+            * "trust proxy" is `true` return
+            * the upstream addr.
+            */
+        ip: string;
 
         /**
-         * Define a `fmt` with the given `name`.
-         */
-        export function format(name: string, str: string): any;
-
-        export function format(name: string, str: Function): any;
+            * When "trust proxy" is `true`, parse
+            * the "X-Forwarded-For" ip address list.
+            *
+            * For example if the value were "client, proxy1, proxy2"
+            * you would receive the array `["client", "proxy1", "proxy2"]`
+            * where "proxy2" is the furthest down-stream.
+            */
+        ips: string[];
 
         /**
-         * Query:
-         *
-         * Automatically parse the query-string when available,
-         * populating the `req.query` object.
-         *
-         * Examples:
-         *
-         *     connect()
-         *       .use(connect.query())
-         *       .use(function(req, res){
-         *         res.end(JSON.stringify(req.query));
-         *       });
-         *
-         *  The `options` passed are provided to qs.parse function.
-         */
-        export function query(options: any): Handler;
+            * Return basic auth credentials.
+            *
+            * Examples:
+            *
+            *    // http://tobi:hello@example.com
+            *    req.auth
+            *    // => { username: 'tobi', password: 'hello' }
+            */
+        auth: any;
 
         /**
-         * Reponse time:
-         *
-         * Adds the `X-Response-Time` header displaying the response
-         * duration in milliseconds.
-         */
-        export function responseTime(): Handler;
+            * Return subdomains as an array.
+            *
+            * Subdomains are the dot-separated parts of the host before the main domain of
+            * the app. By default, the domain of the app is assumed to be the last two
+            * parts of the host. This can be changed by setting "subdomain offset".
+            *
+            * For example, if the domain is "tobi.ferrets.example.com":
+            * If "subdomain offset" is not set, req.subdomains is `["ferrets", "tobi"]`.
+            * If "subdomain offset" is 3, req.subdomains is `["tobi"]`.
+            */
+        subdomains: string[];
 
         /**
-         * Static cache:
-         *
-         * Enables a memory cache layer on top of
-         * the `static()` middleware, serving popular
-         * static files.
-         *
-         * By default a maximum of 128 objects are
-         * held in cache, with a max of 256k each,
-         * totalling ~32mb.
-         *
-         * A Least-Recently-Used (LRU) cache algo
-         * is implemented through the `Cache` object,
-         * simply rotating cache objects as they are
-         * hit. This means that increasingly popular
-         * objects maintain their positions while
-         * others get shoved out of the stack and
-         * garbage collected.
-         *
-         * Benchmarks:
-         *
-         *     static(): 2700 rps
-         *     node-static: 5300 rps
-         *     static() + staticCache(): 7500 rps
-         *
-         * Options:
-         *
-         *   - `maxObjects`  max cache objects [128]
-         *   - `maxLength`  max cache object length 256kb
-         */
-        export function staticCache(options: any): Handler;
+            * Short-hand for `url.parse(req.url).pathname`.
+            */
+        path: string;
 
         /**
-         * Timeout:
-         *
-         * Times out the request in `ms`, defaulting to `5000`. The
-         * method `req.clearTimeout()` is added to revert this behaviour
-         * programmatically within your application's middleware, routes, etc.
-         *
-         * The timeout error is passed to `next()` so that you may customize
-         * the response behaviour. This error has the `.timeout` property as
-         * well as `.status == 408`.
-         */
-        export function timeout(ms: number): Handler;
+            * Parse the "Host" header field hostname.
+            */
+        host: string;
 
         /**
-         * Vhost:
-         * 
-         *   Setup vhost for the given `hostname` and `server`.
-         *
-         *     connect()
-         *       .use(connect.vhost('foo.com', fooApp))
-         *       .use(connect.vhost('bar.com', barApp))
-         *       .use(connect.vhost('*.com', mainApp))
-         *
-         *  The `server` may be a Connect server or
-         *  a regular Node `http.Server`. 
-         *
-         * @param hostname
-         * @param server
-         */
-        export function vhost(hostname: string, server: any): Handler;
+            * Check if the request is fresh, aka
+            * Last-Modified and/or the ETag
+            * still match.
+            */
+        fresh: boolean;
 
-        export function urlencoded(): any;
+        /**
+            * Check if the request is stale, aka
+            * "Last-Modified" and / or the "ETag" for the
+            * resource has changed.
+            */
+        stale: boolean;
 
-        export function multipart(): any;
+        /**
+            * Check if the request was an _XMLHttpRequest_.
+            */
+        xhr: boolean;
+
+        //body: { username: string; password: string; remember: boolean; title: string; };
+        body: any;
+
+        //cookies: { string; remember: boolean; };
+        cookies: any;
+
+        /**
+            * Used to generate an anti-CSRF token.
+            * Placed by the CSRF protection middleware.
+            */
+        csrfToken(): string;
+
+        method: string;
+
+        params: any;
+
+        user: any;
+
+        authenticatedUser: any;
+
+        files: any;
+
+        /**
+            * Clear cookie `name`.
+            *
+            * @param name
+            * @param options
+            */
+        clearCookie(name: string, options?: any): Response;
+
+        query: any;
+
+        route: any;
+
+        signedCookies: any;
+
+        originalUrl: string;
+
+        url: string;
+    }
+
+    export interface MediaType {
+        value: string;
+        quality: number;
+        type: string;
+        subtype:  string;
+    }
+
+    export interface Send {
+        (status: number, body?: any): Response;
+        (body: any): Response;
+    }
+
+    export interface Response extends NodeJs.Http.ServerResponse {
+        /**
+            * Set status `code`.
+            *
+            * @param code
+            */
+        status(code: number): Response;
+
+        /**
+            * Set Link header field with the given `links`.
+            *
+            * Examples:
+            *
+            *    res.links({
+            *      next: 'http://api.example.com/users?page=2',
+            *      last: 'http://api.example.com/users?page=5'
+            *    });
+            *
+            * @param links
+            */
+        links(links: any): Response;
+
+        /**
+            * Send a response.
+            *
+            * Examples:
+            *
+            *     res.send(new Buffer('wahoo'));
+            *     res.send({ some: 'json' });
+            *     res.send('<p>some html</p>');
+            *     res.send(404, 'Sorry, cant find that');
+            *     res.send(404);
+            */
+        send: Send;
+
+        /**
+            * Send JSON response.
+            *
+            * Examples:
+            *
+            *     res.json(null);
+            *     res.json({ user: 'tj' });
+            *     res.json(500, 'oh noes!');
+            *     res.json(404, 'I dont have that');
+            */
+        json: Send;
+
+        /**
+            * Send JSON response with JSONP callback support.
+            *
+            * Examples:
+            *
+            *     res.jsonp(null);
+            *     res.jsonp({ user: 'tj' });
+            *     res.jsonp(500, 'oh noes!');
+            *     res.jsonp(404, 'I dont have that');
+            */
+        jsonp: Send;
+
+        /**
+            * Transfer the file at the given `path`.
+            *
+            * Automatically sets the _Content-Type_ response header field.
+            * The callback `fn(err)` is invoked when the transfer is complete
+            * or when an error occurs. Be sure to check `res.sentHeader`
+            * if you wish to attempt responding, as the header and some data
+            * may have already been transferred.
+            *
+            * Options:
+            *
+            *   - `maxAge` defaulting to 0
+            *   - `root`   root directory for relative filenames
+            *
+            * Examples:
+            *
+            *  The following example illustrates how `res.sendfile()` may
+            *  be used as an alternative for the `static()` middleware for
+            *  dynamic situations. The code backing `res.sendfile()` is actually
+            *  the same code, so HTTP cache support etc is identical.
+            *
+            *     app.get('/user/:uid/photos/:file', function(req, res){
+            *       var uid = req.params.uid
+            *         , file = req.params.file;
+            *
+            *       req.user.mayViewFilesFrom(uid, function(yes){
+            *         if (yes) {
+            *           res.sendfile('/uploads/' + uid + '/' + file);
+            *         } else {
+            *           res.send(403, 'Sorry! you cant see that.');
+            *         }
+            *       });
+            *     });
+            */
+        sendfile(path: string): void;
+
+        sendfile(path: string, options: any): void;
+
+        sendfile(path: string, fn: Errback): void;
+
+        sendfile(path: string, options: any, fn: Errback): void;
+
+        /**
+            * Transfer the file at the given `path` as an attachment.
+            *
+            * Optionally providing an alternate attachment `filename`,
+            * and optional callback `fn(err)`. The callback is invoked
+            * when the data transfer is complete, or when an error has
+            * ocurred. Be sure to check `res.headerSent` if you plan to respond.
+            *
+            * This method uses `res.sendfile()`.
+            */
+        download(path: string): void;
+
+        download(path: string, filename: string): void;
+
+        download(path: string, fn: Errback): void;
+
+        download(path: string, filename: string, fn: Errback): void;
+
+        /**
+            * Set _Content-Type_ response header with `type` through `mime.lookup()`
+            * when it does not contain "/", or set the Content-Type to `type` otherwise.
+            *
+            * Examples:
+            *
+            *     res.type('.html');
+            *     res.type('html');
+            *     res.type('json');
+            *     res.type('application/json');
+            *     res.type('png');
+            *
+            * @param type
+            */
+        contentType(type: string): Response;
+
+        /**
+            * Set _Content-Type_ response header with `type` through `mime.lookup()`
+            * when it does not contain "/", or set the Content-Type to `type` otherwise.
+            *
+            * Examples:
+            *
+            *     res.type('.html');
+            *     res.type('html');
+            *     res.type('json');
+            *     res.type('application/json');
+            *     res.type('png');
+            *
+            * @param type
+            */
+        type(type: string): Response;
+
+        /**
+            * Respond to the Acceptable formats using an `obj`
+            * of mime-type callbacks.
+            *
+            * This method uses `req.accepted`, an array of
+            * acceptable types ordered by their quality values.
+            * When "Accept" is not present the _first_ callback
+            * is invoked, otherwise the first match is used. When
+            * no match is performed the server responds with
+            * 406 "Not Acceptable".
+            *
+            * Content-Type is set for you, however if you choose
+            * you may alter this within the callback using `res.type()`
+            * or `res.set('Content-Type', ...)`.
+            *
+            *    res.format({
+            *      'text/plain': function(){
+            *        res.send('hey');
+            *      },
+            *
+            *      'text/html': function(){
+            *        res.send('<p>hey</p>');
+            *      },
+            *
+            *      'appliation/json': function(){
+            *        res.send({ message: 'hey' });
+            *      }
+            *    });
+            *
+            * In addition to canonicalized MIME types you may
+            * also use extnames mapped to these types:
+            *
+            *    res.format({
+            *      text: function(){
+            *        res.send('hey');
+            *      },
+            *
+            *      html: function(){
+            *        res.send('<p>hey</p>');
+            *      },
+            *
+            *      json: function(){
+            *        res.send({ message: 'hey' });
+            *      }
+            *    });
+            *
+            * By default Express passes an `Error`
+            * with a `.status` of 406 to `next(err)`
+            * if a match is not made. If you provide
+            * a `.default` callback it will be invoked
+            * instead.
+            *
+            * @param obj
+            */
+        format(obj: any): Response;
+
+        /**
+            * Set _Content-Disposition_ header to _attachment_ with optional `filename`.
+            *
+            * @param filename
+            */
+        attachment(filename?: string): Response;
+
+        /**
+            * Set header `field` to `val`, or pass
+            * an object of header fields.
+            *
+            * Examples:
+            *
+            *    res.set('Foo', ['bar', 'baz']);
+            *    res.set('Accept', 'application/json');
+            *    res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
+            *
+            * Aliased as `res.header()`.
+            */
+        set (field: any): Response;
+
+        set (field: string, value?: string): Response;
+
+        header(field: any): Response;
+
+        header(field: string, value?: string): Response;
+
+        /**
+            * Get value for header `field`.
+            *
+            * @param field
+            */
+        get (field: string): string;
+
+        /**
+            * Clear cookie `name`.
+            *
+            * @param name
+            * @param options
+            */
+        clearCookie(name: string, options?: any): Response;
+
+        /**
+            * Set cookie `name` to `val`, with the given `options`.
+            *
+            * Options:
+            *
+            *    - `maxAge`   max-age in milliseconds, converted to `expires`
+            *    - `signed`   sign the cookie
+            *    - `path`     defaults to "/"
+            *
+            * Examples:
+            *
+            *    // "Remember Me" for 15 minutes
+            *    res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });
+            *
+            *    // save as above
+            *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
+            */
+        cookie(name: string, val: string, options: CookieOptions): Response;
+
+        cookie(name: string, val: any, options: CookieOptions): Response;
+
+        cookie(name: string, val: any): Response;
+
+        /**
+            * Set the location header to `url`.
+            *
+            * The given `url` can also be the name of a mapped url, for
+            * example by default express supports "back" which redirects
+            * to the _Referrer_ or _Referer_ headers or "/".
+            *
+            * Examples:
+            *
+            *    res.location('/foo/bar').;
+            *    res.location('http://example.com');
+            *    res.location('../login'); // /blog/post/1 -> /blog/login
+            *
+            * Mounting:
+            *
+            *   When an application is mounted and `res.location()`
+            *   is given a path that does _not_ lead with "/" it becomes
+            *   relative to the mount-point. For example if the application
+            *   is mounted at "/blog", the following would become "/blog/login".
+            *
+            *      res.location('login');
+            *
+            *   While the leading slash would result in a location of "/login":
+            *
+            *      res.location('/login');
+            *
+            * @param url
+            */
+        location(url: string): Response;
+
+        /**
+            * Redirect to the given `url` with optional response `status`
+            * defaulting to 302.
+            *
+            * The resulting `url` is determined by `res.location()`, so
+            * it will play nicely with mounted apps, relative paths,
+            * `"back"` etc.
+            *
+            * Examples:
+            *
+            *    res.redirect('/foo/bar');
+            *    res.redirect('http://example.com');
+            *    res.redirect(301, 'http://example.com');
+            *    res.redirect('http://example.com', 301);
+            *    res.redirect('../login'); // /blog/post/1 -> /blog/login
+            */
+        redirect(url: string): void;
+
+        redirect(status: number, url: string): void;
+
+        redirect(url: string, status: number): void;
+
+        /**
+            * Render `view` with the given `options` and optional callback `fn`.
+            * When a callback function is given a response will _not_ be made
+            * automatically, otherwise a response of _200_ and _text/html_ is given.
+            *
+            * Options:
+            *
+            *  - `cache`     boolean hinting to the engine it should cache
+            *  - `filename`  filename of the view being rendered
+            */
+
+        render(view: string, options?: Object, callback?: (err: Error, html: string) => void ): void;
+            
+        render(view: string, callback?: (err: Error, html: string) => void ): void;
+
+        locals: any;
+
+        charset: string;
+    }
+
+    export interface RequestFunction {
+        (req: Request, res: Response, next: Function): any;
+    }
+
+    export interface Application extends IRouter<Application> {
+        /**
+            * Initialize the server.
+            *
+            *   - setup default configuration
+            *   - setup default middleware
+            *   - setup route reflection methods
+            */
+        init(): void;
+
+        /**
+            * Initialize application configuration.
+            */
+        defaultConfiguration(): void;
+
+        /**
+            * Proxy `connect#use()` to apply settings to
+            * mounted applications.
+        **/
+        use(route: string, callback?: Function): Application;
+
+        use(route: string, server: Application): Application;
+
+        use(callback: Function): Application;
+
+        use(server: Application): Application;
+
+        /**
+            * Register the given template engine callback `fn`
+            * as `ext`.
+            *
+            * By default will `require()` the engine based on the
+            * file extension. For example if you try to render
+            * a "foo.jade" file Express will invoke the following internally:
+            *
+            *     app.engine('jade', require('jade').__express);
+            *
+            * For engines that do not provide `.__express` out of the box,
+            * or if you wish to "map" a different extension to the template engine
+            * you may use this method. For example mapping the EJS template engine to
+            * ".html" files:
+            *
+            *     app.engine('html', require('ejs').renderFile);
+            *
+            * In this case EJS provides a `.renderFile()` method with
+            * the same signature that Express expects: `(path, options, callback)`,
+            * though note that it aliases this method as `ejs.__express` internally
+            * so if you're using ".ejs" extensions you dont need to do anything.
+            *
+            * Some template engines do not follow this convention, the
+            * [Consolidate.js](https://github.com/visionmedia/consolidate.js)
+            * library was created to map all of node's popular template
+            * engines to follow this convention, thus allowing them to
+            * work seamlessly within Express.
+            */
+        engine(ext: string, fn: Function): Application;
+
+        param(name: string, fn: Function): Application;
+
+        param(name: string[], fn: Function): Application;
+
+        /**
+            * Assign `setting` to `val`, or return `setting`'s value.
+            *
+            *    app.set('foo', 'bar');
+            *    app.get('foo');
+            *    // => "bar"
+            *
+            * Mounted servers inherit their parent server's settings.
+            *
+            * @param setting
+            * @param val
+            */
+        set (setting: string, val: string): Application;
+
+        /**
+            * Return the app's absolute pathname
+            * based on the parent(s) that have
+            * mounted it.
+            *
+            * For example if the application was
+            * mounted as "/admin", which itself
+            * was mounted as "/blog" then the
+            * return value would be "/blog/admin".
+            */
+        path(): string;
+
+        /**
+            * Check if `setting` is enabled (truthy).
+            *
+            *    app.enabled('foo')
+            *    // => false
+            *
+            *    app.enable('foo')
+            *    app.enabled('foo')
+            *    // => true
+            */
+        enabled(setting: string): boolean;
+
+        /**
+            * Check if `setting` is disabled.
+            *
+            *    app.disabled('foo')
+            *    // => true
+            *
+            *    app.enable('foo')
+            *    app.disabled('foo')
+            *    // => false
+            *
+            * @param setting
+            */
+        disabled(setting: string): boolean;
+
+        /**
+            * Enable `setting`.
+            *
+            * @param setting
+            */
+        enable(setting: string): Application;
+
+        /**
+            * Disable `setting`.
+            *
+            * @param setting
+            */
+        disable(setting: string): Application;
+
+        /**
+            * Configure callback for zero or more envs,
+            * when no `env` is specified that callback will
+            * be invoked for all environments. Any combination
+            * can be used multiple times, in any order desired.
+            *
+            * Examples:
+            *
+            *    app.configure(function(){
+            *      // executed for all envs
+            *    });
+            *
+            *    app.configure('stage', function(){
+            *      // executed staging env
+            *    });
+            *
+            *    app.configure('stage', 'production', function(){
+            *      // executed for stage and production
+            *    });
+            *
+            * Note:
+            *
+            *  These callbacks are invoked immediately, and
+            *  are effectively sugar for the following:
+            *
+            *     var env = process.env.NODE_ENV || 'development';
+            *
+            *      switch (env) {
+            *        case 'development':
+            *          ...
+            *          break;
+            *        case 'stage':
+            *          ...
+            *          break;
+            *        case 'production':
+            *          ...
+            *          break;
+            *      }
+            *
+            * @param env
+            * @param fn
+            */
+        configure(env: string, fn: Function): Application;
+
+        configure(env0: string, env1: string, fn: Function): Application;
+
+        configure(env0: string, env1: string, env2: string, fn: Function): Application;
+
+        configure(env0: string, env1: string, env2: string, env3: string, fn: Function): Application;
+
+        configure(env0: string, env1: string, env2: string, env3: string, env4: string, fn: Function): Application;
+
+        configure(fn: Function): Application;
+
+
+        /**
+            * Render the given view `name` name with `options`
+            * and a callback accepting an error and the
+            * rendered template string.
+            *
+            * Example:
+            *
+            *    app.render('email', { name: 'Tobi' }, function(err, html){
+            *      // ...
+            *    })
+            *
+            * @param name
+            * @param options or fn
+            * @param fn
+            */
+        render(name: string, options?: Object, callback?: (err: Error, html: string) => void): void;
+            
+        render(name: string, callback: (err: Error, html: string) => void): void;
+
+
+        /**
+            * Listen for connections.
+            *
+            * A node `http.Server` is returned, with this
+            * application (which is a `Function`) as its
+            * callback. If you wish to create both an HTTP
+            * and HTTPS server you may do so with the "http"
+            * and "https" modules as shown here:
+            *
+            *    var http = require('http')
+            *      , https = require('https')
+            *      , express = require('express')
+            *      , app = express();
+            *
+            *    http.createServer(app).listen(80);
+            *    https.createServer({ ... }, app).listen(443);
+            */
+        listen(port: number, hostname: string, backlog: number, callback?: Function): void;
+
+        listen(port: number, hostname: string, callback?: Function): void;
+
+        listen(port: number, callback?: Function): void;
+
+        listen(path: string, callback?: Function): void;
+
+        listen(handle: any, listeningListener?: Function): void;
+
+        route: Route;
+
+        router: string;
+
+        settings: any;
+
+        resource: any;
+
+        map: any;
+
+        locals: any;
+
+        /**
+            * The app.routes object houses all of the routes defined mapped by the
+            * associated HTTP verb. This object may be used for introspection
+            * capabilities, for example Express uses this internally not only for
+            * routing but to provide default OPTIONS behaviour unless app.options()
+            * is used. Your application or framework may also remove routes by
+            * simply by removing them from this object.
+            */
+        routes: any;
+    }
+
+    export interface Express extends Application {
+        /**
+            * Framework version.
+            */
+        version: string;
+
+        /**
+            * Expose mime.
+            */
+        mime: string;
+
+        (): Application;
+
+        /**
+        * Create an express application.
+        */
+        createApplication(): Application;
+
+        createServer(): Application;
+
+        application: any;
+
+        request: Request;
+
+        response: Response;
     }
 }
+interface Express {
+    (): Express.Express;
+
+    /**
+        * Initialize `Route` with the given HTTP `method`, `path`,
+        * and an array of `callbacks` and `options`.
+        *
+        * Options:
+        *
+        *   - `sensitive`    enable case-sensitive routes
+        *   - `strict`       enable strict matching for trailing slashes
+        *
+        * @param method
+        * @param path
+        * @param callbacks
+        * @param options
+        */
+    Route: new (method: string, path: string, callbacks: Function[], options: any) => Express.Route;
+
+    Router: new (options?: any) => Express.Router;
+
+    /**
+        * Body parser:
+        * 
+        *   Parse request bodies, supports _application/json_,
+        *   _application/x-www-form-urlencoded_, and _multipart/form-data_.
+        *
+        *   This is equivalent to: 
+        *
+        *     app.use(connect.json());
+        *     app.use(connect.urlencoded());
+        *     app.use(connect.multipart());
+        *
+        * Examples:
+        *
+        *      connect()
+        *        .use(connect.bodyParser())
+        *        .use(function(req, res) {
+        *          res.end('viewing user ' + req.body.user.name);
+        *        });
+        *
+        *      $ curl -d 'user[name]=tj' http://local/
+        *      $ curl -d '{"user":{"name":"tj"}}' -H "Content-Type: application/json" http://local/
+        *
+        *  View [json](json.html), [urlencoded](urlencoded.html), and [multipart](multipart.html) for more info.
+        *
+        * @param options
+        */
+    bodyParser(options?: any): Express.Handler;
+
+    /**
+        * Error handler:
+        *
+        * Development error handler, providing stack traces
+        * and error message responses for requests accepting text, html,
+        * or json.
+        *
+        * Text:
+        *
+        *   By default, and when _text/plain_ is accepted a simple stack trace
+        *   or error message will be returned.
+        *
+        * JSON:
+        *
+        *   When _application/json_ is accepted, connect will respond with
+        *   an object in the form of `{ "error": error }`.
+        *
+        * HTML:
+        *
+        *   When accepted connect will output a nice html stack trace.
+        */
+    errorHandler(opts?: any): Express.Handler;
+
+    /**
+        * Method Override:
+        * 
+        * Provides faux HTTP method support.
+        * 
+        * Pass an optional `key` to use when checking for
+        * a method override, othewise defaults to _\_method_.
+        * The original method is available via `req.originalMethod`.
+        *
+        * @param key
+        */
+    methodOverride(key?: string): Express.Handler;
+
+    /**
+        * Cookie parser:
+        *
+        * Parse _Cookie_ header and populate `req.cookies`
+        * with an object keyed by the cookie names. Optionally
+        * you may enabled signed cookie support by passing
+        * a `secret` string, which assigns `req.secret` so
+        * it may be used by other middleware.
+        *
+        * Examples:
+        *
+        *     connect()
+        *       .use(connect.cookieParser('optional secret string'))
+        *       .use(function(req, res, next){
+        *         res.end(JSON.stringify(req.cookies));
+        *       })
+        *
+        * @param secret
+        */
+    cookieParser(secret?: string): Express.Handler;
+
+    /**
+        * Session:
+        * 
+        *   Setup session store with the given `options`.
+        *
+        *   Session data is _not_ saved in the cookie itself, however
+        *   cookies are used, so we must use the [cookieParser()](cookieParser.html)
+        *   middleware _before_ `session()`.
+        *
+        * Examples:
+        *
+        *     connect()
+        *       .use(connect.cookieParser())
+        *       .use(connect.session({ secret: 'keyboard cat', key: 'sid', cookie: { secure: true }}))
+        *
+        * Options:
+        *
+        *   - `key` cookie name defaulting to `connect.sid`
+        *   - `store` session store instance
+        *   - `secret` session cookie is signed with this secret to prevent tampering
+        *   - `cookie` session cookie settings, defaulting to `{ path: '/', httpOnly: true, maxAge: null }`
+        *   - `proxy` trust the reverse proxy when setting secure cookies (via "x-forwarded-proto")
+        *
+        * Cookie option:
+        *
+        *  By default `cookie.maxAge` is `null`, meaning no "expires" parameter is set
+        *  so the cookie becomes a browser-session cookie. When the user closes the 
+        *  browser the cookie (and session) will be removed.
+        *
+        * ## req.session
+        *
+        *  To store or access session data, simply use the request property `req.session`,
+        *  which is (generally) serialized as JSON by the store, so nested objects 
+        *  are typically fine. For example below is a user-specific view counter:
+        *
+        *       connect()
+        *         .use(connect.favicon())
+        *         .use(connect.cookieParser())
+        *         .use(connect.session({ secret: 'keyboard cat', cookie: { maxAge: 60000 }}))
+        *         .use(function(req, res, next){
+        *           var sess = req.session;
+        *           if (sess.views) {
+        *             res.setHeader('Content-Type', 'text/html');
+        *             res.write('<p>views: ' + sess.views + '</p>');
+        *             res.write('<p>expires in: ' + (sess.cookie.maxAge / 1000) + 's</p>');
+        *             res.end();
+        *             sess.views++;
+        *           } else {
+        *             sess.views = 1;
+        *             res.end('welcome to the session demo. refresh!');
+        *           }
+        *         }
+        *       )).listen(3000);
+        *
+        * ## Session#regenerate()
+        *
+        *  To regenerate the session simply invoke the method, once complete
+        *  a new SID and `Session` instance will be initialized at `req.session`.
+        *
+        *      req.session.regenerate(function(err){
+        *        // will have a new session here
+        *      });
+        *
+        * ## Session#destroy()
+        *
+        *  Destroys the session, removing `req.session`, will be re-generated next request.
+        *
+        *      req.session.destroy(function(err){
+        *        // cannot access session here
+        *      });
+        * 
+        * ## Session#reload()
+        *
+        *  Reloads the session data.
+        *
+        *      req.session.reload(function(err){
+        *        // session updated
+        *      });
+        *
+        * ## Session#save()
+        *
+        *  Save the session.
+        *
+        *      req.session.save(function(err){
+        *        // session saved
+        *      });
+        *
+        * ## Session#touch()
+        *
+        *   Updates the `.maxAge` property. Typically this is
+        *   not necessary to call, as the session middleware does this for you.
+        *
+        * ## Session#cookie
+        *
+        *  Each session has a unique cookie object accompany it. This allows
+        *  you to alter the session cookie per visitor. For example we can
+        *  set `req.session.cookie.expires` to `false` to enable the cookie
+        *  to remain for only the duration of the user-agent.
+        *
+        * ## Session#maxAge
+        *
+        *  Alternatively `req.session.cookie.maxAge` will return the time
+        *  remaining in milliseconds, which we may also re-assign a new value
+        *  to adjust the `.expires` property appropriately. The following
+        *  are essentially equivalent
+        *
+        *     var hour = 3600000;
+        *     req.session.cookie.expires = new Date(Date.now() + hour);
+        *     req.session.cookie.maxAge = hour;
+        *
+        * For example when `maxAge` is set to `60000` (one minute), and 30 seconds
+        * has elapsed it will return `30000` until the current request has completed,
+        * at which time `req.session.touch()` is called to reset `req.session.maxAge`
+        * to its original value.
+        *
+        *     req.session.cookie.maxAge;
+        *     // => 30000
+        *
+        * Session Store Implementation:
+        *
+        * Every session store _must_ implement the following methods
+        *
+        *    - `.get(sid, callback)`
+        *    - `.set(sid, session, callback)`
+        *    - `.destroy(sid, callback)`
+        *
+        * Recommended methods include, but are not limited to:
+        *
+        *    - `.length(callback)`
+        *    - `.clear(callback)`
+        *
+        * For an example implementation view the [connect-redis](http://github.com/visionmedia/connect-redis) repo.
+        *
+        * @param options
+        */
+    session(options?: any): Express.Handler;
+
+    /**
+        * Hash the given `sess` object omitting changes
+        * to `.cookie`.
+        *
+        * @param sess
+        */
+    hash(sess: string): string;
+
+    /**
+        * Static:
+        *
+        *   Static file server with the given `root` path.
+        *
+        * Examples:
+        *
+        *     var oneDay = 86400000;
+        *
+        *     connect()
+        *       .use(connect.static(__dirname + '/public'))
+        *
+        *     connect()
+        *       .use(connect.static(__dirname + '/public', { maxAge: oneDay }))
+        *
+        * Options:
+        *
+        *    - `maxAge`     Browser cache maxAge in milliseconds. defaults to 0
+        *    - `hidden`     Allow transfer of hidden files. defaults to false
+        *    - `redirect`   Redirect to trailing "/" when the pathname is a dir. defaults to true
+        *
+        * @param root
+        * @param options
+        */
+    static(root: string, options?: any): Express.Handler;
+
+    /**
+        * Basic Auth:
+        *
+        * Enfore basic authentication by providing a `callback(user, pass)`,
+        * which must return `true` in order to gain access. Alternatively an async
+        * method is provided as well, invoking `callback(user, pass, callback)`. Populates
+        * `req.user`. The final alternative is simply passing username / password
+        * strings.
+        *
+        *  Simple username and password
+        *
+        *     connect(connect.basicAuth('username', 'password'));
+        *
+        *  Callback verification
+        *
+        *     connect()
+        *       .use(connect.basicAuth(function(user, pass){
+        *         return 'tj' == user & 'wahoo' == pass;
+        *       }))
+        *
+        *  Async callback verification, accepting `fn(err, user)`.
+        *
+        *     connect()
+        *       .use(connect.basicAuth(function(user, pass, fn){
+        *         User.authenticate({ user: user, pass: pass }, fn);
+        *       }))
+        *
+        * @param callback or username
+        * @param realm
+        */
+    basicAuth(callback: (user: string, pass: string, fn : Function) => void, realm?: string): Express.Handler;
+
+    basicAuth(callback: (user: string, pass: string) => boolean, realm?: string): Express.Handler;
+
+    basicAuth(user: string, pass: string, realm?: string): Express.Handler;
+
+    /**
+        * Compress:
+        *
+        * Compress response data with gzip/deflate.
+        *
+        * Filter:
+        *
+        *  A `filter` callback function may be passed to
+        *  replace the default logic of:
+        *
+        *     exports.filter = function(req, res){
+        *       return /json|text|javascript/.test(res.getHeader('Content-Type'));
+        *     };
+        *
+        * Options:
+        *
+        *  All remaining options are passed to the gzip/deflate
+        *  creation functions. Consult node's docs for additional details.
+        *
+        *   - `chunkSize` (default: 16*1024)
+        *   - `windowBits`
+        *   - `level`: 0-9 where 0 is no compression, and 9 is slow but best compression
+        *   - `memLevel`: 1-9 low is slower but uses less memory, high is fast but uses more
+        *   - `strategy`: compression strategy
+        *
+        * @param options
+        */
+    compress(options?: any): Express.Handler;
+
+    /**
+        * Cookie Session:
+        *
+        *   Cookie session middleware.
+        *
+        *      var app = connect();
+        *      app.use(connect.cookieParser());
+        *      app.use(connect.cookieSession({ secret: 'tobo!', cookie: { maxAge: 60 * 60 * 1000 }}));
+        *
+        * Options:
+        *
+        *   - `key` cookie name defaulting to `connect.sess`
+        *   - `secret` prevents cookie tampering
+        *   - `cookie` session cookie settings, defaulting to `{ path: '/', httpOnly: true, maxAge: null }`
+        *   - `proxy` trust the reverse proxy when setting secure cookies (via "x-forwarded-proto")
+        *
+        * Clearing sessions:
+        *
+        *  To clear the session simply set its value to `null`,
+        *  `cookieSession()` will then respond with a 1970 Set-Cookie.
+        *
+        *     req.session = null;
+        *
+        * @param options
+        */
+    cookieSession(options?: any): Express.Handler;
+
+    /**
+        * Anti CSRF:
+        *
+        * CSRF protection middleware.
+        *
+        * This middleware adds a `req.csrfToken()` function to make a token
+        * which should be added to requests which mutate
+        * state, within a hidden form field, query-string etc. This
+        * token is validated against the visitor's session.
+        *
+        * The default `value` function checks `req.body` generated
+        * by the `bodyParser()` middleware, `req.query` generated
+        * by `query()`, and the "X-CSRF-Token" header field.
+        *
+        * This middleware requires session support, thus should be added
+        * somewhere _below_ `session()` and `cookieParser()`.
+        *
+        * Options:
+        *
+        *    - `value` a function accepting the request, returning the token
+        *
+        * @param options
+        */
+    csrf(options?: {value?: Function}): Express.Handler;
+
+    /**
+        * Directory:
+        *
+        * Serve directory listings with the given `root` path.
+        *
+        * Options:
+        *
+        *  - `hidden` display hidden (dot) files. Defaults to false.
+        *  - `icons`  display icons. Defaults to false.
+        *  - `filter` Apply this filter function to files. Defaults to false.
+        *
+        * @param root
+        * @param options
+        */
+    directory(root: string, options?: any): Express.Handler;
+
+    /**
+        * Favicon:
+        *
+        * By default serves the connect favicon, or the favicon
+        * located by the given `path`.
+        *
+        * Options:
+        *
+        *   - `maxAge`  cache-control max-age directive, defaulting to 1 day
+        *
+        * Examples:
+        *
+        *   Serve default favicon:
+        *
+        *     connect()
+        *       .use(connect.favicon())
+        *
+        *   Serve favicon before logging for brevity:
+        *
+        *     connect()
+        *       .use(connect.favicon())
+        *       .use(connect.logger('dev'))
+        *
+        *   Serve custom favicon:
+        *
+        *     connect()
+        *       .use(connect.favicon('public/favicon.ico))
+        *
+        * @param path
+        * @param options
+        */
+    favicon(path?: string, options?: any): Express.Handler;
+
+    /**
+        * JSON:
+        *
+        * Parse JSON request bodies, providing the
+        * parsed object as `req.body`.
+        *
+        * Options:
+        *
+        *   - `strict`  when `false` anything `JSON.parse()` accepts will be parsed
+        *   - `reviver`  used as the second "reviver" argument for JSON.parse
+        *   - `limit`  byte limit disabled by default
+        *
+        * @param options
+        */
+    json(options?: any): Express.Handler;
+
+    /**
+        * Limit:
+        *
+        *   Limit request bodies to the given size in `bytes`.
+        *
+        *   A string representation of the bytesize may also be passed,
+        *   for example "5mb", "200kb", "1gb", etc.
+        *
+        *     connect()
+        *       .use(connect.limit('5.5mb'))
+        *       .use(handleImageUpload)
+        */
+    limit(bytes: number): Express.Handler;
+
+    limit(bytes: string): Express.Handler;
+
+    /**
+        * Logger:
+        *
+        * Log requests with the given `options` or a `format` string.
+        *
+        * Options:
+        *
+        *   - `format`  Format string, see below for tokens
+        *   - `stream`  Output stream, defaults to _stdout_
+        *   - `buffer`  Buffer duration, defaults to 1000ms when _true_
+        *   - `immediate`  Write log line on request instead of response (for response times)
+        *
+        * Tokens:
+        *
+        *   - `:req[header]` ex: `:req[Accept]`
+        *   - `:res[header]` ex: `:res[Content-Length]`
+        *   - `:http-version`
+        *   - `:response-time`
+        *   - `:remote-addr`
+        *   - `:date`
+        *   - `:method`
+        *   - `:url`
+        *   - `:referrer`
+        *   - `:user-agent`
+        *   - `:status`
+        *
+        * Formats:
+        *
+        *   Pre-defined formats that ship with connect:
+        *
+        *    - `default` ':remote-addr - - [:date] ":method :url HTTP/:http-version" :status :res[content-length] ":referrer" ":user-agent"'
+        *    - `short` ':remote-addr - :method :url HTTP/:http-version :status :res[content-length] - :response-time ms'
+        *    - `tiny`  ':method :url :status :res[content-length] - :response-time ms'
+        *    - `dev` concise output colored by response status for development use
+        *
+        * Examples:
+        *
+        *      connect.logger() // default
+        *      connect.logger('short')
+        *      connect.logger('tiny')
+        *      connect.logger({ immediate: true, format: 'dev' })
+        *      connect.logger(':method :url - :referrer')
+        *      connect.logger(':req[content-type] -> :res[content-type]')
+        *      connect.logger(function(tokens, req, res){ return 'some format string' })
+        *
+        * Defining Tokens:
+        *
+        *   To define a token, simply invoke `connect.logger.token()` with the
+        *   name and a callback function. The value returned is then available
+        *   as ":type" in this case.
+        *
+        *      connect.logger.token('type', function(req, res){ return req.headers['content-type']; })
+        *
+        * Defining Formats:
+        *
+        *   All default formats are defined this way, however it's public API as well:
+        *
+        *       connect.logger.format('name', 'string or function')
+        */
+    logger(options: string): Express.Handler;
+
+    logger(options: Function): Express.Handler;
+
+    logger(options?: any): Express.Handler;
+
+    /**
+        * Compile `fmt` into a function.
+        *
+        * @param fmt
+        */
+    compile(fmt: string): Express.Handler;
+
+    /**
+        * Define a token function with the given `name`,
+        * and callback `fn(req, res)`.
+        *
+        * @param name
+        * @param fn
+        */
+    token(name: string, fn: Function): any;
+
+    /**
+        * Define a `fmt` with the given `name`.
+        */
+    format(name: string, str: string): any;
+
+    format(name: string, str: Function): any;
+
+    /**
+        * Query:
+        *
+        * Automatically parse the query-string when available,
+        * populating the `req.query` object.
+        *
+        * Examples:
+        *
+        *     connect()
+        *       .use(connect.query())
+        *       .use(function(req, res){
+        *         res.end(JSON.stringify(req.query));
+        *       });
+        *
+        *  The `options` passed are provided to qs.parse function.
+        */
+    query(options: any): Express.Handler;
+
+    /**
+        * Reponse time:
+        *
+        * Adds the `X-Response-Time` header displaying the response
+        * duration in milliseconds.
+        */
+    responseTime(): Express.Handler;
+
+    /**
+        * Static cache:
+        *
+        * Enables a memory cache layer on top of
+        * the `static()` middleware, serving popular
+        * static files.
+        *
+        * By default a maximum of 128 objects are
+        * held in cache, with a max of 256k each,
+        * totalling ~32mb.
+        *
+        * A Least-Recently-Used (LRU) cache algo
+        * is implemented through the `Cache` object,
+        * simply rotating cache objects as they are
+        * hit. This means that increasingly popular
+        * objects maintain their positions while
+        * others get shoved out of the stack and
+        * garbage collected.
+        *
+        * Benchmarks:
+        *
+        *     static(): 2700 rps
+        *     node-static: 5300 rps
+        *     static() + staticCache(): 7500 rps
+        *
+        * Options:
+        *
+        *   - `maxObjects`  max cache objects [128]
+        *   - `maxLength`  max cache object length 256kb
+        */
+    staticCache(options: any): Express.Handler;
+
+    /**
+        * Timeout:
+        *
+        * Times out the request in `ms`, defaulting to `5000`. The
+        * method `req.clearTimeout()` is added to revert this behaviour
+        * programmatically within your application's middleware, routes, etc.
+        *
+        * The timeout error is passed to `next()` so that you may customize
+        * the response behaviour. This error has the `.timeout` property as
+        * well as `.status == 408`.
+        */
+    timeout(ms: number): Express.Handler;
+
+    /**
+        * Vhost:
+        * 
+        *   Setup vhost for the given `hostname` and `server`.
+        *
+        *     connect()
+        *       .use(connect.vhost('foo.com', fooApp))
+        *       .use(connect.vhost('bar.com', barApp))
+        *       .use(connect.vhost('*.com', mainApp))
+        *
+        *  The `server` may be a Connect server or
+        *  a regular Node `http.Server`. 
+        *
+        * @param hostname
+        * @param server
+        */
+    vhost(hostname: string, server: any): Express.Handler;
+
+    urlencoded(): any;
+
+    multipart(): any;
+}
diff --git a/node/node.d.ts b/node/node.d.ts
index 25e6c45f2..bb70b7d01 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -219,38 +219,106 @@ interface NodeTimer {
     unref() : void;
 }
 
+
 /************************************************
 *                                               *
 *              MODULES - EXTERNAL               *
 *                                               *
 ************************************************/
 
-declare module "querystring"    { import _ = NodeJs.QueryString;    export = _; }
-declare module "events"         { import _ = NodeJs.Events;         export = _; }
-declare module "http"           { import _ = NodeJs.Http;           export = _; }
-declare module "cluster"        { import _ = NodeJs.Cluster;        export = _; }
-declare module "zlib"           { import _ = NodeJs.Zlib;           export = _; }
-declare module "os"             { import _ = NodeJs.Os;             export = _; }
-declare module "https"          { import _ = NodeJs.Https;          export = _; }
-declare module "punycode"       { import _ = NodeJs.PunyCode;       export = _; }
-declare module "repl"           { import _ = NodeJs.Repl;           export = _; }
-declare module "readline"       { import _ = NodeJs.ReadLine;       export = _; }
-declare module "vm"             { import _ = NodeJs.Vm;             export = _; }
-declare module "child_process"  { import _ = NodeJs.ChildProcess;   export = _; }
-declare module "url"            { import _ = NodeJs.Url;            export = _; }
-declare module "dns"            { import _ = NodeJs.Dns;            export = _; }
-declare module "net"            { import _ = NodeJs.Net;            export = _; }
-declare module "dgram"          { import _ = NodeJs.Dgram;          export = _; }
-declare module "fs"             { import _ = NodeJs.Fs;             export = _; }
-declare module "path"           { import _ = NodeJs.Path;           export = _; }
-declare module "string_decoder" { import _ = NodeJs.StringDecoder;  export = _; }
-declare module "tls"            { import _ = NodeJs.Tls;            export = _; }
-declare module "crypto"         { import _ = NodeJs.Crypto;         export = _; }
-declare module "stream"         { import _ = NodeJs.Stream;         export = _; }
-declare module "util"           { import _ = NodeJs.Util;           export = _; }
-declare module "assert"         { import _ = NodeJs.Assert;         export = _; }
-declare module "tty"            { import _ = NodeJs.Tty;            export = _; }
-declare module "domain"         { import _ = NodeJs.Domain;         export = _; }
+declare module "events"         { import M = _ExternalShim_._NodeJs_.Events;    export = M; }
+declare module "http"           { import M = _ExternalShim_._NodeJs_.Http;      export = M; }
+declare module "url"            { import M = _ExternalShim_._NodeJs_.Url;       export = M; }
+declare module "net"            { import M = _ExternalShim_._NodeJs_.Net;       export = M; }
+declare module "querystring"    { var M: NodeJs.QueryString;    export = M; }
+declare module "cluster"        { var M: NodeJs.Cluster;        export = M; }
+declare module "zlib"           { var M: NodeJs.Zlib;           export = M; }
+declare module "os"             { var M: NodeJs.Os;             export = M; }
+declare module "https"          { var M: NodeJs.Https;          export = M; }
+declare module "punycode"       { var M: NodeJs.PunyCode;       export = M; }
+declare module "repl"           { var M: NodeJs.Repl;           export = M; }
+declare module "readline"       { var M: NodeJs.ReadLine;       export = M; }
+declare module "vm"             { var M: NodeJs.Vm;             export = M; }
+declare module "child_process"  { var M: NodeJs.ChildProcess;   export = M; }
+declare module "dns"            { var M: NodeJs.Dns;            export = M; }
+declare module "dgram"          { var M: NodeJs.Dgram;          export = M; }
+declare module "fs"             { var M: NodeJs.Fs;             export = M; }
+declare module "path"           { var M: NodeJs.Path;           export = M; }
+declare module "string_decoder" { var M: NodeJs.StringDecoder;  export = M; }
+declare module "tls"            { var M: NodeJs.Tls;            export = M; }
+declare module "crypto"         { var M: NodeJs.Crypto;         export = M; }
+declare module "stream"         { var M: NodeJs.Stream;         export = M; }
+declare module "util"           { var M: NodeJs.Util;           export = M; }
+declare module "assert"         { var M: NodeJs.Assert;         export = M; }
+declare module "tty"            { var M: NodeJs.Tty;            export = M; }
+declare module "domain"         { var M: NodeJs.Domain;         export = M; }
+
+
+/************************************************
+*                                               *
+*           EXTERNAL - INTERNAL SHIM            *
+*                                               *
+************************************************/
+
+// NB: This module exists so that 'pure' (ie non-instantiated) internal modules may
+// be declared in parallel with external modules, without breaking code that relies
+// on certain behaviours of external modules. It's a shim to support type definitions
+// that are already out there which use the pattern exemplified below:
+//
+//      declare module "mymodule" {
+//          import http   = require('http');
+//          ...
+//          server?: http.Server;
+//
+// Note that the type 'Server' is accessed via the variable 'http', meaning that
+// Server must be not just a type, but also a property on 'http'. The 'pure' typings
+// declared in the NodeJs module below don't support this usage. With the _ExternalTypes_
+// shim, the above code will continue working unchanged. New type definitions should
+// prefer something like:
+//
+//      declare module "mymodule" {
+//          ...
+//          server?: NodeJs.Http.Server;
+//
+// If all typings switch to using the pure internal types in NodeJs, this shim can be removed.
+
+declare module _ExternalShim_ {
+    export module _NodeJs_ {
+        export module Events {
+            export class EventEmitter implements NodeEventEmitter {
+                static listenerCount(emitter: EventEmitter, event: string): number;
+                addListener(event: string, listener: Function): EventEmitter;
+                on(event: string, listener: Function): EventEmitter;
+                once(event: string, listener: Function): EventEmitter;
+                removeListener(event: string, listener: Function): EventEmitter;
+                removeAllListeners(event?: string): EventEmitter;
+                setMaxListeners(n: number): void;
+                listeners(event: string): Function[];
+                emit(event: string, ...args: any[]): boolean;
+            }
+        }
+        export var Http: NodeJs.Http;
+        export module Http {
+            export interface Server extends NodeJs.Http.Server { }
+            export interface ServerRequest extends NodeJs.Http.ServerRequest { }
+            export interface ServerResponse extends NodeJs.Http.ServerResponse { }
+            export interface ClientRequest extends NodeJs.Http.ClientRequest { }
+            export interface ClientResponse extends NodeJs.Http.ClientResponse { }
+            export interface Agent extends NodeJs.Http.Agent { }
+        }
+        export var Net: NodeJs.Net;
+        export module Net {
+            export interface Socket extends NodeJs.Net.Socket { }
+            export interface Server extends NodeJs.Net.Server { }
+        }
+        export var Url: NodeJs.Url;
+        export module Url {
+            export interface Url extends NodeJs.Url.Url { }
+            export interface UrlOptions extends NodeJs.Url.UrlOptions { }
+        }
+    }
+}
+
 
 /************************************************
 *                                               *
@@ -259,17 +327,6 @@ declare module "domain"         { import _ = NodeJs.Domain;         export = _;
 ************************************************/
 
 declare module NodeJs {
-    // NB: All typings in this namespace are exposed in dual declaration spaces
-    // (i.e. as 'types' and as 'members' - see TypeScript Language Spec section 2.3)
-    // so that type information is available in both of the following scenarios:
-    //
-    //          // Normal import:
-    //          import http = require('http');
-    //          http.createServer((req, res) => {...})
-    //
-    //          // Typed variable:
-    //          var http: NodeJs.Http = someExpr() // a wrapped, mocked or otherwise obtained ref
-    //          http.createServer((req, res) => {...})
 
 
     // ---------- "querystring" module ----------
@@ -279,7 +336,6 @@ declare module NodeJs {
         escape(): any;
         unescape(): any;
     }
-    export var QueryString: QueryString;
 
 
     // ---------- "events" module ----------
@@ -290,8 +346,7 @@ declare module NodeJs {
         }
     }
     export module Events {
-        export class EventEmitter implements NodeEventEmitter {
-            static listenerCount(emitter: EventEmitter, event: string): number;
+        export interface EventEmitter extends NodeEventEmitter {
             addListener(event: string, listener: Function): EventEmitter;
             on(event: string, listener: Function): EventEmitter;
             once(event: string, listener: Function): EventEmitter;
@@ -313,7 +368,6 @@ declare module NodeJs {
         get(options: any, callback?: Function): Http.ClientRequest;
         globalAgent: Http.Agent;
     }
-    export var Http: Http;
     export module Http {
         export interface Server extends NodeEventEmitter {
             listen(port: number, hostname?: string, backlog?: number, callback?: Function): void;
@@ -422,31 +476,12 @@ declare module NodeJs {
         }
     }
     export module Cluster {
-        export var settings: Cluster.ClusterSettings;
-        export var isMaster: boolean;
-        export var isWorker: boolean;
-        export function setupMaster(settings?: Cluster.ClusterSettings): void;
-        export function fork(env?: any): Worker;
-        export function disconnect(callback?: Function): void;
-        export var worker: Worker;
-        export var workers: Worker[];
-
-        // Event emitter
-        export function addListener(event: string, listener: Function): void;
-        export function on(event: string, listener: Function): any;
-        export function once(event: string, listener: Function): void;
-        export function removeListener(event: string, listener: Function): void;
-        export function removeAllListeners(event?: string): void;
-        export function setMaxListeners(n: number): void;
-        export function listeners(event: string): Function[];
-        export function emit(event: string, ...args: any[]): boolean;
-
         export interface ClusterSettings {
             exec?: string;
             args?: string[];
             silent?: boolean;
         }
-        export class Worker extends Events.EventEmitter {
+        export interface Worker extends Events.EventEmitter {
             id: string;
             process: ChildProcess.ChildProcess;
             suicide: boolean;
@@ -509,7 +544,6 @@ declare module NodeJs {
         Z_DEFLATED: number;
         Z_NULL: number;
     }
-    export var Zlib: Zlib;
     export module Zlib {
         export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; }
         export interface Gzip extends ReadWriteStream { }
@@ -538,7 +572,6 @@ declare module NodeJs {
         networkInterfaces(): any;
         EOL: string;
     }
-    export var Os: Os;
 
 
     // ---------- "https" module ----------
@@ -550,7 +583,6 @@ declare module NodeJs {
         get(options: Https.RequestOptions, callback?: (res: NodeEventEmitter) => void): Http.ClientRequest;
         globalAgent: Https.Agent;
     }
-    export var Https: Https;
     export module Https {
         export interface ServerOptions {
             pfx?: any;
@@ -604,14 +636,12 @@ declare module NodeJs {
         }
         version: any;
     }
-    export var PunyCode: PunyCode;
 
 
     // ---------- "repl" module ----------
     export interface Repl {
         start(options: Repl.ReplOptions): NodeEventEmitter;
     }
-    export var Repl: Repl;
     export module Repl {
         export interface ReplOptions {
             prompt?: string;
@@ -631,7 +661,6 @@ declare module NodeJs {
     export interface ReadLine {
         createInterface(options: ReadLine.ReadLineOptions): ReadLine.ReadLine;
     }
-    export var ReadLine: ReadLine;
     export module ReadLine {
         export interface ReadLine extends NodeEventEmitter {
             setPrompt(prompt: string, length: number): void;
@@ -659,7 +688,6 @@ declare module NodeJs {
         createContext(initSandbox?: Vm.Context): Vm.Context;
         createScript(code: string, filename?: string): Vm.Script;
     }
-    export var Vm: Vm;
     export module Vm {
         export interface Context { }
         export interface Script {
@@ -705,7 +733,6 @@ declare module NodeJs {
             encoding?: string;
         }): ChildProcess.ChildProcess;
     }
-    export var ChildProcess: ChildProcess;
     export module ChildProcess {
         export interface ChildProcess extends NodeEventEmitter {
             stdin: WritableStream;
@@ -725,7 +752,6 @@ declare module NodeJs {
         format(url: Url.UrlOptions): string;
         resolve(from: string, to: string): string;
     }
-    export var Url: Url;
     export module Url {
         export interface Url {
             href: string;
@@ -767,7 +793,6 @@ declare module NodeJs {
         resolveCname(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
         reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[];
     }
-    export var Dns: Dns;
 
 
     // ---------- "net" module ----------
@@ -786,7 +811,6 @@ declare module NodeJs {
         isIPv4(input: string): boolean;
         isIPv6(input: string): boolean;
     }
-    export var Net: Net;
     export module Net {
         export interface Socket extends ReadWriteStream {
 
@@ -837,7 +861,6 @@ declare module NodeJs {
     export interface Dgram {
         createSocket(type: string, callback?: Function): Dgram.Socket;
     }
-    export var Dgram: Dgram;
     export module Dgram {
         interface Socket extends NodeEventEmitter {
             send(buf: NodeBuffer, offset: number, length: number, port: number, address: string, callback?: Function): void;
@@ -968,7 +991,6 @@ declare module NodeJs {
             string?: string;
         }): Fs.WriteStream;
     }
-    export var Fs: Fs;
     export module Fs {
         export interface Stats {
             isFile(): boolean;
@@ -1011,14 +1033,12 @@ declare module NodeJs {
         extname(p: string): string;
         sep: string;
     }
-    export var Path: Path;
 
 
     // ---------- "string_decoder" module ----------
     export interface StringDecoder {
         StringDecoder: new(encoding: string) => StringDecoder.StringDecoder;
     }
-    export var StringDecoder: StringDecoder;
     export module StringDecoder {
         export interface StringDecoder {
             write(buffer: NodeBuffer): string;
@@ -1037,7 +1057,6 @@ declare module NodeJs {
         connect(port: number, options?: Tls.ConnectionOptions, secureConnectListener?: () =>void ): Tls.ClearTextStream;
         createSecurePair(credentials?: Crypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): Tls.SecurePair;
     }
-    export var Tls: Tls;
     export module Tls {
         export interface TlsOptions {
             pfx?: any;   //string or buffer
@@ -1124,7 +1143,6 @@ declare module NodeJs {
         pseudoRandomBytes(size: number): NodeBuffer;
         pseudoRandomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
     }
-    export var Crypto: Crypto;
     export module Crypto {
         export interface CredentialDetails {
             pfx: string;
@@ -1190,8 +1208,7 @@ declare module NodeJs {
             encoding?: string;
             objectMode?: boolean;
         }
-        export class Readable extends Events.EventEmitter implements ReadableStream {
-            constructor(opts?: ReadableOptions);
+        export interface Readable extends Events.EventEmitter, ReadableStream {
             readable: boolean;
             _read(size: number): void;
             read(size?: number): any;
@@ -1209,8 +1226,7 @@ declare module NodeJs {
             highWaterMark?: number;
             decodeStrings?: boolean;
         }
-        export class Writable extends Events.EventEmitter implements WritableStream {
-            constructor(opts?: WritableOptions);
+        export interface Writable extends Events.EventEmitter, WritableStream {
             writable: boolean;
             _write(data: NodeBuffer, encoding: string, callback: Function): void;
             _write(data: string, encoding: string, callback: Function): void;
@@ -1227,8 +1243,7 @@ declare module NodeJs {
         }
 
         // Note: Duplex extends both Readable and Writable.
-        export class Duplex extends Readable implements ReadWriteStream {
-            constructor(opts?: DuplexOptions);
+        export interface Duplex extends Readable, ReadWriteStream {
             writable: boolean;
             _write(data: NodeBuffer, encoding: string, callback: Function): void;
             _write(data: string, encoding: string, callback: Function): void;
@@ -1243,8 +1258,7 @@ declare module NodeJs {
         export interface TransformOptions extends ReadableOptions, WritableOptions {}
 
         // Note: Transform lacks the _read and _write methods of Readable/Writable.
-        export class Transform extends Events.EventEmitter implements ReadWriteStream {
-            constructor(opts?: TransformOptions);
+        export interface Transform extends Events.EventEmitter, ReadWriteStream {
             readable: boolean;
             writable: boolean;
             _transform(chunk: NodeBuffer, encoding: string, callback: Function): void;
@@ -1268,7 +1282,7 @@ declare module NodeJs {
             end(str: string, cb?: Function): void;
             end(str: string, encoding?: string, cb?: Function): void;
         }
-        export class PassThrough extends Transform {}
+        export interface PassThrough extends Transform {}
     }
 
 
@@ -1288,7 +1302,6 @@ declare module NodeJs {
         isError(object: any): boolean;
         inherits(constructor: any, superConstructor: any): void;
     }
-    export var Util: Util;
     export module Util {
         export interface InspectOptions {
             showHidden?: boolean;
@@ -1326,30 +1339,7 @@ declare module NodeJs {
         }
         ifError(value: any): void;
     }
-    export function Assert(value: any, message?: string): void;
     export module Assert {
-        export function fail(actual?: any, expected?: any, message?: string, operator?: string): void;
-        export function ok(value: any, message?: string): void;
-        export function equal(actual: any, expected: any, message?: string): void;
-        export function notEqual(actual: any, expected: any, message?: string): void;
-        export function deepEqual(actual: any, expected: any, message?: string): void;
-        export function notDeepEqual(acutal: any, expected: any, message?: string): void;
-        export function strictEqual(actual: any, expected: any, message?: string): void;
-        export function notStrictEqual(actual: any, expected: any, message?: string): void;
-        export var throws: {
-            (block: Function, message?: string): void;
-            (block: Function, error: Function, message?: string): void;
-            (block: Function, error: RegExp, message?: string): void;
-            (block: Function, error: (err: any) => boolean, message?: string): void;
-        }
-        export var doesNotThrow: {
-            (block: Function, message?: string): void;
-            (block: Function, error: Function, message?: string): void;
-            (block: Function, error: RegExp, message?: string): void;
-            (block: Function, error: (err: any) => boolean, message?: string): void;
-        }
-        export function ifError(value: any): void;
-
         export interface AssertionErrorOptions {
             message?: string;
             actual?: any;
@@ -1357,8 +1347,7 @@ declare module NodeJs {
             operator?: string;
             stackStartFunction?: Function
         }
-        export class AssertionError implements Error {
-            constructor(options?: AssertionErrorOptions);
+        export interface AssertionError extends Error {
             name: string;
             message: string;
             actual: any;
@@ -1375,7 +1364,6 @@ declare module NodeJs {
         WriteStream: new() => Tty.WriteStream;
         isatty(fd: number): boolean;
     }
-    export var Tty: Tty;
     export module Tty {
         export interface ReadStream extends Net.Socket {
             isRaw: boolean;
@@ -1394,7 +1382,7 @@ declare module NodeJs {
         create(): Domain.Domain;
     }
     export module Domain {
-        export class Domain extends Events.EventEmitter {
+        export interface Domain extends Events.EventEmitter {
             run(fn: Function): void;
             add(emitter: NodeEventEmitter): void;
             remove(emitter: NodeEventEmitter): void;

From daa12d74b1c2f4e711500fcdd8943726a928cf85 Mon Sep 17 00:00:00 2001
From: yortus <yortus@gmail.com>
Date: Mon, 31 Mar 2014 16:04:21 +0800
Subject: [PATCH 234/309] Re-added get(string):string to express

---
 express/express.d.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/express/express.d.ts b/express/express.d.ts
index 2f1bdeee2..674975da8 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -143,6 +143,8 @@ declare module Express {
 
         all(path: string, ...callbacks: Function[]): void;
 
+        get(name: string): string;
+
         get(name: string, ...handlers: RequestFunction[]): T;
 
         get(name: RegExp, ...handlers: RequestFunction[]): T;
@@ -175,6 +177,8 @@ declare module Express {
 
         all(path: string, ...callbacks: Function[]): void;
 
+        get(name: string): string;
+
         get(name: string, ...handlers: RequestFunction[]): Router;
 
         get(name: RegExp, ...handlers: RequestFunction[]): Router;

From 4e315942f51e8156a6d141b16d4e030286943333 Mon Sep 17 00:00:00 2001
From: yortus <yortus@gmail.com>
Date: Mon, 31 Mar 2014 16:37:41 +0800
Subject: [PATCH 235/309] Moved get(string)=>sting to Application

---
 express/express.d.ts | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/express/express.d.ts b/express/express.d.ts
index 674975da8..d5fbbdaac 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -143,8 +143,6 @@ declare module Express {
 
         all(path: string, ...callbacks: Function[]): void;
 
-        get(name: string): string;
-
         get(name: string, ...handlers: RequestFunction[]): T;
 
         get(name: RegExp, ...handlers: RequestFunction[]): T;
@@ -177,8 +175,6 @@ declare module Express {
 
         all(path: string, ...callbacks: Function[]): void;
 
-        get(name: string): string;
-
         get(name: string, ...handlers: RequestFunction[]): Router;
 
         get(name: RegExp, ...handlers: RequestFunction[]): Router;
@@ -1006,6 +1002,12 @@ declare module Express {
             */
         set (setting: string, val: string): Application;
 
+        get(name: string): string;
+
+        get(name: string, ...handlers: RequestFunction[]): Application;
+
+        get(name: RegExp, ...handlers: RequestFunction[]): Application;
+
         /**
             * Return the app's absolute pathname
             * based on the parent(s) that have

From 0e143ef3e724cb2ae51e6d2e25dc41fd2a688f65 Mon Sep 17 00:00:00 2001
From: Asger Feldthaus <asf@cs.au.dk>
Date: Mon, 31 Mar 2014 14:26:26 +0200
Subject: [PATCH 236/309] various bugfixes in d3.d.ts

---
 d3/d3.d.ts | 132 ++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 86 insertions(+), 46 deletions(-)

diff --git a/d3/d3.d.ts b/d3/d3.d.ts
index 50d9eb6e6..1fcf3917d 100644
--- a/d3/d3.d.ts
+++ b/d3/d3.d.ts
@@ -528,7 +528,7 @@ declare module D3 {
         /**
         * gets the touch positions relative to a specified container.
         */
-        touches(container: any): Array<number>;
+        touches(container: any): Array<Array<number>>;
 
         /**
         * If the specified value is a function, returns the specified value.
@@ -1031,7 +1031,7 @@ declare module D3 {
             ceil: (date: Date) => Date;
             range: Range;
             offset: (date: Date, step: number) => Date;
-            utc: Interval;
+            utc?: Interval;
         }
 
         export interface TimeFormat {
@@ -1066,7 +1066,7 @@ declare module D3 {
             histogram(): HistogramLayout;
             pack(): PackLayout;
             partition(): PartitionLayout;
-            treeMap(): TreeMapLayout;
+            treemap(): TreeMapLayout;
         }
 
         export interface StackLayout {
@@ -1266,7 +1266,7 @@ declare module D3 {
         }
 
         export interface BundleLayout{
-            (links: Array<GraphLink>): Array<GraphNode>;
+            (links: Array<GraphLink>): Array<Array<GraphNode>>;
         }
 
         export interface ChordLayout {
@@ -1279,15 +1279,15 @@ declare module D3 {
                 (padding: number): ChordLayout;
             }
             sortGroups: {
-                (): Array<number>;
+                (): (a: number, b: number) => number;
                 (comparator: (a: number, b: number) => number): ChordLayout;
             }
             sortSubgroups: {
-                (): Array<number>;
+                (): (a: number, b: number) => number;
                 (comparator: (a: number, b: number) => number): ChordLayout;
             }
             sortChords: {
-                (): Array<GraphLink>;
+                (): (a: number, b: number) => number;
                 (comparator: (a: number, b: number) => number): ChordLayout;
             }
             chords(): Array<GraphLink>;
@@ -2480,7 +2480,7 @@ declare module D3 {
                 (values: any[]): Scale;
                 (): any[];
             };
-            invertExtent(y: any): any[];
+            invertExtent?(y: any): any[];
             copy(): Scale;
         }
 
@@ -2579,13 +2579,31 @@ declare module D3 {
             (value: number): number;
         }
 
-        export interface IdentityScale extends QuantitiveScale {
+        export interface IdentityScale extends Scale {
             /**
             * Get the range value corresponding to a given domain value.
             *
             * @param value Domain Value
             */
             (value: number): number;
+            /**
+            * Get the domain value corresponding to a given range value.
+            *
+            * @param value Range Value
+            */
+            invert(value: number): number;
+            /**
+            * get representative values from the input domain.
+            *
+            * @param count Aproximate representative values to return.
+            */
+            ticks(count: number): any[];
+            /**
+            * get a formatter for displaying tick values
+            *
+            * @param count Aproximate representative values to return
+            */
+            tickFormat(count: number): (n: number) => string;
         }
 
         export interface SqrtScale extends QuantitiveScale {
@@ -2910,11 +2928,11 @@ declare module D3 {
             /**
             * create a standard projection from a raw projection.
             */
-            projection(raw: (lambda: any, phi: any) => any): Projection;
+            projection(raw: RawProjection): Projection;
             /**
             * create a standard projection from a mutable raw projection.
             */
-            projectionMutator(rawFactory: (lambda: number, phi: number) => Array<number>): Projection;
+            projectionMutator(rawFactory: RawProjection): ProjectionMutator;
             /**
             * the Albers equal-area conic projection.
             */
@@ -2928,82 +2946,82 @@ declare module D3 {
             */
             azimuthalEqualArea: {
                 (): Projection;
-                raw(): Projection;
+                raw: RawProjection;
             }
             /**
             * the azimuthal equidistant projection.
             */
             azimuthalEquidistant: {
                 (): Projection;
-                raw(): Projection;
+                raw: RawProjection;
             }
             /**
             * the conic conformal projection.
             */
             conicConformal: {
                 (): Projection;
-                raw(): Projection;
+                raw: RawProjection;
             }
             /**
             * the conic equidistant projection.
             */
             conicEquidistant: {
                 (): Projection;
-                raw(): Projection;
+                raw: RawProjection;
             }
             /**
             * the conic equal-area (a.k.a. Albers) projection.
             */
             conicEqualArea: {
                 (): Projection;
-                raw(): Projection;
+                raw: RawProjection;
             }
             /**
             * the equirectangular (plate carreé) projection.
             */
             equirectangular: {
                 (): Projection;
-                raw(): Projection;
+                raw: RawProjection;
             }
             /**
             * the gnomonic projection.
             */
             gnomonic: {
                 (): Projection;
-                raw(): Projection;
+                raw: RawProjection;
             }
             /**
             * the spherical Mercator projection.
             */
             mercator: {
                 (): Projection;
-                raw(): Projection;
+                raw: RawProjection;
             }
             /**
             * the azimuthal orthographic projection.
             */
-            othographic: {
+            orthographic: {
                 (): Projection;
-                raw(): Projection;
+                raw: RawProjection;
             }
             /**
             * the azimuthal stereographic projection.
             */
             stereographic: {
                 (): Projection;
-                raw(): Projection;
+                raw: RawProjection;
             }
             /**
             * the transverse Mercator projection.
             */
             transverseMercator: {
                 (): Projection;
-                raw(): Projection;
+                raw: RawProjection;
             }
             /**
             * convert a GeoJSON object to a geometry stream.
             */
-            stream(object: GeoJSON, listener: any): Stream;
+            stream(object: GeoJSON, listener: Stream);
             /**
             *
             */
@@ -3011,7 +3029,7 @@ declare module D3 {
             /**
             *
             */
-            greatArc: GreatArc;
+            greatArc(): GreatArc;
             /**
             *
             */
@@ -3107,7 +3125,7 @@ declare module D3 {
 
         export interface Graticule{
             (): GeoJSON;
-            lines(): GeoJSON;
+            lines(): Array<GeoJSON>;
             outline(): GeoJSON;
             extent: {
                 (): Array<Array<number>>;
@@ -3161,9 +3179,14 @@ declare module D3 {
             type: string;
         }
 
+        export interface RawProjection {
+            (lambda: number, phi: number): Array<number>;
+            invert?(x: number, y: number): Array<number>;
+        }
+
         export interface Projection {
             (coordinates: Array<number>): Array<number>;
-            invert(point: Array<number>): Array<number>;
+            invert?(point: Array<number>): Array<number>;
             rotate: {
                 (): Array<number>;
                 (rotation: Array<number>): Projection;
@@ -3192,7 +3215,7 @@ declare module D3 {
                 (): number;
                 (precision: number): Projection;
             };
-            stream(listener?: any): Stream;
+            stream(listener?: Stream): Stream;
         }
 
         export interface Stream {
@@ -3208,6 +3231,10 @@ declare module D3 {
             (location: Array<number>): Rotation;
             invert(location: Array<number>): Rotation;
         }
+
+        export interface ProjectionMutator {
+            (lambda: number, phi: number): Projection;
+        }
     }
 
     // Geometry
@@ -3225,15 +3252,25 @@ declare module D3 {
             /**
             * constructs a quadtree for an array of points.
             */
-            quadtree: Quadtree;
+            quadtree(): QuadtreeFactory;
             /**
-            * constructs a polygon
+            * Constructs a new quadtree for the specified array of points.
             */
-            polygon: Polygon;
+            quadtree(points: Array<Point>, x1: number, y1: number, x2: number, y2: number): Quadtree;
+            /**
+            * Constructs a new quadtree for the specified array of points.
+            */
+            quadtree(points: Array<Point>, width: number, height: number): Quadtree;
+            /**
+            * Returns the input array of vertices with additional methods attached
+            */
+            polygon(vertices:Array<Vertice>): Polygon;
             /**
             * creates a new hull layout with the default settings.
             */
-            hull: Hull;
+            hull(): Hull;
+
+            hull(vertices:Array<Vertice>): Array<Vertice>;
         }
 
         export interface Vertice extends Array<number> {
@@ -3244,10 +3281,6 @@ declare module D3 {
         }
 
         export interface Polygon extends Array<Vertice> {
-            /**
-            * Returns the input array of vertices with additional methods attached
-            */
-            (vertices: Array<Vertice>): Polygon;
             /**
             * Returns the signed area of this polygon
             */
@@ -3262,7 +3295,7 @@ declare module D3 {
             clip(subject: Polygon): Polygon;
         }
 
-        export interface Quadtree {
+        export interface QuadtreeFactory {
             /**
             * Constructs a new quadtree for the specified array of points.
             */
@@ -3275,22 +3308,29 @@ declare module D3 {
             * Constructs a new quadtree for the specified array of points.
             */
             (points: Array<Point>, width: number, height: number): Quadtree;
-            /**
-            * Adds a new point to the quadtree.
-            */
-            add(point: Point): Quadtree;
-            visit(callback: any): Quadtree;
+
             x: {
                 (): (d: any) => any;
-                (accesor: (d: any) => any): Quadtree;
+                (accesor: (d: any) => any): QuadtreeFactory;
 
             }
             y: {
                 (): (d: any) => any;
-                (accesor: (d: any) => any): Quadtree;
+                (accesor: (d: any) => any): QuadtreeFactory;
 
             }
-        size(size: Array<number>): Quadtree;
+            size(): Array<number>;
+            size(size: Array<number>): QuadtreeFactory;
+            extent(): Array<Array<number>>;
+            extent(points: Array<Array<number>>): QuadtreeFactory;
+        }
+
+        export interface Quadtree {
+            /**
+            * Adds a new point to the quadtree.
+            */
+            add(point: Point);
+            visit(callback: any);
         }
 
         export interface Point {
@@ -3378,7 +3418,7 @@ declare module D3 {
         }
 
         export interface Hull {
-            (vertices: Array<Vertice>): Hull;
+            (vertices: Array<Vertice>): Array<Vertice>;
             x: {
                 (): (d: any) => any;
                 (accesor: (d: any) => any): any;

From d89a73caaf7aa99158996a0cb1fa42fee6e2cd8d Mon Sep 17 00:00:00 2001
From: Christiaan Rakowski <cs.rakowski@gmail.com>
Date: Mon, 31 Mar 2014 15:35:47 +0200
Subject: [PATCH 237/309] misplace quote

---
 jquery/jquery.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts
index b42f77aaa..fb0429488 100644
--- a/jquery/jquery.d.ts
+++ b/jquery/jquery.d.ts
@@ -2447,7 +2447,7 @@ interface JQuery {
      */
     keydown(handler: (eventObject: JQueryKeyEventObject) => any): JQuery;
     /**
-     * Bind an event handler to the keydown"" JavaScript event
+     * Bind an event handler to the "keydown" JavaScript event
      *
      * @param eventData An object containing data that will be passed to the event handler.
      * @param handler A function to execute each time the event is triggered.

From a1c23bddc395feac6d99e163bf858692d3886a4b Mon Sep 17 00:00:00 2001
From: Asger Feldthaus <asf@cs.au.dk>
Date: Mon, 31 Mar 2014 16:07:42 +0200
Subject: [PATCH 238/309] d3.d.ts: fixed raw signatures for conic projections

---
 d3/d3.d.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/d3/d3.d.ts b/d3/d3.d.ts
index 1fcf3917d..520b7f799 100644
--- a/d3/d3.d.ts
+++ b/d3/d3.d.ts
@@ -2960,21 +2960,21 @@ declare module D3 {
             */
             conicConformal: {
                 (): Projection;
-                raw: RawProjection;
+                raw(phi1:number, phi2:number): RawProjection;
             }
             /**
             * the conic equidistant projection.
             */
             conicEquidistant: {
                 (): Projection;
-                raw: RawProjection;
+                raw(phi1:number, phi2:number): RawProjection;
             }
             /**
             * the conic equal-area (a.k.a. Albers) projection.
             */
             conicEqualArea: {
                 (): Projection;
-                raw: RawProjection;
+                raw(phi1:number, phi2:number): RawProjection;
             }
             /**
             * the equirectangular (plate carreé) projection.

From cbd13655e56d2554de624e24d1cc6ee870612f85 Mon Sep 17 00:00:00 2001
From: Troy Gerwien <yortus@gmail.com>
Date: Mon, 31 Mar 2014 22:20:09 +0800
Subject: [PATCH 239/309] add hash to NodeJs.Url.Url

---
 node/node.d.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/node/node.d.ts b/node/node.d.ts
index bb70b7d01..8318c278d 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -272,7 +272,7 @@ declare module "domain"         { var M: NodeJs.Domain;         export = M; }
 //
 // Note that the type 'Server' is accessed via the variable 'http', meaning that
 // Server must be not just a type, but also a property on 'http'. The 'pure' typings
-// declared in the NodeJs module below don't support this usage. With the _ExternalTypes_
+// declared in the NodeJs module below don't support this usage. With the _ExternalShim_
 // shim, the above code will continue working unchanged. New type definitions should
 // prefer something like:
 //
@@ -764,6 +764,7 @@ declare module NodeJs {
             search: string;
             query: string;
             slashes: boolean;
+            hash: string;
         }
         export interface UrlOptions {
             protocol?: string;

From f75091e08e8e8e41826dfd86c8e9445987954598 Mon Sep 17 00:00:00 2001
From: Asger Feldthaus <asf@cs.au.dk>
Date: Mon, 31 Mar 2014 16:21:20 +0200
Subject: [PATCH 240/309] d3.d.ts: no-return -> void return types

---
 d3/d3.d.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/d3/d3.d.ts b/d3/d3.d.ts
index 520b7f799..ca1c502e6 100644
--- a/d3/d3.d.ts
+++ b/d3/d3.d.ts
@@ -3021,7 +3021,7 @@ declare module D3 {
             /**
             * convert a GeoJSON object to a geometry stream.
             */
-            stream(object: GeoJSON, listener: Stream);
+            stream(object: GeoJSON, listener: Stream): void;
             /**
             *
             */
@@ -3329,8 +3329,8 @@ declare module D3 {
             /**
             * Adds a new point to the quadtree.
             */
-            add(point: Point);
-            visit(callback: any);
+            add(point: Point): void;
+            visit(callback: any): void;
         }
 
         export interface Point {

From 2aabba990578c37e8143a9dfbbe30e523a312a96 Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Tue, 1 Apr 2014 00:04:35 +0900
Subject: [PATCH 241/309] Improvement node.d.ts typings

---
 node/node.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/node/node.d.ts b/node/node.d.ts
index 8318c278d..d84769ec4 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -919,7 +919,7 @@ declare module NodeJs {
         readlinkSync(path: string): string;
         realpath(path: string, callback?: (err: ErrnoException, resolvedPath: string) => any): void;
         realpath(path: string, cache: {[path: string]: string}, callback: (err: ErrnoException, resolvedPath: string) =>any): void;
-        realpathSync(path: string, cache?: {[path: string]: string}): void;
+        realpathSync(path: string, cache?: {[path: string]: string}): string;
         unlink(path: string, callback?: (err?: ErrnoException) => void): void;
         unlinkSync(path: string): void;
         rmdir(path: string, callback?: (err?: ErrnoException) => void): void;

From 8d5da26ea8fad4a35ddaf8cdccc61d7ccc853836 Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Tue, 1 Apr 2014 00:30:31 +0900
Subject: [PATCH 242/309] Added update-notifier.d.ts

---
 README.md                                |  1 +
 update-notifier/update-notifier-tests.ts | 19 +++++++++++++
 update-notifier/update-notifier.d.ts     | 36 ++++++++++++++++++++++++
 3 files changed, 56 insertions(+)
 create mode 100644 update-notifier/update-notifier-tests.ts
 create mode 100644 update-notifier/update-notifier.d.ts

diff --git a/README.md b/README.md
index 377dcdd56..b2149c5cb 100755
--- a/README.md
+++ b/README.md
@@ -271,6 +271,7 @@ List of Definitions
 * [Underscore.js (Typed)](http://underscorejs.org/) (by [Josh Baldwin](https://github.com/jbaldwin/))
 * [Underscore-ko.js](https://github.com/kamranayub/UnderscoreKO) (by [Maurits Elbers](https://github.com/MagicMau))
 * [universal-analytics](https://github.com/peaksandpies/universal-analytics) (by [Bart van der Schoor](https://github.com/Bartvds))
+* [update-notifier](https://github.com/yeoman/update-notifier) (by [vvakame](https://github.com/vvakame))
 * [urlrouter](https://github.com/fengmk2/urlrouter) (by [Carlos Ballesteros Velasco](https://github.com/soywiz))
 * [UUID.js](https://github.com/LiosK/UUID.js) (by [Jason Jarrett](https://github.com/staxmanade))
 * [Valerie](https://github.com/davewatts/valerie) (by [Howard Richards](https://github.com/conficient))
diff --git a/update-notifier/update-notifier-tests.ts b/update-notifier/update-notifier-tests.ts
new file mode 100644
index 000000000..58fdbd623
--- /dev/null
+++ b/update-notifier/update-notifier-tests.ts
@@ -0,0 +1,19 @@
+/// <reference path="./update-notifier.d.ts" />
+
+import updateNotifier = require('update-notifier');
+
+var notifier = updateNotifier();
+
+if (notifier.update) {
+	notifier.notify();
+}
+
+console.log(notifier.update);
+
+var notifier = updateNotifier({
+	updateCheckInterval: 1000 * 60 * 60 * 24 * 7 // 1 week
+});
+
+if (notifier.update) {
+	notifier.notify('Update available: ' + notifier.update.latest);
+}
diff --git a/update-notifier/update-notifier.d.ts b/update-notifier/update-notifier.d.ts
new file mode 100644
index 000000000..965b3631b
--- /dev/null
+++ b/update-notifier/update-notifier.d.ts
@@ -0,0 +1,36 @@
+// Type definitions for update-notifier
+// Project: https://github.com/yeoman/update-notifier
+// Definitions by: vvakame <https://github.com/vvakame>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "update-notifier" {
+	function t(settings?:t.ISettings):t.IResult;
+
+	module t {
+
+		export interface IResult {
+			update: IUpdateInfo;
+			notify(message?:string):void;
+		}
+
+		export interface ISettings {
+			callback?:(error:any, update?:IUpdateInfo)=>any; // default null
+			packagePath?:string; // default 'package.json'
+			packageName?:string; // default Inferred from packageFile
+			packageVersion?:string; // default Inferred from packageFile
+			updateCheckInterval?:number; // default 1000 * 60 * 60 * 24 (1 day)
+			updateCheckTimeout?:number; // default 20000 (20 secs)
+			registryUrl?:string; // default 'http://registry.npmjs.org/%s'
+		}
+
+		export interface IUpdateInfo {
+			latest:string;
+			current:string;
+			type:string;
+			date:string;
+			name:string;
+		}
+	}
+
+	export = t;
+}

From c45713047fd9d8624c00623ee84ce5fe1c6b6db9 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Mon, 31 Mar 2014 17:23:41 +0200
Subject: [PATCH 243/309] Revert "Merge pull request #1931 from
 yortus/node-express-referenceable-types"

This reverts commit 0bfcda81b494a9f123325b198d202a850cfc88d0, reversing
changes made to 2c52e529f9694028e02445c4fe046eda732acd49.
---
 express/express.d.ts | 3512 +++++++++++++++++++++---------------------
 node/node.d.ts       | 2074 ++++++++++++-------------
 2 files changed, 2695 insertions(+), 2891 deletions(-)

diff --git a/express/express.d.ts b/express/express.d.ts
index d5fbbdaac..243aa41d4 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -12,1860 +12,1804 @@
 
 /// <reference path="../node/node.d.ts" />
 
-
-/************************************************
-*                                               *
-*                EXTERNAL MODULE                *
-*                                               *
-************************************************/
-
 declare module "express" {
-    import M = _ExternalShim_._Express_;
-    export = M;
-}
+    import http = require('http');
 
+    // Merged declaration, e is both a callable function and a namespace
+    function e(): e.Express;
 
-/************************************************
-*                                               *
-*           EXTERNAL - INTERNAL SHIM            *
-*                                               *
-************************************************/
+    module e {
+        interface IRoute {
+            path: string;
 
-// NB: This module exists so that 'pure' (ie non-instantiated) internal modules may
-// be declared in parallel with external modules, without breaking code that relies
-// on certain behaviours of external modules. It's a shim to support type definitions
-// that are already out there which use the pattern exemplified below:
-//
-//      declare module "mymodule" {
-//          import express   = require('express');
-//          ...
-//          request?: express.Request;
-//
-// Note that the type 'Request' is accessed via the variable 'express', meaning that
-// Request must be not just a type, but also a property on 'express'. The 'pure' typings
-// declared in the Express module below don't support this usage. With the _ExternalTypes_
-// shim, the above code will continue working unchanged. New type definitions should
-// prefer something like:
-//
-//      declare module "mymodule" {
-//          ...
-//          request?: Express.Request;
-//
-// If all typings switch to using the pure internal types in Express, this shim can be removed.
-declare module _ExternalShim_ {
-    export var _Express_: Express;
-    export module _Express_ {
-        export interface Request extends Express.Request { }
-        export interface Response extends Express.Response { }
-        export interface Express extends Express.Express { }
-        export interface Application extends Express.Application { }
-    }
-}
+            method: string;
 
+            callbacks: Function[];
 
-/************************************************
-*                                               *
-*                INTERNAL MODULE                *
-*                                               *
-************************************************/
+            regexp: any;
 
-declare module Express {
-
-    export interface IRoute {
-        path: string;
-
-        method: string;
-
-        callbacks: Function[];
-
-        regexp: any;
-
-        /**
-        * Check if this route matches `path`, if so
-        * populate `.params`.
-        */
-        match(path: string): boolean;
-    }
-
-    export interface Route extends IRoute {
-        path: string;
-
-        method: string;
-
-        callbacks: Function[];
-
-        regexp: any;
-        match(path: string): boolean;
-    }
-
-    export interface IRouter<T> {
-        /**
-            * Map the given param placeholder `name`(s) to the given callback(s).
-            *
-            * Parameter mapping is used to provide pre-conditions to routes
-            * which use normalized placeholders. For example a _:user_id_ parameter
-            * could automatically load a user's information from the database without
-            * any additional code,
-            *
-            * The callback uses the samesignature as middleware, the only differencing
-            * being that the value of the placeholder is passed, in this case the _id_
-            * of the user. Once the `next()` function is invoked, just like middleware
-            * it will continue on to execute the route, or subsequent parameter functions.
-            *
-            *      app.param('user_id', function(req, res, next, id){
-            *        User.find(id, function(err, user){
-            *          if (err) {
-            *            next(err);
-            *          } else if (user) {
-            *            req.user = user;
-            *            next();
-            *          } else {
-            *            next(new Error('failed to load user'));
-            *          }
-            *        });
-            *      });
-            *
-            * @param name
-            * @param fn
+            /**
+            * Check if this route matches `path`, if so
+            * populate `.params`.
             */
-        param(name: string, fn: Function): T;
+            match(path: string): boolean;
+        }
 
-        param(name: string[], fn: Function): T;
+        class Route implements IRoute {
+            path: string;
 
-        /**
-            * Special-cased "all" method, applying the given route `path`,
-            * middleware, and callback to _every_ HTTP method.
-            *
-            * @param path
-            * @param fn
-            */
-        all(path: string, fn?: (req: Request, res: Response, next: Function) => any): T;
+            method: string;
 
-        all(path: string, ...callbacks: Function[]): void;
+            callbacks: Function[];
 
-        get(name: string, ...handlers: RequestFunction[]): T;
+            regexp: any;
+            match(path: string): boolean;
 
-        get(name: RegExp, ...handlers: RequestFunction[]): T;
+            /**
+             * Initialize `Route` with the given HTTP `method`, `path`,
+             * and an array of `callbacks` and `options`.
+             *
+             * Options:
+             *
+             *   - `sensitive`    enable case-sensitive routes
+             *   - `strict`       enable strict matching for trailing slashes
+             *
+             * @param method
+             * @param path
+             * @param callbacks
+             * @param options
+             */
+            new (method: string, path: string, callbacks: Function[], options: any): Route;
+        }
 
-        post(name: string, ...handlers: RequestFunction[]): T;
+        interface IRouter<T> {
+            /**
+             * Map the given param placeholder `name`(s) to the given callback(s).
+             *
+             * Parameter mapping is used to provide pre-conditions to routes
+             * which use normalized placeholders. For example a _:user_id_ parameter
+             * could automatically load a user's information from the database without
+             * any additional code,
+             *
+             * The callback uses the samesignature as middleware, the only differencing
+             * being that the value of the placeholder is passed, in this case the _id_
+             * of the user. Once the `next()` function is invoked, just like middleware
+             * it will continue on to execute the route, or subsequent parameter functions.
+             *
+             *      app.param('user_id', function(req, res, next, id){
+             *        User.find(id, function(err, user){
+             *          if (err) {
+             *            next(err);
+             *          } else if (user) {
+             *            req.user = user;
+             *            next();
+             *          } else {
+             *            next(new Error('failed to load user'));
+             *          }
+             *        });
+             *      });
+             *
+             * @param name
+             * @param fn
+             */
+            param(name: string, fn: Function): T;
 
-        post(name: RegExp, ...handlers: RequestFunction[]): T;
+            param(name: string[], fn: Function): T;
 
-        put(name: string, ...handlers: RequestFunction[]): T;
+            /**
+             * Special-cased "all" method, applying the given route `path`,
+             * middleware, and callback to _every_ HTTP method.
+             *
+             * @param path
+             * @param fn
+             */
+            all(path: string, fn?: (req: Request, res: Response, next: Function) => any): T;
 
-        put(name: RegExp, ...handlers: RequestFunction[]): T;
+            all(path: string, ...callbacks: Function[]): void;
 
-        del(name: string, ...handlers: RequestFunction[]): T;
+            get(name: string, ...handlers: RequestFunction[]): T;
 
-        del(name: RegExp, ...handlers: RequestFunction[]): T;
+            get(name: RegExp, ...handlers: RequestFunction[]): T;
+
+            post(name: string, ...handlers: RequestFunction[]): T;
+
+            post(name: RegExp, ...handlers: RequestFunction[]): T;
+
+            put(name: string, ...handlers: RequestFunction[]): T;
+
+            put(name: RegExp, ...handlers: RequestFunction[]): T;
+
+            del(name: string, ...handlers: RequestFunction[]): T;
+
+            del(name: RegExp, ...handlers: RequestFunction[]): T;
             
-        patch(name: string, ...handlers: RequestFunction[]): T;
+            patch(name: string, ...handlers: RequestFunction[]): T;
  
-        patch(name: RegExp, ...handlers: RequestFunction[]): T;
-    }
+            patch(name: RegExp, ...handlers: RequestFunction[]): T;
+        }
 
-    export interface Router extends IRouter<Router> {
-        middleware (): any;
+        export class Router implements IRouter<Router> {
+          new (options?: any): Router;
 
-        param(name: string, fn: Function): Router;
+          middleware (): any;
 
-        param(name: any[], fn: Function): Router;
+          param(name: string, fn: Function): Router;
 
-        all(path: string, fn?: (req: Request, res: Response, next: Function) => any): Router;
+          param(name: any[], fn: Function): Router;
 
-        all(path: string, ...callbacks: Function[]): void;
+          all(path: string, fn?: (req: Request, res: Response, next: Function) => any): Router;
 
-        get(name: string, ...handlers: RequestFunction[]): Router;
+          all(path: string, ...callbacks: Function[]): void;
 
-        get(name: RegExp, ...handlers: RequestFunction[]): Router;
+          get(name: string, ...handlers: RequestFunction[]): Router;
 
-        post(name: string, ...handlers: RequestFunction[]): Router;
+          get(name: RegExp, ...handlers: RequestFunction[]): Router;
 
-        post(name: RegExp, ...handlers: RequestFunction[]): Router;
+          post(name: string, ...handlers: RequestFunction[]): Router;
 
-        put(name: string, ...handlers: RequestFunction[]): Router;
+          post(name: RegExp, ...handlers: RequestFunction[]): Router;
 
-        put(name: RegExp, ...handlers: RequestFunction[]): Router;
+          put(name: string, ...handlers: RequestFunction[]): Router;
 
-        del(name: string, ...handlers: RequestFunction[]): Router;
+          put(name: RegExp, ...handlers: RequestFunction[]): Router;
 
-        del(name: RegExp, ...handlers: RequestFunction[]): Router;
+          del(name: string, ...handlers: RequestFunction[]): Router;
+
+          del(name: RegExp, ...handlers: RequestFunction[]): Router;
           
-        patch(name: string, ...handlers: RequestFunction[]): Router;
+          patch(name: string, ...handlers: RequestFunction[]): Router;
  
-        patch(name: RegExp, ...handlers: RequestFunction[]): Router;
-    }
-
-    export interface Handler {
-        (req: Request, res: Response, next?: Function): void;
-    }
-
-    export interface CookieOptions {
-        maxAge?: number;
-        signed?: boolean;
-        expires?: Date;
-        httpOnly?: boolean;
-        path?: string;
-        domain?: string;
-        secure?: boolean;
-    }
-
-    export interface Errback { (err: Error): void; }
-
-    export interface Session {
-        /**
-            * Update reset `.cookie.maxAge` to prevent
-            * the cookie from expiring when the
-            * session is still active.
-            *
-            * @return {Session} for chaining
-            * @api public
-            */
-        touch(): Session;
-
-        /**
-            * Reset `.maxAge` to `.originalMaxAge`.
-            */
-        resetMaxAge(): Session;
-
-        /**
-            * Save the session data with optional callback `fn(err)`.
-            */
-        save(fn: Function): Session;
-
-        /**
-            * Re-loads the session data _without_ altering
-            * the maxAge properties. Invokes the callback `fn(err)`,
-            * after which time if no exception has occurred the
-            * `req.session` property will be a new `Session` object,
-            * although representing the same session.
-            */
-        reload(fn: Function): Session;
-
-        /**
-            * Destroy `this` session.
-            */
-        destroy(fn: Function): Session;
-
-        /**
-            * Regenerate this request's session.
-            */
-        regenerate(fn: Function): Session;
-
-        user: any;
-
-        error: string;
-
-        success: string;
-
-        views: any;
-
-        count: number;
-    }
-
-    export interface Request {
-
-        session: Session;
-
-        /**
-            * Return request header.
-            *
-            * The `Referrer` header field is special-cased,
-            * both `Referrer` and `Referer` are interchangeable.
-            *
-            * Examples:
-            *
-            *     req.get('Content-Type');
-            *     // => "text/plain"
-            *
-            *     req.get('content-type');
-            *     // => "text/plain"
-            *
-            *     req.get('Something');
-            *     // => undefined
-            *
-            * Aliased as `req.header()`.
-            *
-            * @param name
-            */
-        get (name: string): string;
-
-        header(name: string): string;
-
-        headers: string[];
-
-        /**
-            * Check if the given `type(s)` is acceptable, returning
-            * the best match when true, otherwise `undefined`, in which
-            * case you should respond with 406 "Not Acceptable".
-            *
-            * The `type` value may be a single mime type string
-            * such as "application/json", the extension name
-            * such as "json", a comma-delimted list such as "json, html, text/plain",
-            * or an array `["json", "html", "text/plain"]`. When a list
-            * or array is given the _best_ match, if any is returned.
-            *
-            * Examples:
-            *
-            *     // Accept: text/html
-            *     req.accepts('html');
-            *     // => "html"
-            *
-            *     // Accept: text/*, application/json
-            *     req.accepts('html');
-            *     // => "html"
-            *     req.accepts('text/html');
-            *     // => "text/html"
-            *     req.accepts('json, text');
-            *     // => "json"
-            *     req.accepts('application/json');
-            *     // => "application/json"
-            *
-            *     // Accept: text/*, application/json
-            *     req.accepts('image/png');
-            *     req.accepts('png');
-            *     // => undefined
-            *
-            *     // Accept: text/*;q=.5, application/json
-            *     req.accepts(['html', 'json']);
-            *     req.accepts('html, json');
-            *     // => "json"
-            */
-        accepts(type: string): string;
-
-        accepts(type: string[]): string;
-
-        /**
-            * Check if the given `charset` is acceptable,
-            * otherwise you should respond with 406 "Not Acceptable".
-            *
-            * @param charset
-            */
-        acceptsCharset(charset: string): boolean;
-
-        /**
-            * Check if the given `lang` is acceptable,
-            * otherwise you should respond with 406 "Not Acceptable".
-            *
-            * @param lang
-            */
-        acceptsLanguage(lang: string): boolean;
-
-        /**
-            * Parse Range header field,
-            * capping to the given `size`.
-            *
-            * Unspecified ranges such as "0-" require
-            * knowledge of your resource length. In
-            * the case of a byte range this is of course
-            * the total number of bytes. If the Range
-            * header field is not given `null` is returned,
-            * `-1` when unsatisfiable, `-2` when syntactically invalid.
-            *
-            * NOTE: remember that ranges are inclusive, so
-            * for example "Range: users=0-3" should respond
-            * with 4 users when available, not 3.
-            *
-            * @param size
-            */
-        range(size: number): any[];
-
-        /**
-            * Return an array of Accepted media types
-            * ordered from highest quality to lowest.
-            */
-        accepted: MediaType[];
-
-        /**
-            * Return an array of Accepted languages
-            * ordered from highest quality to lowest.
-            *
-            * Examples:
-            *
-            *     Accept-Language: en;q=.5, en-us
-            *     ['en-us', 'en']
-            */
-        acceptedLanguages: any[];
-
-        /**
-            * Return an array of Accepted charsets
-            * ordered from highest quality to lowest.
-            *
-            * Examples:
-            *
-            *     Accept-Charset: iso-8859-5;q=.2, unicode-1-1;q=0.8
-            *     ['unicode-1-1', 'iso-8859-5']
-            */
-        acceptedCharsets: any[];
-
-        /**
-            * Return the value of param `name` when present or `defaultValue`.
-            *
-            *  - Checks route placeholders, ex: _/user/:id_
-            *  - Checks body params, ex: id=12, {"id":12}
-            *  - Checks query string params, ex: ?id=12
-            *
-            * To utilize request bodies, `req.body`
-            * should be an object. This can be done by using
-            * the `connect.bodyParser()` middleware.
-            *
-            * @param name
-            * @param defaultValue
-            */
-        param(name: string, defaultValue?: any): string;
-
-        /**
-            * Check if the incoming request contains the "Content-Type"
-            * header field, and it contains the give mime `type`.
-            *
-            * Examples:
-            *
-            *      // With Content-Type: text/html; charset=utf-8
-            *      req.is('html');
-            *      req.is('text/html');
-            *      req.is('text/*');
-            *      // => true
-            *
-            *      // When Content-Type is application/json
-            *      req.is('json');
-            *      req.is('application/json');
-            *      req.is('application/*');
-            *      // => true
-            *
-            *      req.is('html');
-            *      // => false
-            *
-            * @param type
-            */
-        is(type: string): boolean;
-
-        /**
-            * Return the protocol string "http" or "https"
-            * when requested with TLS. When the "trust proxy"
-            * setting is enabled the "X-Forwarded-Proto" header
-            * field will be trusted. If you're running behind
-            * a reverse proxy that supplies https for you this
-            * may be enabled.
-            */
-        protocol: string;
-
-        /**
-            * Short-hand for:
-            *
-            *    req.protocol == 'https'
-            */
-        secure: boolean;
-
-        /**
-            * Return the remote address, or when
-            * "trust proxy" is `true` return
-            * the upstream addr.
-            */
-        ip: string;
-
-        /**
-            * When "trust proxy" is `true`, parse
-            * the "X-Forwarded-For" ip address list.
-            *
-            * For example if the value were "client, proxy1, proxy2"
-            * you would receive the array `["client", "proxy1", "proxy2"]`
-            * where "proxy2" is the furthest down-stream.
-            */
-        ips: string[];
-
-        /**
-            * Return basic auth credentials.
-            *
-            * Examples:
-            *
-            *    // http://tobi:hello@example.com
-            *    req.auth
-            *    // => { username: 'tobi', password: 'hello' }
-            */
-        auth: any;
-
-        /**
-            * Return subdomains as an array.
-            *
-            * Subdomains are the dot-separated parts of the host before the main domain of
-            * the app. By default, the domain of the app is assumed to be the last two
-            * parts of the host. This can be changed by setting "subdomain offset".
-            *
-            * For example, if the domain is "tobi.ferrets.example.com":
-            * If "subdomain offset" is not set, req.subdomains is `["ferrets", "tobi"]`.
-            * If "subdomain offset" is 3, req.subdomains is `["tobi"]`.
-            */
-        subdomains: string[];
-
-        /**
-            * Short-hand for `url.parse(req.url).pathname`.
-            */
-        path: string;
-
-        /**
-            * Parse the "Host" header field hostname.
-            */
-        host: string;
-
-        /**
-            * Check if the request is fresh, aka
-            * Last-Modified and/or the ETag
-            * still match.
-            */
-        fresh: boolean;
-
-        /**
-            * Check if the request is stale, aka
-            * "Last-Modified" and / or the "ETag" for the
-            * resource has changed.
-            */
-        stale: boolean;
-
-        /**
-            * Check if the request was an _XMLHttpRequest_.
-            */
-        xhr: boolean;
-
-        //body: { username: string; password: string; remember: boolean; title: string; };
-        body: any;
-
-        //cookies: { string; remember: boolean; };
-        cookies: any;
-
-        /**
-            * Used to generate an anti-CSRF token.
-            * Placed by the CSRF protection middleware.
-            */
-        csrfToken(): string;
-
-        method: string;
-
-        params: any;
-
-        user: any;
-
-        authenticatedUser: any;
-
-        files: any;
-
-        /**
-            * Clear cookie `name`.
-            *
-            * @param name
-            * @param options
-            */
-        clearCookie(name: string, options?: any): Response;
-
-        query: any;
-
-        route: any;
-
-        signedCookies: any;
-
-        originalUrl: string;
-
-        url: string;
-    }
-
-    export interface MediaType {
-        value: string;
-        quality: number;
-        type: string;
-        subtype:  string;
-    }
-
-    export interface Send {
-        (status: number, body?: any): Response;
-        (body: any): Response;
-    }
-
-    export interface Response extends NodeJs.Http.ServerResponse {
-        /**
-            * Set status `code`.
-            *
-            * @param code
-            */
-        status(code: number): Response;
-
-        /**
-            * Set Link header field with the given `links`.
-            *
-            * Examples:
-            *
-            *    res.links({
-            *      next: 'http://api.example.com/users?page=2',
-            *      last: 'http://api.example.com/users?page=5'
-            *    });
-            *
-            * @param links
-            */
-        links(links: any): Response;
-
-        /**
-            * Send a response.
-            *
-            * Examples:
-            *
-            *     res.send(new Buffer('wahoo'));
-            *     res.send({ some: 'json' });
-            *     res.send('<p>some html</p>');
-            *     res.send(404, 'Sorry, cant find that');
-            *     res.send(404);
-            */
-        send: Send;
-
-        /**
-            * Send JSON response.
-            *
-            * Examples:
-            *
-            *     res.json(null);
-            *     res.json({ user: 'tj' });
-            *     res.json(500, 'oh noes!');
-            *     res.json(404, 'I dont have that');
-            */
-        json: Send;
-
-        /**
-            * Send JSON response with JSONP callback support.
-            *
-            * Examples:
-            *
-            *     res.jsonp(null);
-            *     res.jsonp({ user: 'tj' });
-            *     res.jsonp(500, 'oh noes!');
-            *     res.jsonp(404, 'I dont have that');
-            */
-        jsonp: Send;
-
-        /**
-            * Transfer the file at the given `path`.
-            *
-            * Automatically sets the _Content-Type_ response header field.
-            * The callback `fn(err)` is invoked when the transfer is complete
-            * or when an error occurs. Be sure to check `res.sentHeader`
-            * if you wish to attempt responding, as the header and some data
-            * may have already been transferred.
-            *
-            * Options:
-            *
-            *   - `maxAge` defaulting to 0
-            *   - `root`   root directory for relative filenames
-            *
-            * Examples:
-            *
-            *  The following example illustrates how `res.sendfile()` may
-            *  be used as an alternative for the `static()` middleware for
-            *  dynamic situations. The code backing `res.sendfile()` is actually
-            *  the same code, so HTTP cache support etc is identical.
-            *
-            *     app.get('/user/:uid/photos/:file', function(req, res){
-            *       var uid = req.params.uid
-            *         , file = req.params.file;
-            *
-            *       req.user.mayViewFilesFrom(uid, function(yes){
-            *         if (yes) {
-            *           res.sendfile('/uploads/' + uid + '/' + file);
-            *         } else {
-            *           res.send(403, 'Sorry! you cant see that.');
-            *         }
-            *       });
-            *     });
-            */
-        sendfile(path: string): void;
-
-        sendfile(path: string, options: any): void;
-
-        sendfile(path: string, fn: Errback): void;
-
-        sendfile(path: string, options: any, fn: Errback): void;
-
-        /**
-            * Transfer the file at the given `path` as an attachment.
-            *
-            * Optionally providing an alternate attachment `filename`,
-            * and optional callback `fn(err)`. The callback is invoked
-            * when the data transfer is complete, or when an error has
-            * ocurred. Be sure to check `res.headerSent` if you plan to respond.
-            *
-            * This method uses `res.sendfile()`.
-            */
-        download(path: string): void;
-
-        download(path: string, filename: string): void;
-
-        download(path: string, fn: Errback): void;
-
-        download(path: string, filename: string, fn: Errback): void;
-
-        /**
-            * Set _Content-Type_ response header with `type` through `mime.lookup()`
-            * when it does not contain "/", or set the Content-Type to `type` otherwise.
-            *
-            * Examples:
-            *
-            *     res.type('.html');
-            *     res.type('html');
-            *     res.type('json');
-            *     res.type('application/json');
-            *     res.type('png');
-            *
-            * @param type
-            */
-        contentType(type: string): Response;
-
-        /**
-            * Set _Content-Type_ response header with `type` through `mime.lookup()`
-            * when it does not contain "/", or set the Content-Type to `type` otherwise.
-            *
-            * Examples:
-            *
-            *     res.type('.html');
-            *     res.type('html');
-            *     res.type('json');
-            *     res.type('application/json');
-            *     res.type('png');
-            *
-            * @param type
-            */
-        type(type: string): Response;
-
-        /**
-            * Respond to the Acceptable formats using an `obj`
-            * of mime-type callbacks.
-            *
-            * This method uses `req.accepted`, an array of
-            * acceptable types ordered by their quality values.
-            * When "Accept" is not present the _first_ callback
-            * is invoked, otherwise the first match is used. When
-            * no match is performed the server responds with
-            * 406 "Not Acceptable".
-            *
-            * Content-Type is set for you, however if you choose
-            * you may alter this within the callback using `res.type()`
-            * or `res.set('Content-Type', ...)`.
-            *
-            *    res.format({
-            *      'text/plain': function(){
-            *        res.send('hey');
-            *      },
-            *
-            *      'text/html': function(){
-            *        res.send('<p>hey</p>');
-            *      },
-            *
-            *      'appliation/json': function(){
-            *        res.send({ message: 'hey' });
-            *      }
-            *    });
-            *
-            * In addition to canonicalized MIME types you may
-            * also use extnames mapped to these types:
-            *
-            *    res.format({
-            *      text: function(){
-            *        res.send('hey');
-            *      },
-            *
-            *      html: function(){
-            *        res.send('<p>hey</p>');
-            *      },
-            *
-            *      json: function(){
-            *        res.send({ message: 'hey' });
-            *      }
-            *    });
-            *
-            * By default Express passes an `Error`
-            * with a `.status` of 406 to `next(err)`
-            * if a match is not made. If you provide
-            * a `.default` callback it will be invoked
-            * instead.
-            *
-            * @param obj
-            */
-        format(obj: any): Response;
-
-        /**
-            * Set _Content-Disposition_ header to _attachment_ with optional `filename`.
-            *
-            * @param filename
-            */
-        attachment(filename?: string): Response;
-
-        /**
-            * Set header `field` to `val`, or pass
-            * an object of header fields.
-            *
-            * Examples:
-            *
-            *    res.set('Foo', ['bar', 'baz']);
-            *    res.set('Accept', 'application/json');
-            *    res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
-            *
-            * Aliased as `res.header()`.
-            */
-        set (field: any): Response;
-
-        set (field: string, value?: string): Response;
-
-        header(field: any): Response;
-
-        header(field: string, value?: string): Response;
-
-        /**
-            * Get value for header `field`.
-            *
-            * @param field
-            */
-        get (field: string): string;
-
-        /**
-            * Clear cookie `name`.
-            *
-            * @param name
-            * @param options
-            */
-        clearCookie(name: string, options?: any): Response;
-
-        /**
-            * Set cookie `name` to `val`, with the given `options`.
-            *
-            * Options:
-            *
-            *    - `maxAge`   max-age in milliseconds, converted to `expires`
-            *    - `signed`   sign the cookie
-            *    - `path`     defaults to "/"
-            *
-            * Examples:
-            *
-            *    // "Remember Me" for 15 minutes
-            *    res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });
-            *
-            *    // save as above
-            *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
-            */
-        cookie(name: string, val: string, options: CookieOptions): Response;
-
-        cookie(name: string, val: any, options: CookieOptions): Response;
-
-        cookie(name: string, val: any): Response;
-
-        /**
-            * Set the location header to `url`.
-            *
-            * The given `url` can also be the name of a mapped url, for
-            * example by default express supports "back" which redirects
-            * to the _Referrer_ or _Referer_ headers or "/".
-            *
-            * Examples:
-            *
-            *    res.location('/foo/bar').;
-            *    res.location('http://example.com');
-            *    res.location('../login'); // /blog/post/1 -> /blog/login
-            *
-            * Mounting:
-            *
-            *   When an application is mounted and `res.location()`
-            *   is given a path that does _not_ lead with "/" it becomes
-            *   relative to the mount-point. For example if the application
-            *   is mounted at "/blog", the following would become "/blog/login".
-            *
-            *      res.location('login');
-            *
-            *   While the leading slash would result in a location of "/login":
-            *
-            *      res.location('/login');
-            *
-            * @param url
-            */
-        location(url: string): Response;
-
-        /**
-            * Redirect to the given `url` with optional response `status`
-            * defaulting to 302.
-            *
-            * The resulting `url` is determined by `res.location()`, so
-            * it will play nicely with mounted apps, relative paths,
-            * `"back"` etc.
-            *
-            * Examples:
-            *
-            *    res.redirect('/foo/bar');
-            *    res.redirect('http://example.com');
-            *    res.redirect(301, 'http://example.com');
-            *    res.redirect('http://example.com', 301);
-            *    res.redirect('../login'); // /blog/post/1 -> /blog/login
-            */
-        redirect(url: string): void;
-
-        redirect(status: number, url: string): void;
-
-        redirect(url: string, status: number): void;
-
-        /**
-            * Render `view` with the given `options` and optional callback `fn`.
-            * When a callback function is given a response will _not_ be made
-            * automatically, otherwise a response of _200_ and _text/html_ is given.
-            *
-            * Options:
-            *
-            *  - `cache`     boolean hinting to the engine it should cache
-            *  - `filename`  filename of the view being rendered
-            */
-
-        render(view: string, options?: Object, callback?: (err: Error, html: string) => void ): void;
+          patch(name: RegExp, ...handlers: RequestFunction[]): Router;
+        }
+
+        interface Handler {
+            (req: Request, res: Response, next?: Function): void;
+        }
+
+        interface CookieOptions {
+            maxAge?: number;
+            signed?: boolean;
+            expires?: Date;
+            httpOnly?: boolean;
+            path?: string;
+            domain?: string;
+            secure?: boolean;
+        }
+
+        interface Errback { (err: Error): void; }
+
+        interface Session {
+            /**
+             * Update reset `.cookie.maxAge` to prevent
+             * the cookie from expiring when the
+             * session is still active.
+             *
+             * @return {Session} for chaining
+             * @api public
+             */
+            touch(): Session;
+
+            /**
+             * Reset `.maxAge` to `.originalMaxAge`.
+             */
+            resetMaxAge(): Session;
+
+            /**
+             * Save the session data with optional callback `fn(err)`.
+             */
+            save(fn: Function): Session;
+
+            /**
+             * Re-loads the session data _without_ altering
+             * the maxAge properties. Invokes the callback `fn(err)`,
+             * after which time if no exception has occurred the
+             * `req.session` property will be a new `Session` object,
+             * although representing the same session.
+             */
+            reload(fn: Function): Session;
+
+            /**
+             * Destroy `this` session.
+             */
+            destroy(fn: Function): Session;
+
+            /**
+             * Regenerate this request's session.
+             */
+            regenerate(fn: Function): Session;
+
+            user: any;
+
+            error: string;
+
+            success: string;
+
+            views: any;
+
+            count: number;
+        }
+
+        interface Request {
+
+            session: Session;
+
+            /**
+             * Return request header.
+             *
+             * The `Referrer` header field is special-cased,
+             * both `Referrer` and `Referer` are interchangeable.
+             *
+             * Examples:
+             *
+             *     req.get('Content-Type');
+             *     // => "text/plain"
+             *
+             *     req.get('content-type');
+             *     // => "text/plain"
+             *
+             *     req.get('Something');
+             *     // => undefined
+             *
+             * Aliased as `req.header()`.
+             *
+             * @param name
+             */
+            get (name: string): string;
+
+            header(name: string): string;
+
+            headers: string[];
+
+            /**
+             * Check if the given `type(s)` is acceptable, returning
+             * the best match when true, otherwise `undefined`, in which
+             * case you should respond with 406 "Not Acceptable".
+             *
+             * The `type` value may be a single mime type string
+             * such as "application/json", the extension name
+             * such as "json", a comma-delimted list such as "json, html, text/plain",
+             * or an array `["json", "html", "text/plain"]`. When a list
+             * or array is given the _best_ match, if any is returned.
+             *
+             * Examples:
+             *
+             *     // Accept: text/html
+             *     req.accepts('html');
+             *     // => "html"
+             *
+             *     // Accept: text/*, application/json
+             *     req.accepts('html');
+             *     // => "html"
+             *     req.accepts('text/html');
+             *     // => "text/html"
+             *     req.accepts('json, text');
+             *     // => "json"
+             *     req.accepts('application/json');
+             *     // => "application/json"
+             *
+             *     // Accept: text/*, application/json
+             *     req.accepts('image/png');
+             *     req.accepts('png');
+             *     // => undefined
+             *
+             *     // Accept: text/*;q=.5, application/json
+             *     req.accepts(['html', 'json']);
+             *     req.accepts('html, json');
+             *     // => "json"
+             */
+            accepts(type: string): string;
+
+            accepts(type: string[]): string;
+
+            /**
+             * Check if the given `charset` is acceptable,
+             * otherwise you should respond with 406 "Not Acceptable".
+             *
+             * @param charset
+             */
+            acceptsCharset(charset: string): boolean;
+
+            /**
+             * Check if the given `lang` is acceptable,
+             * otherwise you should respond with 406 "Not Acceptable".
+             *
+             * @param lang
+             */
+            acceptsLanguage(lang: string): boolean;
+
+            /**
+             * Parse Range header field,
+             * capping to the given `size`.
+             *
+             * Unspecified ranges such as "0-" require
+             * knowledge of your resource length. In
+             * the case of a byte range this is of course
+             * the total number of bytes. If the Range
+             * header field is not given `null` is returned,
+             * `-1` when unsatisfiable, `-2` when syntactically invalid.
+             *
+             * NOTE: remember that ranges are inclusive, so
+             * for example "Range: users=0-3" should respond
+             * with 4 users when available, not 3.
+             *
+             * @param size
+             */
+            range(size: number): any[];
+
+            /**
+             * Return an array of Accepted media types
+             * ordered from highest quality to lowest.
+             */
+            accepted: MediaType[];
+
+            /**
+             * Return an array of Accepted languages
+             * ordered from highest quality to lowest.
+             *
+             * Examples:
+             *
+             *     Accept-Language: en;q=.5, en-us
+             *     ['en-us', 'en']
+             */
+            acceptedLanguages: any[];
+
+            /**
+             * Return an array of Accepted charsets
+             * ordered from highest quality to lowest.
+             *
+             * Examples:
+             *
+             *     Accept-Charset: iso-8859-5;q=.2, unicode-1-1;q=0.8
+             *     ['unicode-1-1', 'iso-8859-5']
+             */
+            acceptedCharsets: any[];
+
+            /**
+             * Return the value of param `name` when present or `defaultValue`.
+             *
+             *  - Checks route placeholders, ex: _/user/:id_
+             *  - Checks body params, ex: id=12, {"id":12}
+             *  - Checks query string params, ex: ?id=12
+             *
+             * To utilize request bodies, `req.body`
+             * should be an object. This can be done by using
+             * the `connect.bodyParser()` middleware.
+             *
+             * @param name
+             * @param defaultValue
+             */
+            param(name: string, defaultValue?: any): string;
+
+            /**
+             * Check if the incoming request contains the "Content-Type"
+             * header field, and it contains the give mime `type`.
+             *
+             * Examples:
+             *
+             *      // With Content-Type: text/html; charset=utf-8
+             *      req.is('html');
+             *      req.is('text/html');
+             *      req.is('text/*');
+             *      // => true
+             *
+             *      // When Content-Type is application/json
+             *      req.is('json');
+             *      req.is('application/json');
+             *      req.is('application/*');
+             *      // => true
+             *
+             *      req.is('html');
+             *      // => false
+             *
+             * @param type
+             */
+            is(type: string): boolean;
+
+            /**
+             * Return the protocol string "http" or "https"
+             * when requested with TLS. When the "trust proxy"
+             * setting is enabled the "X-Forwarded-Proto" header
+             * field will be trusted. If you're running behind
+             * a reverse proxy that supplies https for you this
+             * may be enabled.
+             */
+            protocol: string;
+
+            /**
+             * Short-hand for:
+             *
+             *    req.protocol == 'https'
+             */
+            secure: boolean;
+
+            /**
+             * Return the remote address, or when
+             * "trust proxy" is `true` return
+             * the upstream addr.
+             */
+            ip: string;
+
+            /**
+             * When "trust proxy" is `true`, parse
+             * the "X-Forwarded-For" ip address list.
+             *
+             * For example if the value were "client, proxy1, proxy2"
+             * you would receive the array `["client", "proxy1", "proxy2"]`
+             * where "proxy2" is the furthest down-stream.
+             */
+            ips: string[];
+
+            /**
+             * Return basic auth credentials.
+             *
+             * Examples:
+             *
+             *    // http://tobi:hello@example.com
+             *    req.auth
+             *    // => { username: 'tobi', password: 'hello' }
+             */
+            auth: any;
+
+            /**
+             * Return subdomains as an array.
+             *
+             * Subdomains are the dot-separated parts of the host before the main domain of
+             * the app. By default, the domain of the app is assumed to be the last two
+             * parts of the host. This can be changed by setting "subdomain offset".
+             *
+             * For example, if the domain is "tobi.ferrets.example.com":
+             * If "subdomain offset" is not set, req.subdomains is `["ferrets", "tobi"]`.
+             * If "subdomain offset" is 3, req.subdomains is `["tobi"]`.
+             */
+            subdomains: string[];
+
+            /**
+             * Short-hand for `url.parse(req.url).pathname`.
+             */
+            path: string;
+
+            /**
+             * Parse the "Host" header field hostname.
+             */
+            host: string;
+
+            /**
+             * Check if the request is fresh, aka
+             * Last-Modified and/or the ETag
+             * still match.
+             */
+            fresh: boolean;
+
+            /**
+             * Check if the request is stale, aka
+             * "Last-Modified" and / or the "ETag" for the
+             * resource has changed.
+             */
+            stale: boolean;
+
+            /**
+             * Check if the request was an _XMLHttpRequest_.
+             */
+            xhr: boolean;
+
+            //body: { username: string; password: string; remember: boolean; title: string; };
+            body: any;
+
+            //cookies: { string; remember: boolean; };
+            cookies: any;
+
+            /**
+             * Used to generate an anti-CSRF token.
+             * Placed by the CSRF protection middleware.
+             */
+            csrfToken(): string;
+
+            method: string;
+
+            params: any;
+
+            user: any;
+
+            authenticatedUser: any;
+
+            files: any;
+
+            /**
+             * Clear cookie `name`.
+             *
+             * @param name
+             * @param options
+             */
+            clearCookie(name: string, options?: any): Response;
+
+            query: any;
+
+            route: any;
+
+            signedCookies: any;
+
+            originalUrl: string;
+
+            url: string;
+        }
+
+        interface MediaType {
+            value: string;
+            quality: number;
+            type: string;
+            subtype:  string;
+        }
+
+        interface Send {
+            (status: number, body?: any): Response;
+            (body: any): Response;
+        }
+
+        interface Response extends http.ServerResponse {
+            /**
+             * Set status `code`.
+             *
+             * @param code
+             */
+            status(code: number): Response;
+
+            /**
+             * Set Link header field with the given `links`.
+             *
+             * Examples:
+             *
+             *    res.links({
+             *      next: 'http://api.example.com/users?page=2',
+             *      last: 'http://api.example.com/users?page=5'
+             *    });
+             *
+             * @param links
+             */
+            links(links: any): Response;
+
+            /**
+             * Send a response.
+             *
+             * Examples:
+             *
+             *     res.send(new Buffer('wahoo'));
+             *     res.send({ some: 'json' });
+             *     res.send('<p>some html</p>');
+             *     res.send(404, 'Sorry, cant find that');
+             *     res.send(404);
+             */
+            send: Send;
+
+            /**
+             * Send JSON response.
+             *
+             * Examples:
+             *
+             *     res.json(null);
+             *     res.json({ user: 'tj' });
+             *     res.json(500, 'oh noes!');
+             *     res.json(404, 'I dont have that');
+             */
+            json: Send;
+
+            /**
+             * Send JSON response with JSONP callback support.
+             *
+             * Examples:
+             *
+             *     res.jsonp(null);
+             *     res.jsonp({ user: 'tj' });
+             *     res.jsonp(500, 'oh noes!');
+             *     res.jsonp(404, 'I dont have that');
+             */
+            jsonp: Send;
+
+            /**
+             * Transfer the file at the given `path`.
+             *
+             * Automatically sets the _Content-Type_ response header field.
+             * The callback `fn(err)` is invoked when the transfer is complete
+             * or when an error occurs. Be sure to check `res.sentHeader`
+             * if you wish to attempt responding, as the header and some data
+             * may have already been transferred.
+             *
+             * Options:
+             *
+             *   - `maxAge` defaulting to 0
+             *   - `root`   root directory for relative filenames
+             *
+             * Examples:
+             *
+             *  The following example illustrates how `res.sendfile()` may
+             *  be used as an alternative for the `static()` middleware for
+             *  dynamic situations. The code backing `res.sendfile()` is actually
+             *  the same code, so HTTP cache support etc is identical.
+             *
+             *     app.get('/user/:uid/photos/:file', function(req, res){
+             *       var uid = req.params.uid
+             *         , file = req.params.file;
+             *
+             *       req.user.mayViewFilesFrom(uid, function(yes){
+             *         if (yes) {
+             *           res.sendfile('/uploads/' + uid + '/' + file);
+             *         } else {
+             *           res.send(403, 'Sorry! you cant see that.');
+             *         }
+             *       });
+             *     });
+             */
+            sendfile(path: string): void;
+
+            sendfile(path: string, options: any): void;
+
+            sendfile(path: string, fn: Errback): void;
+
+            sendfile(path: string, options: any, fn: Errback): void;
+
+            /**
+             * Transfer the file at the given `path` as an attachment.
+             *
+             * Optionally providing an alternate attachment `filename`,
+             * and optional callback `fn(err)`. The callback is invoked
+             * when the data transfer is complete, or when an error has
+             * ocurred. Be sure to check `res.headerSent` if you plan to respond.
+             *
+             * This method uses `res.sendfile()`.
+             */
+            download(path: string): void;
+
+            download(path: string, filename: string): void;
+
+            download(path: string, fn: Errback): void;
+
+            download(path: string, filename: string, fn: Errback): void;
+
+            /**
+             * Set _Content-Type_ response header with `type` through `mime.lookup()`
+             * when it does not contain "/", or set the Content-Type to `type` otherwise.
+             *
+             * Examples:
+             *
+             *     res.type('.html');
+             *     res.type('html');
+             *     res.type('json');
+             *     res.type('application/json');
+             *     res.type('png');
+             *
+             * @param type
+             */
+            contentType(type: string): Response;
+
+            /**
+             * Set _Content-Type_ response header with `type` through `mime.lookup()`
+             * when it does not contain "/", or set the Content-Type to `type` otherwise.
+             *
+             * Examples:
+             *
+             *     res.type('.html');
+             *     res.type('html');
+             *     res.type('json');
+             *     res.type('application/json');
+             *     res.type('png');
+             *
+             * @param type
+             */
+            type(type: string): Response;
+
+            /**
+             * Respond to the Acceptable formats using an `obj`
+             * of mime-type callbacks.
+             *
+             * This method uses `req.accepted`, an array of
+             * acceptable types ordered by their quality values.
+             * When "Accept" is not present the _first_ callback
+             * is invoked, otherwise the first match is used. When
+             * no match is performed the server responds with
+             * 406 "Not Acceptable".
+             *
+             * Content-Type is set for you, however if you choose
+             * you may alter this within the callback using `res.type()`
+             * or `res.set('Content-Type', ...)`.
+             *
+             *    res.format({
+             *      'text/plain': function(){
+             *        res.send('hey');
+             *      },
+             *
+             *      'text/html': function(){
+             *        res.send('<p>hey</p>');
+             *      },
+             *
+             *      'appliation/json': function(){
+             *        res.send({ message: 'hey' });
+             *      }
+             *    });
+             *
+             * In addition to canonicalized MIME types you may
+             * also use extnames mapped to these types:
+             *
+             *    res.format({
+             *      text: function(){
+             *        res.send('hey');
+             *      },
+             *
+             *      html: function(){
+             *        res.send('<p>hey</p>');
+             *      },
+             *
+             *      json: function(){
+             *        res.send({ message: 'hey' });
+             *      }
+             *    });
+             *
+             * By default Express passes an `Error`
+             * with a `.status` of 406 to `next(err)`
+             * if a match is not made. If you provide
+             * a `.default` callback it will be invoked
+             * instead.
+             *
+             * @param obj
+             */
+            format(obj: any): Response;
+
+            /**
+             * Set _Content-Disposition_ header to _attachment_ with optional `filename`.
+             *
+             * @param filename
+             */
+            attachment(filename?: string): Response;
+
+            /**
+             * Set header `field` to `val`, or pass
+             * an object of header fields.
+             *
+             * Examples:
+             *
+             *    res.set('Foo', ['bar', 'baz']);
+             *    res.set('Accept', 'application/json');
+             *    res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
+             *
+             * Aliased as `res.header()`.
+             */
+            set (field: any): Response;
+
+            set (field: string, value?: string): Response;
+
+            header(field: any): Response;
+
+            header(field: string, value?: string): Response;
+
+            /**
+             * Get value for header `field`.
+             *
+             * @param field
+             */
+            get (field: string): string;
+
+            /**
+             * Clear cookie `name`.
+             *
+             * @param name
+             * @param options
+             */
+            clearCookie(name: string, options?: any): Response;
+
+            /**
+             * Set cookie `name` to `val`, with the given `options`.
+             *
+             * Options:
+             *
+             *    - `maxAge`   max-age in milliseconds, converted to `expires`
+             *    - `signed`   sign the cookie
+             *    - `path`     defaults to "/"
+             *
+             * Examples:
+             *
+             *    // "Remember Me" for 15 minutes
+             *    res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });
+             *
+             *    // save as above
+             *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
+             */
+            cookie(name: string, val: string, options: CookieOptions): Response;
+
+            cookie(name: string, val: any, options: CookieOptions): Response;
+
+            cookie(name: string, val: any): Response;
+
+            /**
+             * Set the location header to `url`.
+             *
+             * The given `url` can also be the name of a mapped url, for
+             * example by default express supports "back" which redirects
+             * to the _Referrer_ or _Referer_ headers or "/".
+             *
+             * Examples:
+             *
+             *    res.location('/foo/bar').;
+             *    res.location('http://example.com');
+             *    res.location('../login'); // /blog/post/1 -> /blog/login
+             *
+             * Mounting:
+             *
+             *   When an application is mounted and `res.location()`
+             *   is given a path that does _not_ lead with "/" it becomes
+             *   relative to the mount-point. For example if the application
+             *   is mounted at "/blog", the following would become "/blog/login".
+             *
+             *      res.location('login');
+             *
+             *   While the leading slash would result in a location of "/login":
+             *
+             *      res.location('/login');
+             *
+             * @param url
+             */
+            location(url: string): Response;
+
+            /**
+             * Redirect to the given `url` with optional response `status`
+             * defaulting to 302.
+             *
+             * The resulting `url` is determined by `res.location()`, so
+             * it will play nicely with mounted apps, relative paths,
+             * `"back"` etc.
+             *
+             * Examples:
+             *
+             *    res.redirect('/foo/bar');
+             *    res.redirect('http://example.com');
+             *    res.redirect(301, 'http://example.com');
+             *    res.redirect('http://example.com', 301);
+             *    res.redirect('../login'); // /blog/post/1 -> /blog/login
+             */
+            redirect(url: string): void;
+
+            redirect(status: number, url: string): void;
+
+            redirect(url: string, status: number): void;
+
+            /**
+             * Render `view` with the given `options` and optional callback `fn`.
+             * When a callback function is given a response will _not_ be made
+             * automatically, otherwise a response of _200_ and _text/html_ is given.
+             *
+             * Options:
+             *
+             *  - `cache`     boolean hinting to the engine it should cache
+             *  - `filename`  filename of the view being rendered
+             */
+
+            render(view: string, options?: Object, callback?: (err: Error, html: string) => void ): void;
             
-        render(view: string, callback?: (err: Error, html: string) => void ): void;
+            render(view: string, callback?: (err: Error, html: string) => void ): void;
 
-        locals: any;
+            locals: any;
 
-        charset: string;
-    }
+            charset: string;
+        }
 
-    export interface RequestFunction {
-        (req: Request, res: Response, next: Function): any;
-    }
+        interface RequestFunction {
+            (req: Request, res: Response, next: Function): any;
+        }
 
-    export interface Application extends IRouter<Application> {
-        /**
-            * Initialize the server.
-            *
-            *   - setup default configuration
-            *   - setup default middleware
-            *   - setup route reflection methods
-            */
-        init(): void;
+        interface Application extends IRouter<Application> {
+            /**
+             * Initialize the server.
+             *
+             *   - setup default configuration
+             *   - setup default middleware
+             *   - setup route reflection methods
+             */
+            init(): void;
 
-        /**
-            * Initialize application configuration.
-            */
-        defaultConfiguration(): void;
+            /**
+             * Initialize application configuration.
+             */
+            defaultConfiguration(): void;
 
-        /**
-            * Proxy `connect#use()` to apply settings to
-            * mounted applications.
-        **/
-        use(route: string, callback?: Function): Application;
+            /**
+             * Proxy `connect#use()` to apply settings to
+             * mounted applications.
+            **/
+            use(route: string, callback?: Function): Application;
 
-        use(route: string, server: Application): Application;
+            use(route: string, server: Application): Application;
 
-        use(callback: Function): Application;
+            use(callback: Function): Application;
 
-        use(server: Application): Application;
+            use(server: Application): Application;
 
-        /**
-            * Register the given template engine callback `fn`
-            * as `ext`.
-            *
-            * By default will `require()` the engine based on the
-            * file extension. For example if you try to render
-            * a "foo.jade" file Express will invoke the following internally:
-            *
-            *     app.engine('jade', require('jade').__express);
-            *
-            * For engines that do not provide `.__express` out of the box,
-            * or if you wish to "map" a different extension to the template engine
-            * you may use this method. For example mapping the EJS template engine to
-            * ".html" files:
-            *
-            *     app.engine('html', require('ejs').renderFile);
-            *
-            * In this case EJS provides a `.renderFile()` method with
-            * the same signature that Express expects: `(path, options, callback)`,
-            * though note that it aliases this method as `ejs.__express` internally
-            * so if you're using ".ejs" extensions you dont need to do anything.
-            *
-            * Some template engines do not follow this convention, the
-            * [Consolidate.js](https://github.com/visionmedia/consolidate.js)
-            * library was created to map all of node's popular template
-            * engines to follow this convention, thus allowing them to
-            * work seamlessly within Express.
-            */
-        engine(ext: string, fn: Function): Application;
+            /**
+             * Register the given template engine callback `fn`
+             * as `ext`.
+             *
+             * By default will `require()` the engine based on the
+             * file extension. For example if you try to render
+             * a "foo.jade" file Express will invoke the following internally:
+             *
+             *     app.engine('jade', require('jade').__express);
+             *
+             * For engines that do not provide `.__express` out of the box,
+             * or if you wish to "map" a different extension to the template engine
+             * you may use this method. For example mapping the EJS template engine to
+             * ".html" files:
+             *
+             *     app.engine('html', require('ejs').renderFile);
+             *
+             * In this case EJS provides a `.renderFile()` method with
+             * the same signature that Express expects: `(path, options, callback)`,
+             * though note that it aliases this method as `ejs.__express` internally
+             * so if you're using ".ejs" extensions you dont need to do anything.
+             *
+             * Some template engines do not follow this convention, the
+             * [Consolidate.js](https://github.com/visionmedia/consolidate.js)
+             * library was created to map all of node's popular template
+             * engines to follow this convention, thus allowing them to
+             * work seamlessly within Express.
+             */
+            engine(ext: string, fn: Function): Application;
 
-        param(name: string, fn: Function): Application;
+            param(name: string, fn: Function): Application;
 
-        param(name: string[], fn: Function): Application;
+            param(name: string[], fn: Function): Application;
 
-        /**
-            * Assign `setting` to `val`, or return `setting`'s value.
-            *
-            *    app.set('foo', 'bar');
-            *    app.get('foo');
-            *    // => "bar"
-            *
-            * Mounted servers inherit their parent server's settings.
-            *
-            * @param setting
-            * @param val
-            */
-        set (setting: string, val: string): Application;
+            /**
+             * Assign `setting` to `val`, or return `setting`'s value.
+             *
+             *    app.set('foo', 'bar');
+             *    app.get('foo');
+             *    // => "bar"
+             *
+             * Mounted servers inherit their parent server's settings.
+             *
+             * @param setting
+             * @param val
+             */
+            set (setting: string, val: string): Application;
 
-        get(name: string): string;
+            /**
+             * Return the app's absolute pathname
+             * based on the parent(s) that have
+             * mounted it.
+             *
+             * For example if the application was
+             * mounted as "/admin", which itself
+             * was mounted as "/blog" then the
+             * return value would be "/blog/admin".
+             */
+            path(): string;
 
-        get(name: string, ...handlers: RequestFunction[]): Application;
+            /**
+             * Check if `setting` is enabled (truthy).
+             *
+             *    app.enabled('foo')
+             *    // => false
+             *
+             *    app.enable('foo')
+             *    app.enabled('foo')
+             *    // => true
+             */
+            enabled(setting: string): boolean;
 
-        get(name: RegExp, ...handlers: RequestFunction[]): Application;
+            /**
+             * Check if `setting` is disabled.
+             *
+             *    app.disabled('foo')
+             *    // => true
+             *
+             *    app.enable('foo')
+             *    app.disabled('foo')
+             *    // => false
+             *
+             * @param setting
+             */
+            disabled(setting: string): boolean;
 
-        /**
-            * Return the app's absolute pathname
-            * based on the parent(s) that have
-            * mounted it.
-            *
-            * For example if the application was
-            * mounted as "/admin", which itself
-            * was mounted as "/blog" then the
-            * return value would be "/blog/admin".
-            */
-        path(): string;
+            /**
+             * Enable `setting`.
+             *
+             * @param setting
+             */
+            enable(setting: string): Application;
 
-        /**
-            * Check if `setting` is enabled (truthy).
-            *
-            *    app.enabled('foo')
-            *    // => false
-            *
-            *    app.enable('foo')
-            *    app.enabled('foo')
-            *    // => true
-            */
-        enabled(setting: string): boolean;
+            /**
+             * Disable `setting`.
+             *
+             * @param setting
+             */
+            disable(setting: string): Application;
 
-        /**
-            * Check if `setting` is disabled.
-            *
-            *    app.disabled('foo')
-            *    // => true
-            *
-            *    app.enable('foo')
-            *    app.disabled('foo')
-            *    // => false
-            *
-            * @param setting
-            */
-        disabled(setting: string): boolean;
+            /**
+             * Configure callback for zero or more envs,
+             * when no `env` is specified that callback will
+             * be invoked for all environments. Any combination
+             * can be used multiple times, in any order desired.
+             *
+             * Examples:
+             *
+             *    app.configure(function(){
+             *      // executed for all envs
+             *    });
+             *
+             *    app.configure('stage', function(){
+             *      // executed staging env
+             *    });
+             *
+             *    app.configure('stage', 'production', function(){
+             *      // executed for stage and production
+             *    });
+             *
+             * Note:
+             *
+             *  These callbacks are invoked immediately, and
+             *  are effectively sugar for the following:
+             *
+             *     var env = process.env.NODE_ENV || 'development';
+             *
+             *      switch (env) {
+             *        case 'development':
+             *          ...
+             *          break;
+             *        case 'stage':
+             *          ...
+             *          break;
+             *        case 'production':
+             *          ...
+             *          break;
+             *      }
+             *
+             * @param env
+             * @param fn
+             */
+            configure(env: string, fn: Function): Application;
 
-        /**
-            * Enable `setting`.
-            *
-            * @param setting
-            */
-        enable(setting: string): Application;
+            configure(env0: string, env1: string, fn: Function): Application;
 
-        /**
-            * Disable `setting`.
-            *
-            * @param setting
-            */
-        disable(setting: string): Application;
+            configure(env0: string, env1: string, env2: string, fn: Function): Application;
 
-        /**
-            * Configure callback for zero or more envs,
-            * when no `env` is specified that callback will
-            * be invoked for all environments. Any combination
-            * can be used multiple times, in any order desired.
-            *
-            * Examples:
-            *
-            *    app.configure(function(){
-            *      // executed for all envs
-            *    });
-            *
-            *    app.configure('stage', function(){
-            *      // executed staging env
-            *    });
-            *
-            *    app.configure('stage', 'production', function(){
-            *      // executed for stage and production
-            *    });
-            *
-            * Note:
-            *
-            *  These callbacks are invoked immediately, and
-            *  are effectively sugar for the following:
-            *
-            *     var env = process.env.NODE_ENV || 'development';
-            *
-            *      switch (env) {
-            *        case 'development':
-            *          ...
-            *          break;
-            *        case 'stage':
-            *          ...
-            *          break;
-            *        case 'production':
-            *          ...
-            *          break;
-            *      }
-            *
-            * @param env
-            * @param fn
-            */
-        configure(env: string, fn: Function): Application;
+            configure(env0: string, env1: string, env2: string, env3: string, fn: Function): Application;
 
-        configure(env0: string, env1: string, fn: Function): Application;
+            configure(env0: string, env1: string, env2: string, env3: string, env4: string, fn: Function): Application;
 
-        configure(env0: string, env1: string, env2: string, fn: Function): Application;
-
-        configure(env0: string, env1: string, env2: string, env3: string, fn: Function): Application;
-
-        configure(env0: string, env1: string, env2: string, env3: string, env4: string, fn: Function): Application;
-
-        configure(fn: Function): Application;
+            configure(fn: Function): Application;
 
 
-        /**
-            * Render the given view `name` name with `options`
-            * and a callback accepting an error and the
-            * rendered template string.
-            *
-            * Example:
-            *
-            *    app.render('email', { name: 'Tobi' }, function(err, html){
-            *      // ...
-            *    })
-            *
-            * @param name
-            * @param options or fn
-            * @param fn
-            */
-        render(name: string, options?: Object, callback?: (err: Error, html: string) => void): void;
+            /**
+             * Render the given view `name` name with `options`
+             * and a callback accepting an error and the
+             * rendered template string.
+             *
+             * Example:
+             *
+             *    app.render('email', { name: 'Tobi' }, function(err, html){
+             *      // ...
+             *    })
+             *
+             * @param name
+             * @param options or fn
+             * @param fn
+             */
+            render(name: string, options?: Object, callback?: (err: Error, html: string) => void): void;
             
-        render(name: string, callback: (err: Error, html: string) => void): void;
+            render(name: string, callback: (err: Error, html: string) => void): void;
 
 
+            /**
+             * Listen for connections.
+             *
+             * A node `http.Server` is returned, with this
+             * application (which is a `Function`) as its
+             * callback. If you wish to create both an HTTP
+             * and HTTPS server you may do so with the "http"
+             * and "https" modules as shown here:
+             *
+             *    var http = require('http')
+             *      , https = require('https')
+             *      , express = require('express')
+             *      , app = express();
+             *
+             *    http.createServer(app).listen(80);
+             *    https.createServer({ ... }, app).listen(443);
+             */
+            listen(port: number, hostname: string, backlog: number, callback?: Function): void;
+
+            listen(port: number, hostname: string, callback?: Function): void;
+
+            listen(port: number, callback?: Function): void;
+
+            listen(path: string, callback?: Function): void;
+
+            listen(handle: any, listeningListener?: Function): void;
+
+            route: IRoute;
+
+            router: string;
+
+            settings: any;
+
+            resource: any;
+
+            map: any;
+
+            locals: any;
+
+            /**
+             * The app.routes object houses all of the routes defined mapped by the
+             * associated HTTP verb. This object may be used for introspection
+             * capabilities, for example Express uses this internally not only for
+             * routing but to provide default OPTIONS behaviour unless app.options()
+             * is used. Your application or framework may also remove routes by
+             * simply by removing them from this object.
+             */
+            routes: any;
+        }
+
+        interface Express extends Application {
+            /**
+             * Framework version.
+             */
+            version: string;
+
+            /**
+             * Expose mime.
+             */
+            mime: string;
+
+            (): Application;
+
+            /**
+            * Create an express application.
+            */
+            createApplication(): Application;
+
+            createServer(): Application;
+
+            application: any;
+
+            request: Request;
+
+            response: Response;
+        }
+
         /**
-            * Listen for connections.
-            *
-            * A node `http.Server` is returned, with this
-            * application (which is a `Function`) as its
-            * callback. If you wish to create both an HTTP
-            * and HTTPS server you may do so with the "http"
-            * and "https" modules as shown here:
-            *
-            *    var http = require('http')
-            *      , https = require('https')
-            *      , express = require('express')
-            *      , app = express();
-            *
-            *    http.createServer(app).listen(80);
-            *    https.createServer({ ... }, app).listen(443);
-            */
-        listen(port: number, hostname: string, backlog: number, callback?: Function): void;
-
-        listen(port: number, hostname: string, callback?: Function): void;
-
-        listen(port: number, callback?: Function): void;
-
-        listen(path: string, callback?: Function): void;
-
-        listen(handle: any, listeningListener?: Function): void;
-
-        route: Route;
-
-        router: string;
-
-        settings: any;
-
-        resource: any;
-
-        map: any;
-
-        locals: any;
+         * Body parser:
+         * 
+         *   Parse request bodies, supports _application/json_,
+         *   _application/x-www-form-urlencoded_, and _multipart/form-data_.
+         *
+         *   This is equivalent to: 
+         *
+         *     app.use(connect.json());
+         *     app.use(connect.urlencoded());
+         *     app.use(connect.multipart());
+         *
+         * Examples:
+         *
+         *      connect()
+         *        .use(connect.bodyParser())
+         *        .use(function(req, res) {
+         *          res.end('viewing user ' + req.body.user.name);
+         *        });
+         *
+         *      $ curl -d 'user[name]=tj' http://local/
+         *      $ curl -d '{"user":{"name":"tj"}}' -H "Content-Type: application/json" http://local/
+         *
+         *  View [json](json.html), [urlencoded](urlencoded.html), and [multipart](multipart.html) for more info.
+         *
+         * @param options
+         */
+        function bodyParser(options?: any): Handler;
 
         /**
-            * The app.routes object houses all of the routes defined mapped by the
-            * associated HTTP verb. This object may be used for introspection
-            * capabilities, for example Express uses this internally not only for
-            * routing but to provide default OPTIONS behaviour unless app.options()
-            * is used. Your application or framework may also remove routes by
-            * simply by removing them from this object.
-            */
-        routes: any;
+         * Error handler:
+         *
+         * Development error handler, providing stack traces
+         * and error message responses for requests accepting text, html,
+         * or json.
+         *
+         * Text:
+         *
+         *   By default, and when _text/plain_ is accepted a simple stack trace
+         *   or error message will be returned.
+         *
+         * JSON:
+         *
+         *   When _application/json_ is accepted, connect will respond with
+         *   an object in the form of `{ "error": error }`.
+         *
+         * HTML:
+         *
+         *   When accepted connect will output a nice html stack trace.
+         */
+        function errorHandler(opts?: any): Handler;
+
+        /**
+         * Method Override:
+         * 
+         * Provides faux HTTP method support.
+         * 
+         * Pass an optional `key` to use when checking for
+         * a method override, othewise defaults to _\_method_.
+         * The original method is available via `req.originalMethod`.
+         *
+         * @param key
+         */
+        function methodOverride(key?: string): Handler;
+
+        /**
+         * Cookie parser:
+         *
+         * Parse _Cookie_ header and populate `req.cookies`
+         * with an object keyed by the cookie names. Optionally
+         * you may enabled signed cookie support by passing
+         * a `secret` string, which assigns `req.secret` so
+         * it may be used by other middleware.
+         *
+         * Examples:
+         *
+         *     connect()
+         *       .use(connect.cookieParser('optional secret string'))
+         *       .use(function(req, res, next){
+         *         res.end(JSON.stringify(req.cookies));
+         *       })
+         *
+         * @param secret
+         */
+        function cookieParser(secret?: string): Handler;
+
+        /**
+         * Session:
+         * 
+         *   Setup session store with the given `options`.
+         *
+         *   Session data is _not_ saved in the cookie itself, however
+         *   cookies are used, so we must use the [cookieParser()](cookieParser.html)
+         *   middleware _before_ `session()`.
+         *
+         * Examples:
+         *
+         *     connect()
+         *       .use(connect.cookieParser())
+         *       .use(connect.session({ secret: 'keyboard cat', key: 'sid', cookie: { secure: true }}))
+         *
+         * Options:
+         *
+         *   - `key` cookie name defaulting to `connect.sid`
+         *   - `store` session store instance
+         *   - `secret` session cookie is signed with this secret to prevent tampering
+         *   - `cookie` session cookie settings, defaulting to `{ path: '/', httpOnly: true, maxAge: null }`
+         *   - `proxy` trust the reverse proxy when setting secure cookies (via "x-forwarded-proto")
+         *
+         * Cookie option:
+         *
+         *  By default `cookie.maxAge` is `null`, meaning no "expires" parameter is set
+         *  so the cookie becomes a browser-session cookie. When the user closes the 
+         *  browser the cookie (and session) will be removed.
+         *
+         * ## req.session
+         *
+         *  To store or access session data, simply use the request property `req.session`,
+         *  which is (generally) serialized as JSON by the store, so nested objects 
+         *  are typically fine. For example below is a user-specific view counter:
+         *
+         *       connect()
+         *         .use(connect.favicon())
+         *         .use(connect.cookieParser())
+         *         .use(connect.session({ secret: 'keyboard cat', cookie: { maxAge: 60000 }}))
+         *         .use(function(req, res, next){
+         *           var sess = req.session;
+         *           if (sess.views) {
+         *             res.setHeader('Content-Type', 'text/html');
+         *             res.write('<p>views: ' + sess.views + '</p>');
+         *             res.write('<p>expires in: ' + (sess.cookie.maxAge / 1000) + 's</p>');
+         *             res.end();
+         *             sess.views++;
+         *           } else {
+         *             sess.views = 1;
+         *             res.end('welcome to the session demo. refresh!');
+         *           }
+         *         }
+         *       )).listen(3000);
+         *
+         * ## Session#regenerate()
+         *
+         *  To regenerate the session simply invoke the method, once complete
+         *  a new SID and `Session` instance will be initialized at `req.session`.
+         *
+         *      req.session.regenerate(function(err){
+         *        // will have a new session here
+         *      });
+         *
+         * ## Session#destroy()
+         *
+         *  Destroys the session, removing `req.session`, will be re-generated next request.
+         *
+         *      req.session.destroy(function(err){
+         *        // cannot access session here
+         *      });
+         * 
+         * ## Session#reload()
+         *
+         *  Reloads the session data.
+         *
+         *      req.session.reload(function(err){
+         *        // session updated
+         *      });
+         *
+         * ## Session#save()
+         *
+         *  Save the session.
+         *
+         *      req.session.save(function(err){
+         *        // session saved
+         *      });
+         *
+         * ## Session#touch()
+         *
+         *   Updates the `.maxAge` property. Typically this is
+         *   not necessary to call, as the session middleware does this for you.
+         *
+         * ## Session#cookie
+         *
+         *  Each session has a unique cookie object accompany it. This allows
+         *  you to alter the session cookie per visitor. For example we can
+         *  set `req.session.cookie.expires` to `false` to enable the cookie
+         *  to remain for only the duration of the user-agent.
+         *
+         * ## Session#maxAge
+         *
+         *  Alternatively `req.session.cookie.maxAge` will return the time
+         *  remaining in milliseconds, which we may also re-assign a new value
+         *  to adjust the `.expires` property appropriately. The following
+         *  are essentially equivalent
+         *
+         *     var hour = 3600000;
+         *     req.session.cookie.expires = new Date(Date.now() + hour);
+         *     req.session.cookie.maxAge = hour;
+         *
+         * For example when `maxAge` is set to `60000` (one minute), and 30 seconds
+         * has elapsed it will return `30000` until the current request has completed,
+         * at which time `req.session.touch()` is called to reset `req.session.maxAge`
+         * to its original value.
+         *
+         *     req.session.cookie.maxAge;
+         *     // => 30000
+         *
+         * Session Store Implementation:
+         *
+         * Every session store _must_ implement the following methods
+         *
+         *    - `.get(sid, callback)`
+         *    - `.set(sid, session, callback)`
+         *    - `.destroy(sid, callback)`
+         *
+         * Recommended methods include, but are not limited to:
+         *
+         *    - `.length(callback)`
+         *    - `.clear(callback)`
+         *
+         * For an example implementation view the [connect-redis](http://github.com/visionmedia/connect-redis) repo.
+         *
+         * @param options
+         */
+        function session(options?: any): Handler;
+
+        /**
+         * Hash the given `sess` object omitting changes
+         * to `.cookie`.
+         *
+         * @param sess
+         */
+        function hash(sess: string): string;
+
+        /**
+         * Static:
+         *
+         *   Static file server with the given `root` path.
+         *
+         * Examples:
+         *
+         *     var oneDay = 86400000;
+         *
+         *     connect()
+         *       .use(connect.static(__dirname + '/public'))
+         *
+         *     connect()
+         *       .use(connect.static(__dirname + '/public', { maxAge: oneDay }))
+         *
+         * Options:
+         *
+         *    - `maxAge`     Browser cache maxAge in milliseconds. defaults to 0
+         *    - `hidden`     Allow transfer of hidden files. defaults to false
+         *    - `redirect`   Redirect to trailing "/" when the pathname is a dir. defaults to true
+         *
+         * @param root
+         * @param options
+         */
+        function static(root: string, options?: any): Handler;
+
+        /**
+         * Basic Auth:
+         *
+         * Enfore basic authentication by providing a `callback(user, pass)`,
+         * which must return `true` in order to gain access. Alternatively an async
+         * method is provided as well, invoking `callback(user, pass, callback)`. Populates
+         * `req.user`. The final alternative is simply passing username / password
+         * strings.
+         *
+         *  Simple username and password
+         *
+         *     connect(connect.basicAuth('username', 'password'));
+         *
+         *  Callback verification
+         *
+         *     connect()
+         *       .use(connect.basicAuth(function(user, pass){
+         *         return 'tj' == user & 'wahoo' == pass;
+         *       }))
+         *
+         *  Async callback verification, accepting `fn(err, user)`.
+         *
+         *     connect()
+         *       .use(connect.basicAuth(function(user, pass, fn){
+         *         User.authenticate({ user: user, pass: pass }, fn);
+         *       }))
+         *
+         * @param callback or username
+         * @param realm
+         */
+        export function basicAuth(callback: (user: string, pass: string, fn : Function) => void, realm?: string): Handler;
+
+        export function basicAuth(callback: (user: string, pass: string) => boolean, realm?: string): Handler;
+
+        export function basicAuth(user: string, pass: string, realm?: string): Handler;
+
+        /**
+         * Compress:
+         *
+         * Compress response data with gzip/deflate.
+         *
+         * Filter:
+         *
+         *  A `filter` callback function may be passed to
+         *  replace the default logic of:
+         *
+         *     exports.filter = function(req, res){
+         *       return /json|text|javascript/.test(res.getHeader('Content-Type'));
+         *     };
+         *
+         * Options:
+         *
+         *  All remaining options are passed to the gzip/deflate
+         *  creation functions. Consult node's docs for additional details.
+         *
+         *   - `chunkSize` (default: 16*1024)
+         *   - `windowBits`
+         *   - `level`: 0-9 where 0 is no compression, and 9 is slow but best compression
+         *   - `memLevel`: 1-9 low is slower but uses less memory, high is fast but uses more
+         *   - `strategy`: compression strategy
+         *
+         * @param options
+         */
+        function compress(options?: any): Handler;
+
+        /**
+         * Cookie Session:
+         *
+         *   Cookie session middleware.
+         *
+         *      var app = connect();
+         *      app.use(connect.cookieParser());
+         *      app.use(connect.cookieSession({ secret: 'tobo!', cookie: { maxAge: 60 * 60 * 1000 }}));
+         *
+         * Options:
+         *
+         *   - `key` cookie name defaulting to `connect.sess`
+         *   - `secret` prevents cookie tampering
+         *   - `cookie` session cookie settings, defaulting to `{ path: '/', httpOnly: true, maxAge: null }`
+         *   - `proxy` trust the reverse proxy when setting secure cookies (via "x-forwarded-proto")
+         *
+         * Clearing sessions:
+         *
+         *  To clear the session simply set its value to `null`,
+         *  `cookieSession()` will then respond with a 1970 Set-Cookie.
+         *
+         *     req.session = null;
+         *
+         * @param options
+         */
+        function cookieSession(options?: any): Handler;
+
+        /**
+         * Anti CSRF:
+         *
+         * CSRF protection middleware.
+         *
+         * This middleware adds a `req.csrfToken()` function to make a token
+         * which should be added to requests which mutate
+         * state, within a hidden form field, query-string etc. This
+         * token is validated against the visitor's session.
+         *
+         * The default `value` function checks `req.body` generated
+         * by the `bodyParser()` middleware, `req.query` generated
+         * by `query()`, and the "X-CSRF-Token" header field.
+         *
+         * This middleware requires session support, thus should be added
+         * somewhere _below_ `session()` and `cookieParser()`.
+         *
+         * Options:
+         *
+         *    - `value` a function accepting the request, returning the token
+         *
+         * @param options
+         */
+        export function csrf(options?: {value?: Function}): Handler;
+
+        /**
+         * Directory:
+         *
+         * Serve directory listings with the given `root` path.
+         *
+         * Options:
+         *
+         *  - `hidden` display hidden (dot) files. Defaults to false.
+         *  - `icons`  display icons. Defaults to false.
+         *  - `filter` Apply this filter function to files. Defaults to false.
+         *
+         * @param root
+         * @param options
+         */
+        function directory(root: string, options?: any): Handler;
+
+        /**
+         * Favicon:
+         *
+         * By default serves the connect favicon, or the favicon
+         * located by the given `path`.
+         *
+         * Options:
+         *
+         *   - `maxAge`  cache-control max-age directive, defaulting to 1 day
+         *
+         * Examples:
+         *
+         *   Serve default favicon:
+         *
+         *     connect()
+         *       .use(connect.favicon())
+         *
+         *   Serve favicon before logging for brevity:
+         *
+         *     connect()
+         *       .use(connect.favicon())
+         *       .use(connect.logger('dev'))
+         *
+         *   Serve custom favicon:
+         *
+         *     connect()
+         *       .use(connect.favicon('public/favicon.ico))
+         *
+         * @param path
+         * @param options
+         */
+        export function favicon(path?: string, options?: any): Handler;
+
+        /**
+         * JSON:
+         *
+         * Parse JSON request bodies, providing the
+         * parsed object as `req.body`.
+         *
+         * Options:
+         *
+         *   - `strict`  when `false` anything `JSON.parse()` accepts will be parsed
+         *   - `reviver`  used as the second "reviver" argument for JSON.parse
+         *   - `limit`  byte limit disabled by default
+         *
+         * @param options
+         */
+        function json(options?: any): Handler;
+
+        /**
+         * Limit:
+         *
+         *   Limit request bodies to the given size in `bytes`.
+         *
+         *   A string representation of the bytesize may also be passed,
+         *   for example "5mb", "200kb", "1gb", etc.
+         *
+         *     connect()
+         *       .use(connect.limit('5.5mb'))
+         *       .use(handleImageUpload)
+         */
+        function limit(bytes: number): Handler;
+
+        function limit(bytes: string): Handler;
+
+        /**
+         * Logger:
+         *
+         * Log requests with the given `options` or a `format` string.
+         *
+         * Options:
+         *
+         *   - `format`  Format string, see below for tokens
+         *   - `stream`  Output stream, defaults to _stdout_
+         *   - `buffer`  Buffer duration, defaults to 1000ms when _true_
+         *   - `immediate`  Write log line on request instead of response (for response times)
+         *
+         * Tokens:
+         *
+         *   - `:req[header]` ex: `:req[Accept]`
+         *   - `:res[header]` ex: `:res[Content-Length]`
+         *   - `:http-version`
+         *   - `:response-time`
+         *   - `:remote-addr`
+         *   - `:date`
+         *   - `:method`
+         *   - `:url`
+         *   - `:referrer`
+         *   - `:user-agent`
+         *   - `:status`
+         *
+         * Formats:
+         *
+         *   Pre-defined formats that ship with connect:
+         *
+         *    - `default` ':remote-addr - - [:date] ":method :url HTTP/:http-version" :status :res[content-length] ":referrer" ":user-agent"'
+         *    - `short` ':remote-addr - :method :url HTTP/:http-version :status :res[content-length] - :response-time ms'
+         *    - `tiny`  ':method :url :status :res[content-length] - :response-time ms'
+         *    - `dev` concise output colored by response status for development use
+         *
+         * Examples:
+         *
+         *      connect.logger() // default
+         *      connect.logger('short')
+         *      connect.logger('tiny')
+         *      connect.logger({ immediate: true, format: 'dev' })
+         *      connect.logger(':method :url - :referrer')
+         *      connect.logger(':req[content-type] -> :res[content-type]')
+         *      connect.logger(function(tokens, req, res){ return 'some format string' })
+         *
+         * Defining Tokens:
+         *
+         *   To define a token, simply invoke `connect.logger.token()` with the
+         *   name and a callback function. The value returned is then available
+         *   as ":type" in this case.
+         *
+         *      connect.logger.token('type', function(req, res){ return req.headers['content-type']; })
+         *
+         * Defining Formats:
+         *
+         *   All default formats are defined this way, however it's public API as well:
+         *
+         *       connect.logger.format('name', 'string or function')
+         */
+        function logger(options: string): Handler;
+
+        function logger(options: Function): Handler;
+
+        function logger(options?: any): Handler;
+
+        /**
+         * Compile `fmt` into a function.
+         *
+         * @param fmt
+         */
+        function compile(fmt: string): Handler;
+
+        /**
+         * Define a token function with the given `name`,
+         * and callback `fn(req, res)`.
+         *
+         * @param name
+         * @param fn
+         */
+        function token(name: string, fn: Function): any;
+
+        /**
+         * Define a `fmt` with the given `name`.
+         */
+        function format(name: string, str: string): any;
+
+        function format(name: string, str: Function): any;
+
+        /**
+         * Query:
+         *
+         * Automatically parse the query-string when available,
+         * populating the `req.query` object.
+         *
+         * Examples:
+         *
+         *     connect()
+         *       .use(connect.query())
+         *       .use(function(req, res){
+         *         res.end(JSON.stringify(req.query));
+         *       });
+         *
+         *  The `options` passed are provided to qs.parse function.
+         */
+        function query(options: any): Handler;
+
+        /**
+         * Reponse time:
+         *
+         * Adds the `X-Response-Time` header displaying the response
+         * duration in milliseconds.
+         */
+        function responseTime(): Handler;
+
+        /**
+         * Static cache:
+         *
+         * Enables a memory cache layer on top of
+         * the `static()` middleware, serving popular
+         * static files.
+         *
+         * By default a maximum of 128 objects are
+         * held in cache, with a max of 256k each,
+         * totalling ~32mb.
+         *
+         * A Least-Recently-Used (LRU) cache algo
+         * is implemented through the `Cache` object,
+         * simply rotating cache objects as they are
+         * hit. This means that increasingly popular
+         * objects maintain their positions while
+         * others get shoved out of the stack and
+         * garbage collected.
+         *
+         * Benchmarks:
+         *
+         *     static(): 2700 rps
+         *     node-static: 5300 rps
+         *     static() + staticCache(): 7500 rps
+         *
+         * Options:
+         *
+         *   - `maxObjects`  max cache objects [128]
+         *   - `maxLength`  max cache object length 256kb
+         */
+        function staticCache(options: any): Handler;
+
+        /**
+         * Timeout:
+         *
+         * Times out the request in `ms`, defaulting to `5000`. The
+         * method `req.clearTimeout()` is added to revert this behaviour
+         * programmatically within your application's middleware, routes, etc.
+         *
+         * The timeout error is passed to `next()` so that you may customize
+         * the response behaviour. This error has the `.timeout` property as
+         * well as `.status == 408`.
+         */
+        function timeout(ms: number): Handler;
+
+        /**
+         * Vhost:
+         * 
+         *   Setup vhost for the given `hostname` and `server`.
+         *
+         *     connect()
+         *       .use(connect.vhost('foo.com', fooApp))
+         *       .use(connect.vhost('bar.com', barApp))
+         *       .use(connect.vhost('*.com', mainApp))
+         *
+         *  The `server` may be a Connect server or
+         *  a regular Node `http.Server`. 
+         *
+         * @param hostname
+         * @param server
+         */
+        function vhost(hostname: string, server: any): Handler;
+
+        function urlencoded(): any;
+
+        function multipart(): any;
+
     }
 
-    export interface Express extends Application {
-        /**
-            * Framework version.
-            */
-        version: string;
-
-        /**
-            * Expose mime.
-            */
-        mime: string;
-
-        (): Application;
-
-        /**
-        * Create an express application.
-        */
-        createApplication(): Application;
-
-        createServer(): Application;
-
-        application: any;
-
-        request: Request;
-
-        response: Response;
-    }
+    export = e;
 }
-interface Express {
-    (): Express.Express;
 
-    /**
-        * Initialize `Route` with the given HTTP `method`, `path`,
-        * and an array of `callbacks` and `options`.
-        *
-        * Options:
-        *
-        *   - `sensitive`    enable case-sensitive routes
-        *   - `strict`       enable strict matching for trailing slashes
-        *
-        * @param method
-        * @param path
-        * @param callbacks
-        * @param options
-        */
-    Route: new (method: string, path: string, callbacks: Function[], options: any) => Express.Route;
-
-    Router: new (options?: any) => Express.Router;
-
-    /**
-        * Body parser:
-        * 
-        *   Parse request bodies, supports _application/json_,
-        *   _application/x-www-form-urlencoded_, and _multipart/form-data_.
-        *
-        *   This is equivalent to: 
-        *
-        *     app.use(connect.json());
-        *     app.use(connect.urlencoded());
-        *     app.use(connect.multipart());
-        *
-        * Examples:
-        *
-        *      connect()
-        *        .use(connect.bodyParser())
-        *        .use(function(req, res) {
-        *          res.end('viewing user ' + req.body.user.name);
-        *        });
-        *
-        *      $ curl -d 'user[name]=tj' http://local/
-        *      $ curl -d '{"user":{"name":"tj"}}' -H "Content-Type: application/json" http://local/
-        *
-        *  View [json](json.html), [urlencoded](urlencoded.html), and [multipart](multipart.html) for more info.
-        *
-        * @param options
-        */
-    bodyParser(options?: any): Express.Handler;
-
-    /**
-        * Error handler:
-        *
-        * Development error handler, providing stack traces
-        * and error message responses for requests accepting text, html,
-        * or json.
-        *
-        * Text:
-        *
-        *   By default, and when _text/plain_ is accepted a simple stack trace
-        *   or error message will be returned.
-        *
-        * JSON:
-        *
-        *   When _application/json_ is accepted, connect will respond with
-        *   an object in the form of `{ "error": error }`.
-        *
-        * HTML:
-        *
-        *   When accepted connect will output a nice html stack trace.
-        */
-    errorHandler(opts?: any): Express.Handler;
-
-    /**
-        * Method Override:
-        * 
-        * Provides faux HTTP method support.
-        * 
-        * Pass an optional `key` to use when checking for
-        * a method override, othewise defaults to _\_method_.
-        * The original method is available via `req.originalMethod`.
-        *
-        * @param key
-        */
-    methodOverride(key?: string): Express.Handler;
-
-    /**
-        * Cookie parser:
-        *
-        * Parse _Cookie_ header and populate `req.cookies`
-        * with an object keyed by the cookie names. Optionally
-        * you may enabled signed cookie support by passing
-        * a `secret` string, which assigns `req.secret` so
-        * it may be used by other middleware.
-        *
-        * Examples:
-        *
-        *     connect()
-        *       .use(connect.cookieParser('optional secret string'))
-        *       .use(function(req, res, next){
-        *         res.end(JSON.stringify(req.cookies));
-        *       })
-        *
-        * @param secret
-        */
-    cookieParser(secret?: string): Express.Handler;
-
-    /**
-        * Session:
-        * 
-        *   Setup session store with the given `options`.
-        *
-        *   Session data is _not_ saved in the cookie itself, however
-        *   cookies are used, so we must use the [cookieParser()](cookieParser.html)
-        *   middleware _before_ `session()`.
-        *
-        * Examples:
-        *
-        *     connect()
-        *       .use(connect.cookieParser())
-        *       .use(connect.session({ secret: 'keyboard cat', key: 'sid', cookie: { secure: true }}))
-        *
-        * Options:
-        *
-        *   - `key` cookie name defaulting to `connect.sid`
-        *   - `store` session store instance
-        *   - `secret` session cookie is signed with this secret to prevent tampering
-        *   - `cookie` session cookie settings, defaulting to `{ path: '/', httpOnly: true, maxAge: null }`
-        *   - `proxy` trust the reverse proxy when setting secure cookies (via "x-forwarded-proto")
-        *
-        * Cookie option:
-        *
-        *  By default `cookie.maxAge` is `null`, meaning no "expires" parameter is set
-        *  so the cookie becomes a browser-session cookie. When the user closes the 
-        *  browser the cookie (and session) will be removed.
-        *
-        * ## req.session
-        *
-        *  To store or access session data, simply use the request property `req.session`,
-        *  which is (generally) serialized as JSON by the store, so nested objects 
-        *  are typically fine. For example below is a user-specific view counter:
-        *
-        *       connect()
-        *         .use(connect.favicon())
-        *         .use(connect.cookieParser())
-        *         .use(connect.session({ secret: 'keyboard cat', cookie: { maxAge: 60000 }}))
-        *         .use(function(req, res, next){
-        *           var sess = req.session;
-        *           if (sess.views) {
-        *             res.setHeader('Content-Type', 'text/html');
-        *             res.write('<p>views: ' + sess.views + '</p>');
-        *             res.write('<p>expires in: ' + (sess.cookie.maxAge / 1000) + 's</p>');
-        *             res.end();
-        *             sess.views++;
-        *           } else {
-        *             sess.views = 1;
-        *             res.end('welcome to the session demo. refresh!');
-        *           }
-        *         }
-        *       )).listen(3000);
-        *
-        * ## Session#regenerate()
-        *
-        *  To regenerate the session simply invoke the method, once complete
-        *  a new SID and `Session` instance will be initialized at `req.session`.
-        *
-        *      req.session.regenerate(function(err){
-        *        // will have a new session here
-        *      });
-        *
-        * ## Session#destroy()
-        *
-        *  Destroys the session, removing `req.session`, will be re-generated next request.
-        *
-        *      req.session.destroy(function(err){
-        *        // cannot access session here
-        *      });
-        * 
-        * ## Session#reload()
-        *
-        *  Reloads the session data.
-        *
-        *      req.session.reload(function(err){
-        *        // session updated
-        *      });
-        *
-        * ## Session#save()
-        *
-        *  Save the session.
-        *
-        *      req.session.save(function(err){
-        *        // session saved
-        *      });
-        *
-        * ## Session#touch()
-        *
-        *   Updates the `.maxAge` property. Typically this is
-        *   not necessary to call, as the session middleware does this for you.
-        *
-        * ## Session#cookie
-        *
-        *  Each session has a unique cookie object accompany it. This allows
-        *  you to alter the session cookie per visitor. For example we can
-        *  set `req.session.cookie.expires` to `false` to enable the cookie
-        *  to remain for only the duration of the user-agent.
-        *
-        * ## Session#maxAge
-        *
-        *  Alternatively `req.session.cookie.maxAge` will return the time
-        *  remaining in milliseconds, which we may also re-assign a new value
-        *  to adjust the `.expires` property appropriately. The following
-        *  are essentially equivalent
-        *
-        *     var hour = 3600000;
-        *     req.session.cookie.expires = new Date(Date.now() + hour);
-        *     req.session.cookie.maxAge = hour;
-        *
-        * For example when `maxAge` is set to `60000` (one minute), and 30 seconds
-        * has elapsed it will return `30000` until the current request has completed,
-        * at which time `req.session.touch()` is called to reset `req.session.maxAge`
-        * to its original value.
-        *
-        *     req.session.cookie.maxAge;
-        *     // => 30000
-        *
-        * Session Store Implementation:
-        *
-        * Every session store _must_ implement the following methods
-        *
-        *    - `.get(sid, callback)`
-        *    - `.set(sid, session, callback)`
-        *    - `.destroy(sid, callback)`
-        *
-        * Recommended methods include, but are not limited to:
-        *
-        *    - `.length(callback)`
-        *    - `.clear(callback)`
-        *
-        * For an example implementation view the [connect-redis](http://github.com/visionmedia/connect-redis) repo.
-        *
-        * @param options
-        */
-    session(options?: any): Express.Handler;
-
-    /**
-        * Hash the given `sess` object omitting changes
-        * to `.cookie`.
-        *
-        * @param sess
-        */
-    hash(sess: string): string;
-
-    /**
-        * Static:
-        *
-        *   Static file server with the given `root` path.
-        *
-        * Examples:
-        *
-        *     var oneDay = 86400000;
-        *
-        *     connect()
-        *       .use(connect.static(__dirname + '/public'))
-        *
-        *     connect()
-        *       .use(connect.static(__dirname + '/public', { maxAge: oneDay }))
-        *
-        * Options:
-        *
-        *    - `maxAge`     Browser cache maxAge in milliseconds. defaults to 0
-        *    - `hidden`     Allow transfer of hidden files. defaults to false
-        *    - `redirect`   Redirect to trailing "/" when the pathname is a dir. defaults to true
-        *
-        * @param root
-        * @param options
-        */
-    static(root: string, options?: any): Express.Handler;
-
-    /**
-        * Basic Auth:
-        *
-        * Enfore basic authentication by providing a `callback(user, pass)`,
-        * which must return `true` in order to gain access. Alternatively an async
-        * method is provided as well, invoking `callback(user, pass, callback)`. Populates
-        * `req.user`. The final alternative is simply passing username / password
-        * strings.
-        *
-        *  Simple username and password
-        *
-        *     connect(connect.basicAuth('username', 'password'));
-        *
-        *  Callback verification
-        *
-        *     connect()
-        *       .use(connect.basicAuth(function(user, pass){
-        *         return 'tj' == user & 'wahoo' == pass;
-        *       }))
-        *
-        *  Async callback verification, accepting `fn(err, user)`.
-        *
-        *     connect()
-        *       .use(connect.basicAuth(function(user, pass, fn){
-        *         User.authenticate({ user: user, pass: pass }, fn);
-        *       }))
-        *
-        * @param callback or username
-        * @param realm
-        */
-    basicAuth(callback: (user: string, pass: string, fn : Function) => void, realm?: string): Express.Handler;
-
-    basicAuth(callback: (user: string, pass: string) => boolean, realm?: string): Express.Handler;
-
-    basicAuth(user: string, pass: string, realm?: string): Express.Handler;
-
-    /**
-        * Compress:
-        *
-        * Compress response data with gzip/deflate.
-        *
-        * Filter:
-        *
-        *  A `filter` callback function may be passed to
-        *  replace the default logic of:
-        *
-        *     exports.filter = function(req, res){
-        *       return /json|text|javascript/.test(res.getHeader('Content-Type'));
-        *     };
-        *
-        * Options:
-        *
-        *  All remaining options are passed to the gzip/deflate
-        *  creation functions. Consult node's docs for additional details.
-        *
-        *   - `chunkSize` (default: 16*1024)
-        *   - `windowBits`
-        *   - `level`: 0-9 where 0 is no compression, and 9 is slow but best compression
-        *   - `memLevel`: 1-9 low is slower but uses less memory, high is fast but uses more
-        *   - `strategy`: compression strategy
-        *
-        * @param options
-        */
-    compress(options?: any): Express.Handler;
-
-    /**
-        * Cookie Session:
-        *
-        *   Cookie session middleware.
-        *
-        *      var app = connect();
-        *      app.use(connect.cookieParser());
-        *      app.use(connect.cookieSession({ secret: 'tobo!', cookie: { maxAge: 60 * 60 * 1000 }}));
-        *
-        * Options:
-        *
-        *   - `key` cookie name defaulting to `connect.sess`
-        *   - `secret` prevents cookie tampering
-        *   - `cookie` session cookie settings, defaulting to `{ path: '/', httpOnly: true, maxAge: null }`
-        *   - `proxy` trust the reverse proxy when setting secure cookies (via "x-forwarded-proto")
-        *
-        * Clearing sessions:
-        *
-        *  To clear the session simply set its value to `null`,
-        *  `cookieSession()` will then respond with a 1970 Set-Cookie.
-        *
-        *     req.session = null;
-        *
-        * @param options
-        */
-    cookieSession(options?: any): Express.Handler;
-
-    /**
-        * Anti CSRF:
-        *
-        * CSRF protection middleware.
-        *
-        * This middleware adds a `req.csrfToken()` function to make a token
-        * which should be added to requests which mutate
-        * state, within a hidden form field, query-string etc. This
-        * token is validated against the visitor's session.
-        *
-        * The default `value` function checks `req.body` generated
-        * by the `bodyParser()` middleware, `req.query` generated
-        * by `query()`, and the "X-CSRF-Token" header field.
-        *
-        * This middleware requires session support, thus should be added
-        * somewhere _below_ `session()` and `cookieParser()`.
-        *
-        * Options:
-        *
-        *    - `value` a function accepting the request, returning the token
-        *
-        * @param options
-        */
-    csrf(options?: {value?: Function}): Express.Handler;
-
-    /**
-        * Directory:
-        *
-        * Serve directory listings with the given `root` path.
-        *
-        * Options:
-        *
-        *  - `hidden` display hidden (dot) files. Defaults to false.
-        *  - `icons`  display icons. Defaults to false.
-        *  - `filter` Apply this filter function to files. Defaults to false.
-        *
-        * @param root
-        * @param options
-        */
-    directory(root: string, options?: any): Express.Handler;
-
-    /**
-        * Favicon:
-        *
-        * By default serves the connect favicon, or the favicon
-        * located by the given `path`.
-        *
-        * Options:
-        *
-        *   - `maxAge`  cache-control max-age directive, defaulting to 1 day
-        *
-        * Examples:
-        *
-        *   Serve default favicon:
-        *
-        *     connect()
-        *       .use(connect.favicon())
-        *
-        *   Serve favicon before logging for brevity:
-        *
-        *     connect()
-        *       .use(connect.favicon())
-        *       .use(connect.logger('dev'))
-        *
-        *   Serve custom favicon:
-        *
-        *     connect()
-        *       .use(connect.favicon('public/favicon.ico))
-        *
-        * @param path
-        * @param options
-        */
-    favicon(path?: string, options?: any): Express.Handler;
-
-    /**
-        * JSON:
-        *
-        * Parse JSON request bodies, providing the
-        * parsed object as `req.body`.
-        *
-        * Options:
-        *
-        *   - `strict`  when `false` anything `JSON.parse()` accepts will be parsed
-        *   - `reviver`  used as the second "reviver" argument for JSON.parse
-        *   - `limit`  byte limit disabled by default
-        *
-        * @param options
-        */
-    json(options?: any): Express.Handler;
-
-    /**
-        * Limit:
-        *
-        *   Limit request bodies to the given size in `bytes`.
-        *
-        *   A string representation of the bytesize may also be passed,
-        *   for example "5mb", "200kb", "1gb", etc.
-        *
-        *     connect()
-        *       .use(connect.limit('5.5mb'))
-        *       .use(handleImageUpload)
-        */
-    limit(bytes: number): Express.Handler;
-
-    limit(bytes: string): Express.Handler;
-
-    /**
-        * Logger:
-        *
-        * Log requests with the given `options` or a `format` string.
-        *
-        * Options:
-        *
-        *   - `format`  Format string, see below for tokens
-        *   - `stream`  Output stream, defaults to _stdout_
-        *   - `buffer`  Buffer duration, defaults to 1000ms when _true_
-        *   - `immediate`  Write log line on request instead of response (for response times)
-        *
-        * Tokens:
-        *
-        *   - `:req[header]` ex: `:req[Accept]`
-        *   - `:res[header]` ex: `:res[Content-Length]`
-        *   - `:http-version`
-        *   - `:response-time`
-        *   - `:remote-addr`
-        *   - `:date`
-        *   - `:method`
-        *   - `:url`
-        *   - `:referrer`
-        *   - `:user-agent`
-        *   - `:status`
-        *
-        * Formats:
-        *
-        *   Pre-defined formats that ship with connect:
-        *
-        *    - `default` ':remote-addr - - [:date] ":method :url HTTP/:http-version" :status :res[content-length] ":referrer" ":user-agent"'
-        *    - `short` ':remote-addr - :method :url HTTP/:http-version :status :res[content-length] - :response-time ms'
-        *    - `tiny`  ':method :url :status :res[content-length] - :response-time ms'
-        *    - `dev` concise output colored by response status for development use
-        *
-        * Examples:
-        *
-        *      connect.logger() // default
-        *      connect.logger('short')
-        *      connect.logger('tiny')
-        *      connect.logger({ immediate: true, format: 'dev' })
-        *      connect.logger(':method :url - :referrer')
-        *      connect.logger(':req[content-type] -> :res[content-type]')
-        *      connect.logger(function(tokens, req, res){ return 'some format string' })
-        *
-        * Defining Tokens:
-        *
-        *   To define a token, simply invoke `connect.logger.token()` with the
-        *   name and a callback function. The value returned is then available
-        *   as ":type" in this case.
-        *
-        *      connect.logger.token('type', function(req, res){ return req.headers['content-type']; })
-        *
-        * Defining Formats:
-        *
-        *   All default formats are defined this way, however it's public API as well:
-        *
-        *       connect.logger.format('name', 'string or function')
-        */
-    logger(options: string): Express.Handler;
-
-    logger(options: Function): Express.Handler;
-
-    logger(options?: any): Express.Handler;
-
-    /**
-        * Compile `fmt` into a function.
-        *
-        * @param fmt
-        */
-    compile(fmt: string): Express.Handler;
-
-    /**
-        * Define a token function with the given `name`,
-        * and callback `fn(req, res)`.
-        *
-        * @param name
-        * @param fn
-        */
-    token(name: string, fn: Function): any;
-
-    /**
-        * Define a `fmt` with the given `name`.
-        */
-    format(name: string, str: string): any;
-
-    format(name: string, str: Function): any;
-
-    /**
-        * Query:
-        *
-        * Automatically parse the query-string when available,
-        * populating the `req.query` object.
-        *
-        * Examples:
-        *
-        *     connect()
-        *       .use(connect.query())
-        *       .use(function(req, res){
-        *         res.end(JSON.stringify(req.query));
-        *       });
-        *
-        *  The `options` passed are provided to qs.parse function.
-        */
-    query(options: any): Express.Handler;
-
-    /**
-        * Reponse time:
-        *
-        * Adds the `X-Response-Time` header displaying the response
-        * duration in milliseconds.
-        */
-    responseTime(): Express.Handler;
-
-    /**
-        * Static cache:
-        *
-        * Enables a memory cache layer on top of
-        * the `static()` middleware, serving popular
-        * static files.
-        *
-        * By default a maximum of 128 objects are
-        * held in cache, with a max of 256k each,
-        * totalling ~32mb.
-        *
-        * A Least-Recently-Used (LRU) cache algo
-        * is implemented through the `Cache` object,
-        * simply rotating cache objects as they are
-        * hit. This means that increasingly popular
-        * objects maintain their positions while
-        * others get shoved out of the stack and
-        * garbage collected.
-        *
-        * Benchmarks:
-        *
-        *     static(): 2700 rps
-        *     node-static: 5300 rps
-        *     static() + staticCache(): 7500 rps
-        *
-        * Options:
-        *
-        *   - `maxObjects`  max cache objects [128]
-        *   - `maxLength`  max cache object length 256kb
-        */
-    staticCache(options: any): Express.Handler;
-
-    /**
-        * Timeout:
-        *
-        * Times out the request in `ms`, defaulting to `5000`. The
-        * method `req.clearTimeout()` is added to revert this behaviour
-        * programmatically within your application's middleware, routes, etc.
-        *
-        * The timeout error is passed to `next()` so that you may customize
-        * the response behaviour. This error has the `.timeout` property as
-        * well as `.status == 408`.
-        */
-    timeout(ms: number): Express.Handler;
-
-    /**
-        * Vhost:
-        * 
-        *   Setup vhost for the given `hostname` and `server`.
-        *
-        *     connect()
-        *       .use(connect.vhost('foo.com', fooApp))
-        *       .use(connect.vhost('bar.com', barApp))
-        *       .use(connect.vhost('*.com', mainApp))
-        *
-        *  The `server` may be a Connect server or
-        *  a regular Node `http.Server`. 
-        *
-        * @param hostname
-        * @param server
-        */
-    vhost(hostname: string, server: any): Express.Handler;
-
-    urlencoded(): any;
-
-    multipart(): any;
-}
diff --git a/node/node.d.ts b/node/node.d.ts
index d84769ec4..4fafb883e 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -219,1183 +219,1043 @@ interface NodeTimer {
     unref() : void;
 }
 
-
 /************************************************
 *                                               *
-*              MODULES - EXTERNAL               *
+*                   MODULES                     *
 *                                               *
 ************************************************/
-
-declare module "events"         { import M = _ExternalShim_._NodeJs_.Events;    export = M; }
-declare module "http"           { import M = _ExternalShim_._NodeJs_.Http;      export = M; }
-declare module "url"            { import M = _ExternalShim_._NodeJs_.Url;       export = M; }
-declare module "net"            { import M = _ExternalShim_._NodeJs_.Net;       export = M; }
-declare module "querystring"    { var M: NodeJs.QueryString;    export = M; }
-declare module "cluster"        { var M: NodeJs.Cluster;        export = M; }
-declare module "zlib"           { var M: NodeJs.Zlib;           export = M; }
-declare module "os"             { var M: NodeJs.Os;             export = M; }
-declare module "https"          { var M: NodeJs.Https;          export = M; }
-declare module "punycode"       { var M: NodeJs.PunyCode;       export = M; }
-declare module "repl"           { var M: NodeJs.Repl;           export = M; }
-declare module "readline"       { var M: NodeJs.ReadLine;       export = M; }
-declare module "vm"             { var M: NodeJs.Vm;             export = M; }
-declare module "child_process"  { var M: NodeJs.ChildProcess;   export = M; }
-declare module "dns"            { var M: NodeJs.Dns;            export = M; }
-declare module "dgram"          { var M: NodeJs.Dgram;          export = M; }
-declare module "fs"             { var M: NodeJs.Fs;             export = M; }
-declare module "path"           { var M: NodeJs.Path;           export = M; }
-declare module "string_decoder" { var M: NodeJs.StringDecoder;  export = M; }
-declare module "tls"            { var M: NodeJs.Tls;            export = M; }
-declare module "crypto"         { var M: NodeJs.Crypto;         export = M; }
-declare module "stream"         { var M: NodeJs.Stream;         export = M; }
-declare module "util"           { var M: NodeJs.Util;           export = M; }
-declare module "assert"         { var M: NodeJs.Assert;         export = M; }
-declare module "tty"            { var M: NodeJs.Tty;            export = M; }
-declare module "domain"         { var M: NodeJs.Domain;         export = M; }
-
-
-/************************************************
-*                                               *
-*           EXTERNAL - INTERNAL SHIM            *
-*                                               *
-************************************************/
-
-// NB: This module exists so that 'pure' (ie non-instantiated) internal modules may
-// be declared in parallel with external modules, without breaking code that relies
-// on certain behaviours of external modules. It's a shim to support type definitions
-// that are already out there which use the pattern exemplified below:
-//
-//      declare module "mymodule" {
-//          import http   = require('http');
-//          ...
-//          server?: http.Server;
-//
-// Note that the type 'Server' is accessed via the variable 'http', meaning that
-// Server must be not just a type, but also a property on 'http'. The 'pure' typings
-// declared in the NodeJs module below don't support this usage. With the _ExternalShim_
-// shim, the above code will continue working unchanged. New type definitions should
-// prefer something like:
-//
-//      declare module "mymodule" {
-//          ...
-//          server?: NodeJs.Http.Server;
-//
-// If all typings switch to using the pure internal types in NodeJs, this shim can be removed.
-
-declare module _ExternalShim_ {
-    export module _NodeJs_ {
-        export module Events {
-            export class EventEmitter implements NodeEventEmitter {
-                static listenerCount(emitter: EventEmitter, event: string): number;
-                addListener(event: string, listener: Function): EventEmitter;
-                on(event: string, listener: Function): EventEmitter;
-                once(event: string, listener: Function): EventEmitter;
-                removeListener(event: string, listener: Function): EventEmitter;
-                removeAllListeners(event?: string): EventEmitter;
-                setMaxListeners(n: number): void;
-                listeners(event: string): Function[];
-                emit(event: string, ...args: any[]): boolean;
-            }
-        }
-        export var Http: NodeJs.Http;
-        export module Http {
-            export interface Server extends NodeJs.Http.Server { }
-            export interface ServerRequest extends NodeJs.Http.ServerRequest { }
-            export interface ServerResponse extends NodeJs.Http.ServerResponse { }
-            export interface ClientRequest extends NodeJs.Http.ClientRequest { }
-            export interface ClientResponse extends NodeJs.Http.ClientResponse { }
-            export interface Agent extends NodeJs.Http.Agent { }
-        }
-        export var Net: NodeJs.Net;
-        export module Net {
-            export interface Socket extends NodeJs.Net.Socket { }
-            export interface Server extends NodeJs.Net.Server { }
-        }
-        export var Url: NodeJs.Url;
-        export module Url {
-            export interface Url extends NodeJs.Url.Url { }
-            export interface UrlOptions extends NodeJs.Url.UrlOptions { }
-        }
-    }
+declare module "querystring" {
+    export function stringify(obj: any, sep?: string, eq?: string): string;
+    export function parse(str: string, sep?: string, eq?: string, options?: { maxKeys?: number; }): any;
+    export function escape(): any;
+    export function unescape(): any;
 }
 
+declare module "events" {
+    export class EventEmitter implements NodeEventEmitter {
+        static listenerCount(emitter: EventEmitter, event: string): number;
 
-/************************************************
-*                                               *
-*              MODULES - INTERNAL               *
-*                                               *
-************************************************/
-
-declare module NodeJs {
-
-
-    // ---------- "querystring" module ----------
-    export interface QueryString {
-        stringify(obj: any, sep?: string, eq?: string): string;
-        parse(str: string, sep?: string, eq?: string, options?: { maxKeys?: number; }): any;
-        escape(): any;
-        unescape(): any;
-    }
-
-
-    // ---------- "events" module ----------
-    export interface Events {
-        EventEmitter: {
-            new(): Events.EventEmitter;
-            listenerCount(emitter: Events.EventEmitter, event: string): number;
-        }
-    }
-    export module Events {
-        export interface EventEmitter extends NodeEventEmitter {
-            addListener(event: string, listener: Function): EventEmitter;
-            on(event: string, listener: Function): EventEmitter;
-            once(event: string, listener: Function): EventEmitter;
-            removeListener(event: string, listener: Function): EventEmitter;
-            removeAllListeners(event?: string): EventEmitter;
-            setMaxListeners(n: number): void;
-            listeners(event: string): Function[];
-            emit(event: string, ...args: any[]): boolean;
-        }
-    }
-
-
-    // ---------- "http" module ----------
-    export interface Http {
-        STATUS_CODES: any;
-        createServer(requestListener?: (request: Http.ServerRequest, response: Http.ServerResponse) =>void ): Http.Server;
-        createClient(port?: number, host?: string): any;
-        request(options: any, callback?: Function): Http.ClientRequest;
-        get(options: any, callback?: Function): Http.ClientRequest;
-        globalAgent: Http.Agent;
-    }
-    export module Http {
-        export interface Server extends NodeEventEmitter {
-            listen(port: number, hostname?: string, backlog?: number, callback?: Function): void;
-            listen(path: string, callback?: Function): void;
-            listen(handle: any, listeningListener?: Function): void;
-            close(cb?: any): void;
-            maxHeadersCount: number;
-        }
-        export interface ServerRequest extends NodeEventEmitter, ReadableStream {
-            method: string;
-            url: string;
-            headers: any;
-            trailers: string;
-            httpVersion: string;
-            setEncoding(encoding?: string): void;
-            pause(): void;
-            resume(): void;
-            connection: Net.Socket;
-        }
-        export interface ServerResponse extends NodeEventEmitter, WritableStream {
-
-            // Extended base methods
-            write(buffer: NodeBuffer): boolean;
-            write(buffer: NodeBuffer, cb?: Function): boolean;
-            write(str: string, cb?: Function): boolean;
-            write(str: string, encoding?: string, cb?: Function): boolean;
-            write(str: string, encoding?: string, fd?: string): boolean;
-
-            writeContinue(): void;
-            writeHead(statusCode: number, reasonPhrase?: string, headers?: any): void;
-            writeHead(statusCode: number, headers?: any): void;
-            statusCode: number;
-            setHeader(name: string, value: string): void;
-            sendDate: boolean;
-            getHeader(name: string): string;
-            removeHeader(name: string): void;
-            write(chunk: any, encoding?: string): any;
-            addTrailers(headers: any): void;
-
-            // Extended base methods
-            end(): void;
-            end(buffer: NodeBuffer, cb?: Function): void;
-            end(str: string, cb?: Function): void;
-            end(str: string, encoding?: string, cb?: Function): void;
-            end(data?: any, encoding?: string): void;
-        }
-        export interface ClientRequest extends NodeEventEmitter, WritableStream {
-
-            // Extended base methods
-            write(buffer: NodeBuffer): boolean;
-            write(buffer: NodeBuffer, cb?: Function): boolean;
-            write(str: string, cb?: Function): boolean;
-            write(str: string, encoding?: string, cb?: Function): boolean;
-            write(str: string, encoding?: string, fd?: string): boolean;
-
-            write(chunk: any, encoding?: string): void;
-            abort(): void;
-            setTimeout(timeout: number, callback?: Function): void;
-            setNoDelay(noDelay?: Function): void;
-            setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
-
-            // Extended base methods
-            end(): void;
-            end(buffer: NodeBuffer, cb?: Function): void;
-            end(str: string, cb?: Function): void;
-            end(str: string, encoding?: string, cb?: Function): void;
-            end(data?: any, encoding?: string): void;
-        }
-        export interface ClientResponse extends NodeEventEmitter, ReadableStream {
-            statusCode: number;
-            httpVersion: string;
-            headers: any;
-            trailers: any;
-            setEncoding(encoding?: string): void;
-            pause(): void;
-            resume(): void;
-        }
-        export interface Agent { maxSockets: number; sockets: any; requests: any; }
-    }
-
-
-    // ---------- "cluster" module ----------
-    export interface Cluster {
-        settings: Cluster.ClusterSettings;
-        isMaster: boolean;
-        isWorker: boolean;
-        setupMaster(settings?: Cluster.ClusterSettings): void;
-        fork(env?: any): Worker;
-        disconnect(callback?: Function): void;
-        worker: Worker;
-        workers: Worker[];
-
-        // Event emitter
-        addListener(event: string, listener: Function): void;
-        on(event: string, listener: Function): any;
-        once(event: string, listener: Function): void;
-        removeListener(event: string, listener: Function): void;
-        removeAllListeners(event?: string): void;
+        addListener(event: string, listener: Function): EventEmitter;
+        on(event: string, listener: Function): EventEmitter;
+        once(event: string, listener: Function): EventEmitter;
+        removeListener(event: string, listener: Function): EventEmitter;
+        removeAllListeners(event?: string): EventEmitter;
         setMaxListeners(n: number): void;
         listeners(event: string): Function[];
         emit(event: string, ...args: any[]): boolean;
+   }
+}
 
-        Worker: {
-            (): any;    // Correctly reflect the fact that this is a (constructor) function,
-                        // without suggesting that instances can be obtained this way
-        }
+declare module "http" {
+    import events = require("events");
+    import net = require("net");
+    import stream = require("stream");
+
+    export interface Server extends NodeEventEmitter {
+        listen(port: number, hostname?: string, backlog?: number, callback?: Function): void;
+        listen(path: string, callback?: Function): void;
+        listen(handle: any, listeningListener?: Function): void;
+        close(cb?: any): void;
+        maxHeadersCount: number;
     }
-    export module Cluster {
-        export interface ClusterSettings {
-            exec?: string;
-            args?: string[];
-            silent?: boolean;
-        }
-        export interface Worker extends Events.EventEmitter {
-            id: string;
-            process: ChildProcess.ChildProcess;
-            suicide: boolean;
-            send(message: any, sendHandle?: any): void;
-            kill(signal?: string): void;
-            destroy(signal?: string): void;
-            disconnect(): void;
-        }
+    export interface ServerRequest extends NodeEventEmitter, ReadableStream {
+        method: string;
+        url: string;
+        headers: any;
+        trailers: string;
+        httpVersion: string;
+        setEncoding(encoding?: string): void;
+        pause(): void;
+        resume(): void;
+        connection: net.Socket;
+    }
+    export interface ServerResponse extends NodeEventEmitter, WritableStream {
+        // Extended base methods
+        write(buffer: NodeBuffer): boolean;
+        write(buffer: NodeBuffer, cb?: Function): boolean;
+        write(str: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, fd?: string): boolean;
+
+        writeContinue(): void;
+        writeHead(statusCode: number, reasonPhrase?: string, headers?: any): void;
+        writeHead(statusCode: number, headers?: any): void;
+        statusCode: number;
+        setHeader(name: string, value: string): void;
+        sendDate: boolean;
+        getHeader(name: string): string;
+        removeHeader(name: string): void;
+        write(chunk: any, encoding?: string): any;
+        addTrailers(headers: any): void;
+
+        // Extended base methods
+        end(): void;
+        end(buffer: NodeBuffer, cb?: Function): void;
+        end(str: string, cb?: Function): void;
+        end(str: string, encoding?: string, cb?: Function): void;
+        end(data?: any, encoding?: string): void;
+    }
+    export interface ClientRequest extends NodeEventEmitter, WritableStream {
+        // Extended base methods
+        write(buffer: NodeBuffer): boolean;
+        write(buffer: NodeBuffer, cb?: Function): boolean;
+        write(str: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, fd?: string): boolean;
+
+        write(chunk: any, encoding?: string): void;
+        abort(): void;
+        setTimeout(timeout: number, callback?: Function): void;
+        setNoDelay(noDelay?: Function): void;
+        setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
+
+        // Extended base methods
+        end(): void;
+        end(buffer: NodeBuffer, cb?: Function): void;
+        end(str: string, cb?: Function): void;
+        end(str: string, encoding?: string, cb?: Function): void;
+        end(data?: any, encoding?: string): void;
+    }
+    export interface ClientResponse extends NodeEventEmitter, ReadableStream {
+        statusCode: number;
+        httpVersion: string;
+        headers: any;
+        trailers: any;
+        setEncoding(encoding?: string): void;
+        pause(): void;
+        resume(): void;
+    }
+    export interface Agent { maxSockets: number; sockets: any; requests: any; }
+
+    export var STATUS_CODES: any;
+    export function createServer(requestListener?: (request: ServerRequest, response: ServerResponse) =>void ): Server;
+    export function createClient(port?: number, host?: string): any;
+    export function request(options: any, callback?: Function): ClientRequest;
+    export function get(options: any, callback?: Function): ClientRequest;
+    export var globalAgent: Agent;
+}
+
+declare module "cluster" {
+    import child  = require("child_process");
+    import events = require("events");
+
+    export interface ClusterSettings {
+        exec?: string;
+        args?: string[];
+        silent?: boolean;
     }
 
-
-    // ---------- "zlib" module ----------
-    export interface Zlib {
-        createGzip(options?: Zlib.ZlibOptions): Zlib.Gzip;
-        createGunzip(options?: Zlib.ZlibOptions): Zlib.Gunzip;
-        createDeflate(options?: Zlib.ZlibOptions): Zlib.Deflate;
-        createInflate(options?: Zlib.ZlibOptions): Zlib.Inflate;
-        createDeflateRaw(options?: Zlib.ZlibOptions): Zlib.DeflateRaw;
-        createInflateRaw(options?: Zlib.ZlibOptions): Zlib.InflateRaw;
-        createUnzip(options?: Zlib.ZlibOptions): Zlib.Unzip;
-
-        deflate(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-        deflateRaw(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-        gzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-        gunzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-        inflate(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-        inflateRaw(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-        unzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-
-        // Constants
-        Z_NO_FLUSH: number;
-        Z_PARTIAL_FLUSH: number;
-        Z_SYNC_FLUSH: number;
-        Z_FULL_FLUSH: number;
-        Z_FINISH: number;
-        Z_BLOCK: number;
-        Z_TREES: number;
-        Z_OK: number;
-        Z_STREAM_END: number;
-        Z_NEED_DICT: number;
-        Z_ERRNO: number;
-        Z_STREAM_ERROR: number;
-        Z_DATA_ERROR: number;
-        Z_MEM_ERROR: number;
-        Z_BUF_ERROR: number;
-        Z_VERSION_ERROR: number;
-        Z_NO_COMPRESSION: number;
-        Z_BEST_SPEED: number;
-        Z_BEST_COMPRESSION: number;
-        Z_DEFAULT_COMPRESSION: number;
-        Z_FILTERED: number;
-        Z_HUFFMAN_ONLY: number;
-        Z_RLE: number;
-        Z_FIXED: number;
-        Z_DEFAULT_STRATEGY: number;
-        Z_BINARY: number;
-        Z_TEXT: number;
-        Z_ASCII: number;
-        Z_UNKNOWN: number;
-        Z_DEFLATED: number;
-        Z_NULL: number;
-    }
-    export module Zlib {
-        export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; }
-        export interface Gzip extends ReadWriteStream { }
-        export interface Gunzip extends ReadWriteStream { }
-        export interface Deflate extends ReadWriteStream { }
-        export interface Inflate extends ReadWriteStream { }
-        export interface DeflateRaw extends ReadWriteStream { }
-        export interface InflateRaw extends ReadWriteStream { }
-        export interface Unzip extends ReadWriteStream { }
+    export class Worker extends events.EventEmitter {
+        id: string;
+        process: child.ChildProcess;
+        suicide: boolean;
+        send(message: any, sendHandle?: any): void;
+        kill(signal?: string): void;
+        destroy(signal?: string): void;
+        disconnect(): void;
     }
 
+    export var settings: ClusterSettings;
+    export var isMaster: boolean;
+    export var isWorker: boolean;
+    export function setupMaster(settings?: ClusterSettings): void;
+    export function fork(env?: any): Worker;
+    export function disconnect(callback?: Function): void;
+    export var worker: Worker;
+    export var workers: Worker[];
 
-    // ---------- "os" module ----------
-    export interface Os {
-        tmpDir(): string;
-        hostname(): string;
-        type(): string;
-        platform(): string;
-        arch(): string;
-        release(): string;
-        uptime(): number;
-        loadavg(): number[];
-        totalmem(): number;
-        freemem(): number;
-        cpus(): { model: string; speed: number; times: { user: number; nice: number; sys: number; idle: number; irq: number; }; }[];
-        networkInterfaces(): any;
-        EOL: string;
+    // Event emitter
+    export function addListener(event: string, listener: Function): void;
+    export function on(event: string, listener: Function): any;
+    export function once(event: string, listener: Function): void;
+    export function removeListener(event: string, listener: Function): void;
+    export function removeAllListeners(event?: string): void;
+    export function setMaxListeners(n: number): void;
+    export function listeners(event: string): Function[];
+    export function emit(event: string, ...args: any[]): boolean;
+}
+
+declare module "zlib" {
+    import stream = require("stream");
+    export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; }
+
+    export interface Gzip extends ReadWriteStream { }
+    export interface Gunzip extends ReadWriteStream { }
+    export interface Deflate extends ReadWriteStream { }
+    export interface Inflate extends ReadWriteStream { }
+    export interface DeflateRaw extends ReadWriteStream { }
+    export interface InflateRaw extends ReadWriteStream { }
+    export interface Unzip extends ReadWriteStream { }
+
+    export function createGzip(options?: ZlibOptions): Gzip;
+    export function createGunzip(options?: ZlibOptions): Gunzip;
+    export function createDeflate(options?: ZlibOptions): Deflate;
+    export function createInflate(options?: ZlibOptions): Inflate;
+    export function createDeflateRaw(options?: ZlibOptions): DeflateRaw;
+    export function createInflateRaw(options?: ZlibOptions): InflateRaw;
+    export function createUnzip(options?: ZlibOptions): Unzip;
+
+    export function deflate(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+    export function deflateRaw(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+    export function gzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+    export function gunzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+    export function inflate(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+    export function inflateRaw(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+    export function unzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+
+    // Constants
+    export var Z_NO_FLUSH: number;
+    export var Z_PARTIAL_FLUSH: number;
+    export var Z_SYNC_FLUSH: number;
+    export var Z_FULL_FLUSH: number;
+    export var Z_FINISH: number;
+    export var Z_BLOCK: number;
+    export var Z_TREES: number;
+    export var Z_OK: number;
+    export var Z_STREAM_END: number;
+    export var Z_NEED_DICT: number;
+    export var Z_ERRNO: number;
+    export var Z_STREAM_ERROR: number;
+    export var Z_DATA_ERROR: number;
+    export var Z_MEM_ERROR: number;
+    export var Z_BUF_ERROR: number;
+    export var Z_VERSION_ERROR: number;
+    export var Z_NO_COMPRESSION: number;
+    export var Z_BEST_SPEED: number;
+    export var Z_BEST_COMPRESSION: number;
+    export var Z_DEFAULT_COMPRESSION: number;
+    export var Z_FILTERED: number;
+    export var Z_HUFFMAN_ONLY: number;
+    export var Z_RLE: number;
+    export var Z_FIXED: number;
+    export var Z_DEFAULT_STRATEGY: number;
+    export var Z_BINARY: number;
+    export var Z_TEXT: number;
+    export var Z_ASCII: number;
+    export var Z_UNKNOWN: number;
+    export var Z_DEFLATED: number;
+    export var Z_NULL: number;
+}
+
+declare module "os" {
+    export function tmpDir(): string;
+    export function hostname(): string;
+    export function type(): string;
+    export function platform(): string;
+    export function arch(): string;
+    export function release(): string;
+    export function uptime(): number;
+    export function loadavg(): number[];
+    export function totalmem(): number;
+    export function freemem(): number;
+    export function cpus(): { model: string; speed: number; times: { user: number; nice: number; sys: number; idle: number; irq: number; }; }[];
+    export function networkInterfaces(): any;
+    export var EOL: string;
+}
+
+declare module "https" {
+    import tls = require("tls");
+    import events = require("events");
+    import http = require("http");
+
+    export interface ServerOptions {
+        pfx?: any;
+        key?: any;
+        passphrase?: string;
+        cert?: any;
+        ca?: any;
+        crl?: any;
+        ciphers?: string;
+        honorCipherOrder?: boolean;
+        requestCert?: boolean;
+        rejectUnauthorized?: boolean;
+        NPNProtocols?: any;
+        SNICallback?: (servername: string) => any;
     }
 
-
-    // ---------- "https" module ----------
-    export interface Https {
-        Agent: new(options?: Https.RequestOptions) => Https.Agent;
-
-        createServer(options: Https.ServerOptions, requestListener?: Function): Https.Server;
-        request(options: Https.RequestOptions, callback?: (res: NodeEventEmitter) => void): Http.ClientRequest;
-        get(options: Https.RequestOptions, callback?: (res: NodeEventEmitter) => void): Http.ClientRequest;
-        globalAgent: Https.Agent;
-    }
-    export module Https {
-        export interface ServerOptions {
-            pfx?: any;
-            key?: any;
-            passphrase?: string;
-            cert?: any;
-            ca?: any;
-            crl?: any;
-            ciphers?: string;
-            honorCipherOrder?: boolean;
-            requestCert?: boolean;
-            rejectUnauthorized?: boolean;
-            NPNProtocols?: any;
-            SNICallback?: (servername: string) => any;
-        }
-        export interface RequestOptions {
-            host?: string;
-            hostname?: string;
-            port?: number;
-            path?: string;
-            method?: string;
-            headers?: any;
-            auth?: string;
-            agent?: any;
-            pfx?: any;
-            key?: any;
-            passphrase?: string;
-            cert?: any;
-            ca?: any;
-            ciphers?: string;
-            rejectUnauthorized?: boolean;
-        }
-        export interface Agent {
-            maxSockets: number;
-            sockets: any;
-            requests: any;
-        }
-        export interface Server extends Tls.Server { }
+    export interface RequestOptions {
+        host?: string;
+        hostname?: string;
+        port?: number;
+        path?: string;
+        method?: string;
+        headers?: any;
+        auth?: string;
+        agent?: any;
+        pfx?: any;
+        key?: any;
+        passphrase?: string;
+        cert?: any;
+        ca?: any;
+        ciphers?: string;
+        rejectUnauthorized?: boolean;
     }
 
+    export interface Agent {
+        maxSockets: number;
+        sockets: any;
+        requests: any;
+    }
+    export var Agent: {
+        new (options?: RequestOptions): Agent;
+    };
+    export interface Server extends tls.Server { }
+    export function createServer(options: ServerOptions, requestListener?: Function): Server;
+    export function request(options: RequestOptions, callback?: (res: NodeEventEmitter) =>void ): http.ClientRequest;
+    export function get(options: RequestOptions, callback?: (res: NodeEventEmitter) =>void ): http.ClientRequest;
+    export var globalAgent: Agent;
+}
 
-    // ---------- "punycode" module ----------
-    export interface PunyCode {
+declare module "punycode" {
+    export function decode(string: string): string;
+    export function encode(string: string): string;
+    export function toUnicode(domain: string): string;
+    export function toASCII(domain: string): string;
+    export var ucs2: ucs2;
+    interface ucs2 {
         decode(string: string): string;
-        encode(string: string): string;
-        toUnicode(domain: string): string;
-        toASCII(domain: string): string;
-        ucs2: {
-            decode(string: string): string;
-            encode(codePoints: number[]): string;
-        }
-        version: any;
+        encode(codePoints: number[]): string;
+    }
+    export var version: any;
+}
+
+declare module "repl" {
+    import stream = require("stream");
+    import events = require("events");
+
+    export interface ReplOptions {
+        prompt?: string;
+        input?: ReadableStream;
+        output?: WritableStream;
+        terminal?: boolean;
+        eval?: Function;
+        useColors?: boolean;
+        useGlobal?: boolean;
+        ignoreUndefined?: boolean;
+        writer?: Function;
+    }
+    export function start(options: ReplOptions): NodeEventEmitter;
+}
+
+declare module "readline" {
+    import events = require("events");
+    import stream = require("stream");
+
+    export interface ReadLine extends NodeEventEmitter {
+        setPrompt(prompt: string, length: number): void;
+        prompt(preserveCursor?: boolean): void;
+        question(query: string, callback: Function): void;
+        pause(): void;
+        resume(): void;
+        close(): void;
+        write(data: any, key?: any): void;
+    }
+    export interface ReadLineOptions {
+        input: ReadableStream;
+        output: WritableStream;
+        completer?: Function;
+        terminal?: boolean;
+    }
+    export function createInterface(options: ReadLineOptions): ReadLine;
+}
+
+declare module "vm" {
+    export interface Context { }
+    export interface Script {
+        runInThisContext(): void;
+        runInNewContext(sandbox?: Context): void;
+    }
+    export function runInThisContext(code: string, filename?: string): void;
+    export function runInNewContext(code: string, sandbox?: Context, filename?: string): void;
+    export function runInContext(code: string, context: Context, filename?: string): void;
+    export function createContext(initSandbox?: Context): Context;
+    export function createScript(code: string, filename?: string): Script;
+}
+
+declare module "child_process" {
+    import events = require("events");
+    import stream = require("stream");
+
+    export interface ChildProcess extends NodeEventEmitter {
+        stdin: WritableStream;
+        stdout: ReadableStream;
+        stderr: ReadableStream;
+        pid: number;
+        kill(signal?: string): void;
+        send(message: any, sendHandle: any): void;
+        disconnect(): void;
     }
 
+    export function spawn(command: string, args?: string[], options?: {
+        cwd?: string;
+        stdio?: any;
+        custom?: any;
+        env?: any;
+        detached?: boolean;
+    }): ChildProcess;
+    export function exec(command: string, options: {
+        cwd?: string;
+        stdio?: any;
+        customFds?: any;
+        env?: any;
+        encoding?: string;
+        timeout?: number;
+        maxBuffer?: number;
+        killSignal?: string;
+    }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
+    export function exec(command: string, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
+    export function execFile(file: string, args: string[], options: {
+        cwd?: string;
+        stdio?: any;
+        customFds?: any;
+        env?: any;
+        encoding?: string;
+        timeout?: number;
+        maxBuffer?: string;
+        killSignal?: string;
+    }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
+    export function fork(modulePath: string, args?: string[], options?: {
+        cwd?: string;
+        env?: any;
+        encoding?: string;
+    }): ChildProcess;
+}
 
-    // ---------- "repl" module ----------
-    export interface Repl {
-        start(options: Repl.ReplOptions): NodeEventEmitter;
-    }
-    export module Repl {
-        export interface ReplOptions {
-            prompt?: string;
-            input?: ReadableStream;
-            output?: WritableStream;
-            terminal?: boolean;
-            eval?: Function;
-            useColors?: boolean;
-            useGlobal?: boolean;
-            ignoreUndefined?: boolean;
-            writer?: Function;
-        }
-    }
-
-
-    // ---------- "readline" module ----------
-    export interface ReadLine {
-        createInterface(options: ReadLine.ReadLineOptions): ReadLine.ReadLine;
-    }
-    export module ReadLine {
-        export interface ReadLine extends NodeEventEmitter {
-            setPrompt(prompt: string, length: number): void;
-            prompt(preserveCursor?: boolean): void;
-            question(query: string, callback: Function): void;
-            pause(): void;
-            resume(): void;
-            close(): void;
-            write(data: any, key?: any): void;
-        }
-        export interface ReadLineOptions {
-            input: ReadableStream;
-            output: WritableStream;
-            completer?: Function;
-            terminal?: boolean;
-        }
-    }
-
-
-    // ---------- "vm" module ----------
-    export interface Vm {
-        runInThisContext(code: string, filename?: string): void;
-        runInNewContext(code: string, sandbox?: Vm.Context, filename?: string): void;
-        runInContext(code: string, context: Vm.Context, filename?: string): void;
-        createContext(initSandbox?: Vm.Context): Vm.Context;
-        createScript(code: string, filename?: string): Vm.Script;
-    }
-    export module Vm {
-        export interface Context { }
-        export interface Script {
-            runInThisContext(): void;
-            runInNewContext(sandbox?: Context): void;
-        }
-    }
-
-
-    // ---------- "child_process" module ----------
-    export interface ChildProcess {
-        spawn(command: string, args?: string[], options?: {
-            cwd?: string;
-            stdio?: any;
-            custom?: any;
-            env?: any;
-            detached?: boolean;
-        }): ChildProcess.ChildProcess;
-        exec(command: string, options: {
-            cwd?: string;
-            stdio?: any;
-            customFds?: any;
-            env?: any;
-            encoding?: string;
-            timeout?: number;
-            maxBuffer?: number;
-            killSignal?: string;
-        }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess.ChildProcess;
-        exec(command: string, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess.ChildProcess;
-        execFile(file: string, args: string[], options: {
-            cwd?: string;
-            stdio?: any;
-            customFds?: any;
-            env?: any;
-            encoding?: string;
-            timeout?: number;
-            maxBuffer?: string;
-            killSignal?: string;
-        }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess.ChildProcess;
-        fork(modulePath: string, args?: string[], options?: {
-            cwd?: string;
-            env?: any;
-            encoding?: string;
-        }): ChildProcess.ChildProcess;
-    }
-    export module ChildProcess {
-        export interface ChildProcess extends NodeEventEmitter {
-            stdin: WritableStream;
-            stdout: ReadableStream;
-            stderr: ReadableStream;
-            pid: number;
-            kill(signal?: string): void;
-            send(message: any, sendHandle: any): void;
-            disconnect(): void;
-        }
-    }
-
-
-    // ---------- "url" module ----------
+declare module "url" {
     export interface Url {
-        parse(urlStr: string, parseQueryString?: boolean , slashesDenoteHost?: boolean ): Url.Url;
-        format(url: Url.UrlOptions): string;
-        resolve(from: string, to: string): string;
-    }
-    export module Url {
-        export interface Url {
-            href: string;
-            protocol: string;
-            auth: string;
-            hostname: string;
-            port: string;
-            host: string;
-            pathname: string;
-            search: string;
-            query: string;
-            slashes: boolean;
-            hash: string;
-        }
-        export interface UrlOptions {
-            protocol?: string;
-            auth?: string;
-            hostname?: string;
-            port?: string;
-            host?: string;
-            pathname?: string;
-            search?: string;
-            query?: any;
-        }
+        href: string;
+        protocol: string;
+        auth: string;
+        hostname: string;
+        port: string;
+        host: string;
+        pathname: string;
+        search: string;
+        query: string;
+        slashes: boolean;
     }
 
-
-    // ---------- "dns" module ----------
-    export interface Dns {
-        lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string;
-        lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string;
-        resolve(domain: string, rrtype: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-        resolve(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-        resolve4(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-        resolve6(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-        resolveMx(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-        resolveTxt(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-        resolveSrv(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-        resolveNs(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-        resolveCname(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
-        reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[];
+    export interface UrlOptions {
+        protocol?: string;
+        auth?: string;
+        hostname?: string;
+        port?: string;
+        host?: string;
+        pathname?: string;
+        search?: string;
+        query?: any;
     }
 
+    export function parse(urlStr: string, parseQueryString?: boolean , slashesDenoteHost?: boolean ): Url;
+    export function format(url: UrlOptions): string;
+    export function resolve(from: string, to: string): string;
+}
 
-    // ---------- "net" module ----------
-    export interface Net {
-        Socket: new(options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }) => Net.Socket;
+declare module "dns" {
+    export function lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string;
+    export function lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string;
+    export function resolve(domain: string, rrtype: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolve(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolve4(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolve6(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolveMx(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolveTxt(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolveSrv(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolveNs(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolveCname(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[];
+}
 
-        createServer(connectionListener?: (socket: Net.Socket) =>void ): Net.Server;
-        createServer(options?: { allowHalfOpen?: boolean; }, connectionListener?: (socket: Net.Socket) =>void ): Net.Server;
-        connect(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): Net.Socket;
-        connect(port: number, host?: string, connectionListener?: Function): Net.Socket;
-        connect(path: string, connectionListener?: Function): Net.Socket;
-        createConnection(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): Net.Socket;
-        createConnection(port: number, host?: string, connectionListener?: Function): Net.Socket;
-        createConnection(path: string, connectionListener?: Function): Net.Socket;
-        isIP(input: string): number;
-        isIPv4(input: string): boolean;
-        isIPv6(input: string): boolean;
-    }
-    export module Net {
-        export interface Socket extends ReadWriteStream {
+declare module "net" {
+    import stream = require("stream");
 
-            // Extended base methods
-            write(buffer: NodeBuffer): boolean;
-            write(buffer: NodeBuffer, cb?: Function): boolean;
-            write(str: string, cb?: Function): boolean;
-            write(str: string, encoding?: string, cb?: Function): boolean;
-            write(str: string, encoding?: string, fd?: string): boolean;
+    export interface Socket extends ReadWriteStream {
+        // Extended base methods
+        write(buffer: NodeBuffer): boolean;
+        write(buffer: NodeBuffer, cb?: Function): boolean;
+        write(str: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, fd?: string): boolean;
 
-            connect(port: number, host?: string, connectionListener?: Function): void;
-            connect(path: string, connectionListener?: Function): void;
-            bufferSize: number;
-            setEncoding(encoding?: string): void;
-            write(data: any, encoding?: string, callback?: Function): void;
-            destroy(): void;
-            pause(): void;
-            resume(): void;
-            setTimeout(timeout: number, callback?: Function): void;
-            setNoDelay(noDelay?: boolean): void;
-            setKeepAlive(enable?: boolean, initialDelay?: number): void;
-            address(): { port: number; family: string; address: string; };
-            remoteAddress: string;
-            remotePort: number;
-            bytesRead: number;
-            bytesWritten: number;
+        connect(port: number, host?: string, connectionListener?: Function): void;
+        connect(path: string, connectionListener?: Function): void;
+        bufferSize: number;
+        setEncoding(encoding?: string): void;
+        write(data: any, encoding?: string, callback?: Function): void;
+        destroy(): void;
+        pause(): void;
+        resume(): void;
+        setTimeout(timeout: number, callback?: Function): void;
+        setNoDelay(noDelay?: boolean): void;
+        setKeepAlive(enable?: boolean, initialDelay?: number): void;
+        address(): { port: number; family: string; address: string; };
+        remoteAddress: string;
+        remotePort: number;
+        bytesRead: number;
+        bytesWritten: number;
 
-            // Extended base methods
-            end(): void;
-            end(buffer: NodeBuffer, cb?: Function): void;
-            end(str: string, cb?: Function): void;
-            end(str: string, encoding?: string, cb?: Function): void;
-            end(data?: any, encoding?: string): void;
-        }
-        export interface Server extends Socket {
-            listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
-            listen(path: string, listeningListener?: Function): void;
-            listen(handle: any, listeningListener?: Function): void;
-            close(callback?: Function): void;
-            address(): { port: number; family: string; address: string; };
-            maxConnections: number;
-            connections: number;
-        }
+        // Extended base methods
+        end(): void;
+        end(buffer: NodeBuffer, cb?: Function): void;
+        end(str: string, cb?: Function): void;
+        end(str: string, encoding?: string, cb?: Function): void;
+        end(data?: any, encoding?: string): void;
     }
 
+    export var Socket: {
+        new (options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }): Socket;
+    };
 
-    // ---------- "dgram" module ----------
-    export interface Dgram {
-        createSocket(type: string, callback?: Function): Dgram.Socket;
+    export interface Server extends Socket {
+        listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
+        listen(path: string, listeningListener?: Function): void;
+        listen(handle: any, listeningListener?: Function): void;
+        close(callback?: Function): void;
+        address(): { port: number; family: string; address: string; };
+        maxConnections: number;
+        connections: number;
     }
-    export module Dgram {
-        interface Socket extends NodeEventEmitter {
-            send(buf: NodeBuffer, offset: number, length: number, port: number, address: string, callback?: Function): void;
-            bind(port: number, address?: string): void;
-            close(): void;
-            address: { address: string; family: string; port: number; };
-            setBroadcast(flag: boolean): void;
-            setMulticastTTL(ttl: number): void;
-            setMulticastLoopback(flag: boolean): void;
-            addMembership(multicastAddress: string, multicastInterface?: string): void;
-            dropMembership(multicastAddress: string, multicastInterface?: string): void;
-        }
+    export function createServer(connectionListener?: (socket: Socket) =>void ): Server;
+    export function createServer(options?: { allowHalfOpen?: boolean; }, connectionListener?: (socket: Socket) =>void ): Server;
+    export function connect(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): Socket;
+    export function connect(port: number, host?: string, connectionListener?: Function): Socket;
+    export function connect(path: string, connectionListener?: Function): Socket;
+    export function createConnection(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): Socket;
+    export function createConnection(port: number, host?: string, connectionListener?: Function): Socket;
+    export function createConnection(path: string, connectionListener?: Function): Socket;
+    export function isIP(input: string): number;
+    export function isIPv4(input: string): boolean;
+    export function isIPv6(input: string): boolean;
+}
+
+declare module "dgram" {
+    import events = require("events");
+
+    export function createSocket(type: string, callback?: Function): Socket;
+
+    interface Socket extends NodeEventEmitter {
+        send(buf: NodeBuffer, offset: number, length: number, port: number, address: string, callback?: Function): void;
+        bind(port: number, address?: string): void;
+        close(): void;
+        address: { address: string; family: string; port: number; };
+        setBroadcast(flag: boolean): void;
+        setMulticastTTL(ttl: number): void;
+        setMulticastLoopback(flag: boolean): void;
+        addMembership(multicastAddress: string, multicastInterface?: string): void;
+        dropMembership(multicastAddress: string, multicastInterface?: string): void;
+    }
+}
+
+declare module "fs" {
+    import stream = require("stream");
+
+    interface Stats {
+        isFile(): boolean;
+        isDirectory(): boolean;
+        isBlockDevice(): boolean;
+        isCharacterDevice(): boolean;
+        isSymbolicLink(): boolean;
+        isFIFO(): boolean;
+        isSocket(): boolean;
+        dev: number;
+        ino: number;
+        mode: number;
+        nlink: number;
+        uid: number;
+        gid: number;
+        rdev: number;
+        size: number;
+        blksize: number;
+        blocks: number;
+        atime: Date;
+        mtime: Date;
+        ctime: Date;
     }
 
-
-    // ---------- "fs" module ----------
-    export interface Fs {
-        rename(oldPath: string, newPath: string, callback?: (err?: ErrnoException) => void): void;
-        renameSync(oldPath: string, newPath: string): void;
-        truncate(path: string, callback?: (err?: ErrnoException) => void): void;
-        truncate(path: string, len: number, callback?: (err?: ErrnoException) => void): void;
-        truncateSync(path: string, len?: number): void;
-        ftruncate(fd: number, callback?: (err?: ErrnoException) => void): void;
-        ftruncate(fd: number, len: number, callback?: (err?: ErrnoException) => void): void;
-        ftruncateSync(fd: number, len?: number): void;
-        chown(path: string, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
-        chownSync(path: string, uid: number, gid: number): void;
-        fchown(fd: number, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
-        fchownSync(fd: number, uid: number, gid: number): void;
-        lchown(path: string, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
-        lchownSync(path: string, uid: number, gid: number): void;
-        chmod(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
-        chmod(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
-        chmodSync(path: string, mode: number): void;
-        chmodSync(path: string, mode: string): void;
-        fchmod(fd: number, mode: number, callback?: (err?: ErrnoException) => void): void;
-        fchmod(fd: number, mode: string, callback?: (err?: ErrnoException) => void): void;
-        fchmodSync(fd: number, mode: number): void;
-        fchmodSync(fd: number, mode: string): void;
-        lchmod(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
-        lchmod(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
-        lchmodSync(path: string, mode: number): void;
-        lchmodSync(path: string, mode: string): void;
-        stat(path: string, callback?: (err: ErrnoException, stats: Fs.Stats) => any): void;
-        lstat(path: string, callback?: (err: ErrnoException, stats: Fs.Stats) => any): void;
-        fstat(fd: number, callback?: (err: ErrnoException, stats: Fs.Stats) => any): void;
-        statSync(path: string): Fs.Stats;
-        lstatSync(path: string): Fs.Stats;
-        fstatSync(fd: number): Fs.Stats;
-        link(srcpath: string, dstpath: string, callback?: (err?: ErrnoException) => void): void;
-        linkSync(srcpath: string, dstpath: string): void;
-        symlink(srcpath: string, dstpath: string, type?: string, callback?: (err?: ErrnoException) => void): void;
-        symlinkSync(srcpath: string, dstpath: string, type?: string): void;
-        readlink(path: string, callback?: (err: ErrnoException, linkString: string) => any): void;
-        readlinkSync(path: string): string;
-        realpath(path: string, callback?: (err: ErrnoException, resolvedPath: string) => any): void;
-        realpath(path: string, cache: {[path: string]: string}, callback: (err: ErrnoException, resolvedPath: string) =>any): void;
-        realpathSync(path: string, cache?: {[path: string]: string}): string;
-        unlink(path: string, callback?: (err?: ErrnoException) => void): void;
-        unlinkSync(path: string): void;
-        rmdir(path: string, callback?: (err?: ErrnoException) => void): void;
-        rmdirSync(path: string): void;
-        mkdir(path: string, callback?: (err?: ErrnoException) => void): void;
-        mkdir(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
-        mkdir(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
-        mkdirSync(path: string, mode?: number): void;
-        mkdirSync(path: string, mode?: string): void;
-        readdir(path: string, callback?: (err: ErrnoException, files: string[]) => void): void;
-        readdirSync(path: string): string[];
-        close(fd: number, callback?: (err?: ErrnoException) => void): void;
-        closeSync(fd: number): void;
-        open(path: string, flags: string, callback?: (err: ErrnoException, fd: number) => any): void;
-        open(path: string, flags: string, mode: number, callback?: (err: ErrnoException, fd: number) => any): void;
-        open(path: string, flags: string, mode: string, callback?: (err: ErrnoException, fd: number) => any): void;
-        openSync(path: string, flags: string, mode?: number): number;
-        openSync(path: string, flags: string, mode?: string): number;
-        utimes(path: string, atime: number, mtime: number, callback?: (err?: ErrnoException) => void): void;
-        utimesSync(path: string, atime: number, mtime: number): void;
-        futimes(fd: number, atime: number, mtime: number, callback?: (err?: ErrnoException) => void): void;
-        futimesSync(fd: number, atime: number, mtime: number): void;
-        fsync(fd: number, callback?: (err?: ErrnoException) => void): void;
-        fsyncSync(fd: number): void;
-        write(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, written: number, buffer: NodeBuffer) => void): void;
-        writeSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
-        read(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, bytesRead: number, buffer: NodeBuffer) => void): void;
-        readSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
-        readFile(filename: string, encoding: string, callback: (err: ErrnoException, data: string) => void): void;
-        readFile(filename: string, options: { encoding: string; flag?: string; }, callback: (err: ErrnoException, data: string) => void): void;
-        readFile(filename: string, options: { flag?: string; }, callback: (err: ErrnoException, data: NodeBuffer) => void): void;
-        readFile(filename: string, callback: (err: ErrnoException, data: NodeBuffer) => void ): void;
-        readFileSync(filename: string, encoding: string): string;
-        readFileSync(filename: string, options: { encoding: string; flag?: string; }): string;
-        readFileSync(filename: string, options?: { flag?: string; }): NodeBuffer;
-        writeFile(filename: string, data: any, callback?: (err: ErrnoException) => void): void;
-        writeFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: ErrnoException) => void): void;
-        writeFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void;
-        writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
-        writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void;
-        appendFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: ErrnoException) => void): void;
-        appendFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void;
-        appendFile(filename: string, data: any, callback?: (err: ErrnoException) => void): void;
-        appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
-        appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void;
-        watchFile(filename: string, listener: (curr: Fs.Stats, prev: Fs.Stats) => void): void;
-        watchFile(filename: string, options: { persistent?: boolean; interval?: number; }, listener: (curr: Fs.Stats, prev: Fs.Stats) => void): void;
-        unwatchFile(filename: string, listener?: (curr: Fs.Stats, prev: Fs.Stats) => void): void;
-        watch(filename: string, listener?: (event: string, filename: string) => any): Fs.FSWatcher;
-        watch(filename: string, options: { persistent?: boolean; }, listener?: (event: string, filename: string) => any): Fs.FSWatcher;
-        exists(path: string, callback?: (exists: boolean) => void): void;
-        existsSync(path: string): boolean;
-        createReadStream(path: string, options?: {
-            flags?: string;
-            encoding?: string;
-            fd?: string;
-            mode?: number;
-            bufferSize?: number;
-        }): Fs.ReadStream;
-        createReadStream(path: string, options?: {
-            flags?: string;
-            encoding?: string;
-            fd?: string;
-            mode?: string;
-            bufferSize?: number;
-        }): Fs.ReadStream;
-        createWriteStream(path: string, options?: {
-            flags?: string;
-            encoding?: string;
-            string?: string;
-        }): Fs.WriteStream;
-    }
-    export module Fs {
-        export interface Stats {
-            isFile(): boolean;
-            isDirectory(): boolean;
-            isBlockDevice(): boolean;
-            isCharacterDevice(): boolean;
-            isSymbolicLink(): boolean;
-            isFIFO(): boolean;
-            isSocket(): boolean;
-            dev: number;
-            ino: number;
-            mode: number;
-            nlink: number;
-            uid: number;
-            gid: number;
-            rdev: number;
-            size: number;
-            blksize: number;
-            blocks: number;
-            atime: Date;
-            mtime: Date;
-            ctime: Date;
-        }
-        export interface FSWatcher extends NodeEventEmitter {
-            close(): void;
-        }
-        export interface ReadStream extends ReadableStream { }
-        export interface WriteStream extends WritableStream { }
+    interface FSWatcher extends NodeEventEmitter {
+        close(): void;
     }
 
+    export interface ReadStream extends ReadableStream { }
+    export interface WriteStream extends WritableStream { }
 
-    // ---------- "path" module ----------
-    export interface Path {
-        normalize(p: string): string;
-        join(...paths: any[]): string;
-        resolve(...pathSegments: any[]): string;
-        relative(from: string, to: string): string;
-        dirname(p: string): string;
-        basename(p: string, ext?: string): string;
-        extname(p: string): string;
-        sep: string;
+    export function rename(oldPath: string, newPath: string, callback?: (err?: ErrnoException) => void): void;
+    export function renameSync(oldPath: string, newPath: string): void;
+    export function truncate(path: string, callback?: (err?: ErrnoException) => void): void;
+    export function truncate(path: string, len: number, callback?: (err?: ErrnoException) => void): void;
+    export function truncateSync(path: string, len?: number): void;
+    export function ftruncate(fd: number, callback?: (err?: ErrnoException) => void): void;
+    export function ftruncate(fd: number, len: number, callback?: (err?: ErrnoException) => void): void;
+    export function ftruncateSync(fd: number, len?: number): void;
+    export function chown(path: string, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
+    export function chownSync(path: string, uid: number, gid: number): void;
+    export function fchown(fd: number, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
+    export function fchownSync(fd: number, uid: number, gid: number): void;
+    export function lchown(path: string, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void;
+    export function lchownSync(path: string, uid: number, gid: number): void;
+    export function chmod(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
+    export function chmod(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
+    export function chmodSync(path: string, mode: number): void;
+    export function chmodSync(path: string, mode: string): void;
+    export function fchmod(fd: number, mode: number, callback?: (err?: ErrnoException) => void): void;
+    export function fchmod(fd: number, mode: string, callback?: (err?: ErrnoException) => void): void;
+    export function fchmodSync(fd: number, mode: number): void;
+    export function fchmodSync(fd: number, mode: string): void;
+    export function lchmod(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
+    export function lchmod(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
+    export function lchmodSync(path: string, mode: number): void;
+    export function lchmodSync(path: string, mode: string): void;
+    export function stat(path: string, callback?: (err: ErrnoException, stats: Stats) => any): void;
+    export function lstat(path: string, callback?: (err: ErrnoException, stats: Stats) => any): void;
+    export function fstat(fd: number, callback?: (err: ErrnoException, stats: Stats) => any): void;
+    export function statSync(path: string): Stats;
+    export function lstatSync(path: string): Stats;
+    export function fstatSync(fd: number): Stats;
+    export function link(srcpath: string, dstpath: string, callback?: (err?: ErrnoException) => void): void;
+    export function linkSync(srcpath: string, dstpath: string): void;
+    export function symlink(srcpath: string, dstpath: string, type?: string, callback?: (err?: ErrnoException) => void): void;
+    export function symlinkSync(srcpath: string, dstpath: string, type?: string): void;
+    export function readlink(path: string, callback?: (err: ErrnoException, linkString: string) => any): void;
+    export function readlinkSync(path: string): string;
+    export function realpath(path: string, callback?: (err: ErrnoException, resolvedPath: string) => any): void;
+    export function realpath(path: string, cache: {[path: string]: string}, callback: (err: ErrnoException, resolvedPath: string) =>any): void;
+    export function realpathSync(path: string, cache?: {[path: string]: string}): void;
+    export function unlink(path: string, callback?: (err?: ErrnoException) => void): void;
+    export function unlinkSync(path: string): void;
+    export function rmdir(path: string, callback?: (err?: ErrnoException) => void): void;
+    export function rmdirSync(path: string): void;
+    export function mkdir(path: string, callback?: (err?: ErrnoException) => void): void;
+    export function mkdir(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
+    export function mkdir(path: string, mode: string, callback?: (err?: ErrnoException) => void): void;
+    export function mkdirSync(path: string, mode?: number): void;
+    export function mkdirSync(path: string, mode?: string): void;
+    export function readdir(path: string, callback?: (err: ErrnoException, files: string[]) => void): void;
+    export function readdirSync(path: string): string[];
+    export function close(fd: number, callback?: (err?: ErrnoException) => void): void;
+    export function closeSync(fd: number): void;
+    export function open(path: string, flags: string, callback?: (err: ErrnoException, fd: number) => any): void;
+    export function open(path: string, flags: string, mode: number, callback?: (err: ErrnoException, fd: number) => any): void;
+    export function open(path: string, flags: string, mode: string, callback?: (err: ErrnoException, fd: number) => any): void;
+    export function openSync(path: string, flags: string, mode?: number): number;
+    export function openSync(path: string, flags: string, mode?: string): number;
+    export function utimes(path: string, atime: number, mtime: number, callback?: (err?: ErrnoException) => void): void;
+    export function utimesSync(path: string, atime: number, mtime: number): void;
+    export function futimes(fd: number, atime: number, mtime: number, callback?: (err?: ErrnoException) => void): void;
+    export function futimesSync(fd: number, atime: number, mtime: number): void;
+    export function fsync(fd: number, callback?: (err?: ErrnoException) => void): void;
+    export function fsyncSync(fd: number): void;
+    export function write(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, written: number, buffer: NodeBuffer) => void): void;
+    export function writeSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
+    export function read(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, bytesRead: number, buffer: NodeBuffer) => void): void;
+    export function readSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
+    export function readFile(filename: string, encoding: string, callback: (err: ErrnoException, data: string) => void): void;
+    export function readFile(filename: string, options: { encoding: string; flag?: string; }, callback: (err: ErrnoException, data: string) => void): void;
+    export function readFile(filename: string, options: { flag?: string; }, callback: (err: ErrnoException, data: NodeBuffer) => void): void;
+    export function readFile(filename: string, callback: (err: ErrnoException, data: NodeBuffer) => void ): void;
+    export function readFileSync(filename: string, encoding: string): string;
+    export function readFileSync(filename: string, options: { encoding: string; flag?: string; }): string;
+    export function readFileSync(filename: string, options?: { flag?: string; }): NodeBuffer;
+    export function writeFile(filename: string, data: any, callback?: (err: ErrnoException) => void): void;
+    export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: ErrnoException) => void): void;
+    export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void;
+    export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
+    export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void;
+    export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: ErrnoException) => void): void;
+    export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void;
+    export function appendFile(filename: string, data: any, callback?: (err: ErrnoException) => void): void;
+    export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
+    export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void;
+    export function watchFile(filename: string, listener: (curr: Stats, prev: Stats) => void): void;
+    export function watchFile(filename: string, options: { persistent?: boolean; interval?: number; }, listener: (curr: Stats, prev: Stats) => void): void;
+    export function unwatchFile(filename: string, listener?: (curr: Stats, prev: Stats) => void): void;
+    export function watch(filename: string, listener?: (event: string, filename: string) => any): FSWatcher;
+    export function watch(filename: string, options: { persistent?: boolean; }, listener?: (event: string, filename: string) => any): FSWatcher;
+    export function exists(path: string, callback?: (exists: boolean) => void): void;
+    export function existsSync(path: string): boolean;
+    export function createReadStream(path: string, options?: {
+        flags?: string;
+        encoding?: string;
+        fd?: string;
+        mode?: number;
+        bufferSize?: number;
+    }): ReadStream;
+    export function createReadStream(path: string, options?: {
+        flags?: string;
+        encoding?: string;
+        fd?: string;
+        mode?: string;
+        bufferSize?: number;
+    }): ReadStream;
+    export function createWriteStream(path: string, options?: {
+        flags?: string;
+        encoding?: string;
+        string?: string;
+    }): WriteStream;
+}
+
+declare module "path" {
+    export function normalize(p: string): string;
+    export function join(...paths: any[]): string;
+    export function resolve(...pathSegments: any[]): string;
+    export function relative(from: string, to: string): string;
+    export function dirname(p: string): string;
+    export function basename(p: string, ext?: string): string;
+    export function extname(p: string): string;
+    export var sep: string;
+}
+
+declare module "string_decoder" {
+    export interface NodeStringDecoder {
+        write(buffer: NodeBuffer): string;
+        detectIncompleteChar(buffer: NodeBuffer): number;
+    }
+    export var StringDecoder: {
+        new (encoding: string): NodeStringDecoder;
+    };
+}
+
+declare module "tls" {
+    import crypto = require("crypto");
+    import net = require("net");
+    import stream = require("stream");
+
+    var CLIENT_RENEG_LIMIT: number;
+    var CLIENT_RENEG_WINDOW: number;
+
+    export interface TlsOptions {
+        pfx?: any;   //string or buffer
+        key?: any;   //string or buffer
+        passphrase?: string;
+        cert?: any;
+        ca?: any;    //string or buffer
+        crl?: any;   //string or string array
+        ciphers?: string;
+        honorCipherOrder?: any;
+        requestCert?: boolean;
+        rejectUnauthorized?: boolean;
+        NPNProtocols?: any;  //array or Buffer;
+        SNICallback?: (servername: string) => any;
     }
 
-
-    // ---------- "string_decoder" module ----------
-    export interface StringDecoder {
-        StringDecoder: new(encoding: string) => StringDecoder.StringDecoder;
-    }
-    export module StringDecoder {
-        export interface StringDecoder {
-            write(buffer: NodeBuffer): string;
-            detectIncompleteChar(buffer: NodeBuffer): number;
-        }
+    export interface ConnectionOptions {
+        host?: string;
+        port?: number;
+        socket?: net.Socket;
+        pfx?: any;   //string | Buffer
+        key?: any;   //string | Buffer
+        passphrase?: string;
+        cert?: any;  //string | Buffer
+        ca?: any;    //Array of string | Buffer
+        rejectUnauthorized?: boolean;
+        NPNProtocols?: any;  //Array of string | Buffer
+        servername?: string;
     }
 
+    export interface Server extends net.Server {
+        // Extended base methods
+        listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
+        listen(path: string, listeningListener?: Function): void;
+        listen(handle: any, listeningListener?: Function): void;
 
-    // ---------- "tls" module ----------
-    export interface Tls {
-        CLIENT_RENEG_LIMIT: number;
-        CLIENT_RENEG_WINDOW: number;
-        createServer(options: Tls.TlsOptions, secureConnectionListener?: (cleartextStream: Tls.ClearTextStream) =>void ): Tls.Server;
-        connect(options: Tls.TlsOptions, secureConnectionListener?: () =>void ): Tls.ClearTextStream;
-        connect(port: number, host?: string, options?: Tls.ConnectionOptions, secureConnectListener?: () =>void ): Tls.ClearTextStream;
-        connect(port: number, options?: Tls.ConnectionOptions, secureConnectListener?: () =>void ): Tls.ClearTextStream;
-        createSecurePair(credentials?: Crypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): Tls.SecurePair;
-    }
-    export module Tls {
-        export interface TlsOptions {
-            pfx?: any;   //string or buffer
-            key?: any;   //string or buffer
-            passphrase?: string;
-            cert?: any;
-            ca?: any;    //string or buffer
-            crl?: any;   //string or string array
-            ciphers?: string;
-            honorCipherOrder?: any;
-            requestCert?: boolean;
-            rejectUnauthorized?: boolean;
-            NPNProtocols?: any;  //array or Buffer;
-            SNICallback?: (servername: string) => any;
-        }
-        export interface ConnectionOptions {
-            host?: string;
-            port?: number;
-            socket?: Net.Socket;
-            pfx?: any;   //string | Buffer
-            key?: any;   //string | Buffer
-            passphrase?: string;
-            cert?: any;  //string | Buffer
-            ca?: any;    //Array of string | Buffer
-            rejectUnauthorized?: boolean;
-            NPNProtocols?: any;  //Array of string | Buffer
-            servername?: string;
-        }
-        export interface Server extends Net.Server {
-            // Extended base methods
-            listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void;
-            listen(path: string, listeningListener?: Function): void;
-            listen(handle: any, listeningListener?: Function): void;
-
-            listen(port: number, host?: string, callback?: Function): void;
-            close(): void;
-            address(): { port: number; family: string; address: string; };
-            addContext(hostName: string, credentials: {
-                key: string;
-                cert: string;
-                ca: string;
-            }): void;
-            maxConnections: number;
-            connections: number;
-        }
-        export interface ClearTextStream extends ReadWriteStream {
-            authorized: boolean;
-            authorizationError: Error;
-            getPeerCertificate(): any;
-            getCipher: {
-                name: string;
-                version: string;
-            };
-            address: {
-                port: number;
-                family: string;
-                address: string;
-            };
-            remoteAddress: string;
-            remotePort: number;
-        }
-        export interface SecurePair {
-            encrypted: any;
-            cleartext: any;
-        }
-    }
-
-
-    // ---------- "crypto" module ----------
-    export interface Crypto {
-        createCredentials(details: Crypto.CredentialDetails): Crypto.Credentials;
-        createHash(algorithm: string): Crypto.Hash;
-        createHmac(algorithm: string, key: string): Crypto.Hmac;
-        createCipher(algorithm: string, password: any): Crypto.Cipher;
-        createCipheriv(algorithm: string, key: any, iv: any): Crypto.Cipher;
-        createSign(algorithm: string): Crypto.Signer;
-        createVerify(algorith: string): Crypto.Verify;
-        createDiffieHellman(prime_length: number): Crypto.DiffieHellman;
-        createDiffieHellman(prime: number, encoding?: string): Crypto.DiffieHellman;
-        getDiffieHellman(group_name: string): Crypto.DiffieHellman;
-        pbkdf2(password: string, salt: string, iterations: number, keylen: number, callback: (err: Error, derivedKey: string) => any): void;
-        randomBytes(size: number): NodeBuffer;
-        randomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
-        pseudoRandomBytes(size: number): NodeBuffer;
-        pseudoRandomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
-    }
-    export module Crypto {
-        export interface CredentialDetails {
-            pfx: string;
+        listen(port: number, host?: string, callback?: Function): void;
+        close(): void;
+        address(): { port: number; family: string; address: string; };
+        addContext(hostName: string, credentials: {
             key: string;
-            passphrase: string;
             cert: string;
-            ca: any;    //string | string array
-            crl: any;   //string | string array
-            ciphers: string;
-        }
-        export interface Credentials { context?: any; }
-        export interface Hash {
-            update(data: any, input_encoding?: string): Hash;
-            digest(encoding?: string): string;
-        }
-        export interface Hmac {
-            update(data: any): void;
-            digest(encoding?: string): void;
-        }
-        export interface Cipher {
-            update(data: any, input_encoding?: string, output_encoding?: string): string;
-            final(output_encoding?: string): string;
-            setAutoPadding(auto_padding: boolean): void;
-            createDecipher(algorithm: string, password: any): Decipher;
-            createDecipheriv(algorithm: string, key: any, iv: any): Decipher;
-        }
-        export interface Decipher {
-            update(data: any, input_encoding?: string, output_encoding?: string): void;
-            final(output_encoding?: string): string;
-            setAutoPadding(auto_padding: boolean): void;
-        }
-        export interface Signer {
-            update(data: any): void;
-            sign(private_key: string, output_format: string): string;
-        }
-        export interface Verify {
-            update(data: any): void;
-            verify(object: string, signature: string, signature_format?: string): boolean;
-        }
-        export interface DiffieHellman {
-            generateKeys(encoding?: string): string;
-            computeSecret(other_public_key: string, input_encoding?: string, output_encoding?: string): string;
-            getPrime(encoding?: string): string;
-            getGenerator(encoding: string): string;
-            getPublicKey(encoding?: string): string;
-            getPrivateKey(encoding?: string): string;
-            setPublicKey(public_key: string, encoding?: string): void;
-            setPrivateKey(public_key: string, encoding?: string): void;
-        }
+            ca: string;
+        }): void;
+        maxConnections: number;
+        connections: number;
     }
 
-
-    // ---------- "stream" module ----------
-    export interface Stream {
-        Readable: new(opts?: Stream.ReadableOptions) => Stream.Readable;
-        Writable: new(opts?: Stream.WritableOptions) => Stream.Writable;
-        Duplex: new(opts?: Stream.DuplexOptions) => Stream.Duplex;
-        Transform: new(opts?: Stream.TransformOptions) => Stream.Transform;
-    }
-    export module Stream {
-        export interface ReadableOptions {
-            highWaterMark?: number;
-            encoding?: string;
-            objectMode?: boolean;
-        }
-        export interface Readable extends Events.EventEmitter, ReadableStream {
-            readable: boolean;
-            _read(size: number): void;
-            read(size?: number): any;
-            setEncoding(encoding: string): void;
-            pause(): void;
-            resume(): void;
-            pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
-            unpipe<T extends WritableStream>(destination?: T): void;
-            unshift(chunk: string): void;
-            unshift(chunk: NodeBuffer): void;
-            wrap(oldStream: ReadableStream): ReadableStream;
-            push(chunk: any, encoding?: string): boolean;
-        }
-        export interface WritableOptions {
-            highWaterMark?: number;
-            decodeStrings?: boolean;
-        }
-        export interface Writable extends Events.EventEmitter, WritableStream {
-            writable: boolean;
-            _write(data: NodeBuffer, encoding: string, callback: Function): void;
-            _write(data: string, encoding: string, callback: Function): void;
-            write(buffer: NodeBuffer, cb?: Function): boolean;
-            write(str: string, cb?: Function): boolean;
-            write(str: string, encoding?: string, cb?: Function): boolean;
-            end(): void;
-            end(buffer: NodeBuffer, cb?: Function): void;
-            end(str: string, cb?: Function): void;
-            end(str: string, encoding?: string, cb?: Function): void;
-        }
-        export interface DuplexOptions extends ReadableOptions, WritableOptions {
-            allowHalfOpen?: boolean;
-        }
-
-        // Note: Duplex extends both Readable and Writable.
-        export interface Duplex extends Readable, ReadWriteStream {
-            writable: boolean;
-            _write(data: NodeBuffer, encoding: string, callback: Function): void;
-            _write(data: string, encoding: string, callback: Function): void;
-            write(buffer: NodeBuffer, cb?: Function): boolean;
-            write(str: string, cb?: Function): boolean;
-            write(str: string, encoding?: string, cb?: Function): boolean;
-            end(): void;
-            end(buffer: NodeBuffer, cb?: Function): void;
-            end(str: string, cb?: Function): void;
-            end(str: string, encoding?: string, cb?: Function): void;
-        }
-        export interface TransformOptions extends ReadableOptions, WritableOptions {}
-
-        // Note: Transform lacks the _read and _write methods of Readable/Writable.
-        export interface Transform extends Events.EventEmitter, ReadWriteStream {
-            readable: boolean;
-            writable: boolean;
-            _transform(chunk: NodeBuffer, encoding: string, callback: Function): void;
-            _transform(chunk: string, encoding: string, callback: Function): void;
-            _flush(callback: Function): void;
-            read(size?: number): any;
-            setEncoding(encoding: string): void;
-            pause(): void;
-            resume(): void;
-            pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
-            unpipe<T extends WritableStream>(destination?: T): void;
-            unshift(chunk: string): void;
-            unshift(chunk: NodeBuffer): void;
-            wrap(oldStream: ReadableStream): ReadableStream;
-            push(chunk: any, encoding?: string): boolean;
-            write(buffer: NodeBuffer, cb?: Function): boolean;
-            write(str: string, cb?: Function): boolean;
-            write(str: string, encoding?: string, cb?: Function): boolean;
-            end(): void;
-            end(buffer: NodeBuffer, cb?: Function): void;
-            end(str: string, cb?: Function): void;
-            end(str: string, encoding?: string, cb?: Function): void;
-        }
-        export interface PassThrough extends Transform {}
+    export interface ClearTextStream extends ReadWriteStream {
+        authorized: boolean;
+        authorizationError: Error;
+        getPeerCertificate(): any;
+        getCipher: {
+            name: string;
+            version: string;
+        };
+        address: {
+            port: number;
+            family: string;
+            address: string;
+        };
+        remoteAddress: string;
+        remotePort: number;
     }
 
-
-    // ---------- "util" module ----------
-    export interface Util {
-        format(format: any, ...param: any[]): string;
-        debug(string: string): void;
-        error(...param: any[]): void;
-        puts(...param: any[]): void;
-        print(...param: any[]): void;
-        log(string: string): void;
-        inspect(object: any, showHidden?: boolean, depth?: number, color?: boolean): string;
-        inspect(object: any, options: Util.InspectOptions): string;
-        isArray(object: any): boolean;
-        isRegExp(object: any): boolean;
-        isDate(object: any): boolean;
-        isError(object: any): boolean;
-        inherits(constructor: any, superConstructor: any): void;
-    }
-    export module Util {
-        export interface InspectOptions {
-            showHidden?: boolean;
-            depth?: number;
-            colors?: boolean;
-            customInspect?: boolean;
-        }
+    export interface SecurePair {
+        encrypted: any;
+        cleartext: any;
     }
 
+    export function createServer(options: TlsOptions, secureConnectionListener?: (cleartextStream: ClearTextStream) =>void ): Server;
+    export function connect(options: TlsOptions, secureConnectionListener?: () =>void ): ClearTextStream;
+    export function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
+    export function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
+    export function createSecurePair(credentials?: crypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
+}
 
-    // ---------- "assert" module ----------
-    export interface Assert {
-        (value: any, message?: string): void;
-        AssertionError: new(options?: Assert.AssertionErrorOptions) => Assert.AssertionError;
-
-        fail(actual?: any, expected?: any, message?: string, operator?: string): void;
-        ok(value: any, message?: string): void;
-        equal(actual: any, expected: any, message?: string): void;
-        notEqual(actual: any, expected: any, message?: string): void;
-        deepEqual(actual: any, expected: any, message?: string): void;
-        notDeepEqual(acutal: any, expected: any, message?: string): void;
-        strictEqual(actual: any, expected: any, message?: string): void;
-        notStrictEqual(actual: any, expected: any, message?: string): void;
-        throws: {
-            (block: Function, message?: string): void;
-            (block: Function, error: Function, message?: string): void;
-            (block: Function, error: RegExp, message?: string): void;
-            (block: Function, error: (err: any) => boolean, message?: string): void;
-        }
-        doesNotThrow: {
-            (block: Function, message?: string): void;
-            (block: Function, error: Function, message?: string): void;
-            (block: Function, error: RegExp, message?: string): void;
-            (block: Function, error: (err: any) => boolean, message?: string): void;
-        }
-        ifError(value: any): void;
+declare module "crypto" {
+    export interface CredentialDetails {
+        pfx: string;
+        key: string;
+        passphrase: string;
+        cert: string;
+        ca: any;    //string | string array
+        crl: any;   //string | string array
+        ciphers: string;
     }
-    export module Assert {
-        export interface AssertionErrorOptions {
-            message?: string;
-            actual?: any;
-            expected?: any;
-            operator?: string;
-            stackStartFunction?: Function
-        }
-        export interface AssertionError extends Error {
+    export interface Credentials { context?: any; }
+    export function createCredentials(details: CredentialDetails): Credentials;
+    export function createHash(algorithm: string): Hash;
+    export function createHmac(algorithm: string, key: string): Hmac;
+    interface Hash {
+        update(data: any, input_encoding?: string): Hash;
+        digest(encoding?: string): string;
+    }
+    interface Hmac {
+        update(data: any): void;
+        digest(encoding?: string): void;
+    }
+    export function createCipher(algorithm: string, password: any): Cipher;
+    export function createCipheriv(algorithm: string, key: any, iv: any): Cipher;
+    interface Cipher {
+        update(data: any, input_encoding?: string, output_encoding?: string): string;
+        final(output_encoding?: string): string;
+        setAutoPadding(auto_padding: boolean): void;
+        createDecipher(algorithm: string, password: any): Decipher;
+        createDecipheriv(algorithm: string, key: any, iv: any): Decipher;
+    }
+    interface Decipher {
+        update(data: any, input_encoding?: string, output_encoding?: string): void;
+        final(output_encoding?: string): string;
+        setAutoPadding(auto_padding: boolean): void;
+    }
+    export function createSign(algorithm: string): Signer;
+    interface Signer {
+        update(data: any): void;
+        sign(private_key: string, output_format: string): string;
+    }
+    export function createVerify(algorith: string): Verify;
+    interface Verify {
+        update(data: any): void;
+        verify(object: string, signature: string, signature_format?: string): boolean;
+    }
+    export function createDiffieHellman(prime_length: number): DiffieHellman;
+    export function createDiffieHellman(prime: number, encoding?: string): DiffieHellman;
+    interface DiffieHellman {
+        generateKeys(encoding?: string): string;
+        computeSecret(other_public_key: string, input_encoding?: string, output_encoding?: string): string;
+        getPrime(encoding?: string): string;
+        getGenerator(encoding: string): string;
+        getPublicKey(encoding?: string): string;
+        getPrivateKey(encoding?: string): string;
+        setPublicKey(public_key: string, encoding?: string): void;
+        setPrivateKey(public_key: string, encoding?: string): void;
+    }
+    export function getDiffieHellman(group_name: string): DiffieHellman;
+    export function pbkdf2(password: string, salt: string, iterations: number, keylen: number, callback: (err: Error, derivedKey: string) => any): void;
+    export function randomBytes(size: number): NodeBuffer;
+    export function randomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
+    export function pseudoRandomBytes(size: number): NodeBuffer;
+    export function pseudoRandomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
+}
+
+declare module "stream" {
+    import events = require("events");
+
+    export interface ReadableOptions {
+        highWaterMark?: number;
+        encoding?: string;
+        objectMode?: boolean;
+    }
+
+    export class Readable extends events.EventEmitter implements ReadableStream {
+        readable: boolean;
+        constructor(opts?: ReadableOptions);
+        _read(size: number): void;
+        read(size?: number): any;
+        setEncoding(encoding: string): void;
+        pause(): void;
+        resume(): void;
+        pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
+        unpipe<T extends WritableStream>(destination?: T): void;
+        unshift(chunk: string): void;
+        unshift(chunk: NodeBuffer): void;
+        wrap(oldStream: ReadableStream): ReadableStream;
+        push(chunk: any, encoding?: string): boolean;
+    }
+
+    export interface WritableOptions {
+        highWaterMark?: number;
+        decodeStrings?: boolean;
+    }
+
+    export class Writable extends events.EventEmitter implements WritableStream {
+        writable: boolean;
+        constructor(opts?: WritableOptions);
+        _write(data: NodeBuffer, encoding: string, callback: Function): void;
+        _write(data: string, encoding: string, callback: Function): void;
+        write(buffer: NodeBuffer, cb?: Function): boolean;
+        write(str: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, cb?: Function): boolean;
+        end(): void;
+        end(buffer: NodeBuffer, cb?: Function): void;
+        end(str: string, cb?: Function): void;
+        end(str: string, encoding?: string, cb?: Function): void;
+    }
+
+    export interface DuplexOptions extends ReadableOptions, WritableOptions {
+        allowHalfOpen?: boolean;
+    }
+
+    // Note: Duplex extends both Readable and Writable.
+    export class Duplex extends Readable implements ReadWriteStream {
+        writable: boolean;
+        constructor(opts?: DuplexOptions);
+        _write(data: NodeBuffer, encoding: string, callback: Function): void;
+        _write(data: string, encoding: string, callback: Function): void;
+        write(buffer: NodeBuffer, cb?: Function): boolean;
+        write(str: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, cb?: Function): boolean;
+        end(): void;
+        end(buffer: NodeBuffer, cb?: Function): void;
+        end(str: string, cb?: Function): void;
+        end(str: string, encoding?: string, cb?: Function): void;
+    }
+
+    export interface TransformOptions extends ReadableOptions, WritableOptions {}
+
+    // Note: Transform lacks the _read and _write methods of Readable/Writable.
+    export class Transform extends events.EventEmitter implements ReadWriteStream {
+        readable: boolean;
+        writable: boolean;
+        constructor(opts?: TransformOptions);
+        _transform(chunk: NodeBuffer, encoding: string, callback: Function): void;
+        _transform(chunk: string, encoding: string, callback: Function): void;
+        _flush(callback: Function): void;
+        read(size?: number): any;
+        setEncoding(encoding: string): void;
+        pause(): void;
+        resume(): void;
+        pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
+        unpipe<T extends WritableStream>(destination?: T): void;
+        unshift(chunk: string): void;
+        unshift(chunk: NodeBuffer): void;
+        wrap(oldStream: ReadableStream): ReadableStream;
+        push(chunk: any, encoding?: string): boolean;
+        write(buffer: NodeBuffer, cb?: Function): boolean;
+        write(str: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, cb?: Function): boolean;
+        end(): void;
+        end(buffer: NodeBuffer, cb?: Function): void;
+        end(str: string, cb?: Function): void;
+        end(str: string, encoding?: string, cb?: Function): void;
+    }
+
+    export class PassThrough extends Transform {}
+}
+
+declare module "util" {
+    export interface InspectOptions {
+        showHidden?: boolean;
+        depth?: number;
+        colors?: boolean;
+        customInspect?: boolean;
+    }
+
+    export function format(format: any, ...param: any[]): string;
+    export function debug(string: string): void;
+    export function error(...param: any[]): void;
+    export function puts(...param: any[]): void;
+    export function print(...param: any[]): void;
+    export function log(string: string): void;
+    export function inspect(object: any, showHidden?: boolean, depth?: number, color?: boolean): string;
+    export function inspect(object: any, options: InspectOptions): string;
+    export function isArray(object: any): boolean;
+    export function isRegExp(object: any): boolean;
+    export function isDate(object: any): boolean;
+    export function isError(object: any): boolean;
+    export function inherits(constructor: any, superConstructor: any): void;
+}
+
+declare module "assert" {
+    function internal (value: any, message?: string): void;
+    module internal {
+        export class AssertionError implements Error {
             name: string;
             message: string;
             actual: any;
             expected: any;
             operator: string;
             generatedMessage: boolean;
+
+            constructor(options?: {message?: string; actual?: any; expected?: any;
+                                  operator?: string; stackStartFunction?: Function});
         }
+
+        export function fail(actual?: any, expected?: any, message?: string, operator?: string): void;
+        export function ok(value: any, message?: string): void;
+        export function equal(actual: any, expected: any, message?: string): void;
+        export function notEqual(actual: any, expected: any, message?: string): void;
+        export function deepEqual(actual: any, expected: any, message?: string): void;
+        export function notDeepEqual(acutal: any, expected: any, message?: string): void;
+        export function strictEqual(actual: any, expected: any, message?: string): void;
+        export function notStrictEqual(actual: any, expected: any, message?: string): void;
+        export var throws: {
+            (block: Function, message?: string): void;
+            (block: Function, error: Function, message?: string): void;
+            (block: Function, error: RegExp, message?: string): void;
+            (block: Function, error: (err: any) => boolean, message?: string): void;
+        }
+
+        export var doesNotThrow: {
+            (block: Function, message?: string): void;
+            (block: Function, error: Function, message?: string): void;
+            (block: Function, error: RegExp, message?: string): void;
+            (block: Function, error: (err: any) => boolean, message?: string): void;
+        }
+
+        export function ifError(value: any): void;
     }
 
+    export = internal;
+}
 
-    // ---------- "tty" module ----------
-    export interface Tty {
-        ReadStream: new() => Tty.ReadStream;
-        WriteStream: new() => Tty.WriteStream;
-        isatty(fd: number): boolean;
+declare module "tty" {
+    import net = require("net");
+
+    export function isatty(fd: number): boolean;
+    export interface ReadStream extends net.Socket {
+        isRaw: boolean;
+        setRawMode(mode: boolean): void;
     }
-    export module Tty {
-        export interface ReadStream extends Net.Socket {
-            isRaw: boolean;
-            setRawMode(mode: boolean): void;
-        }
-        export interface WriteStream extends Net.Socket {
-            columns: number;
-            rows: number;
-        }
-    }
-
-
-    // ---------- "domain" module ----------
-    export interface Domain {
-        Domain: new() => Domain.Domain;
-        create(): Domain.Domain;
-    }
-    export module Domain {
-        export interface Domain extends Events.EventEmitter {
-            run(fn: Function): void;
-            add(emitter: NodeEventEmitter): void;
-            remove(emitter: NodeEventEmitter): void;
-            bind(cb: (err: Error, data: any) => any): any;
-            intercept(cb: (data: any) => any): any;
-            dispose(): void;
-
-            addListener(event: string, listener: Function): Domain;
-            on(event: string, listener: Function): Domain;
-            once(event: string, listener: Function): Domain;
-            removeListener(event: string, listener: Function): Domain;
-            removeAllListeners(event?: string): Domain;
-        }
+    export interface WriteStream extends net.Socket {
+        columns: number;
+        rows: number;
     }
 }
+
+declare module "domain" {
+    import events = require("events");
+
+    export class Domain extends events.EventEmitter {
+        run(fn: Function): void;
+        add(emitter: NodeEventEmitter): void;
+        remove(emitter: NodeEventEmitter): void;
+        bind(cb: (err: Error, data: any) => any): any;
+        intercept(cb: (data: any) => any): any;
+        dispose(): void;
+
+        addListener(event: string, listener: Function): Domain;
+        on(event: string, listener: Function): Domain;
+        once(event: string, listener: Function): Domain;
+        removeListener(event: string, listener: Function): Domain;
+        removeAllListeners(event?: string): Domain;
+    }
+
+    export function create(): Domain;
+}

From d70401ed4d1eed89dc188d70fcd6139b34831fc3 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Mon, 31 Mar 2014 17:33:29 +0200
Subject: [PATCH 244/309] fixed realpathsync again

---
 node/node.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/node/node.d.ts b/node/node.d.ts
index 4fafb883e..c81d795bd 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -819,7 +819,7 @@ declare module "fs" {
     export function readlinkSync(path: string): string;
     export function realpath(path: string, callback?: (err: ErrnoException, resolvedPath: string) => any): void;
     export function realpath(path: string, cache: {[path: string]: string}, callback: (err: ErrnoException, resolvedPath: string) =>any): void;
-    export function realpathSync(path: string, cache?: {[path: string]: string}): void;
+    export function realpathSync(path: string, cache?: {[path: string]: string}): string;
     export function unlink(path: string, callback?: (err?: ErrnoException) => void): void;
     export function unlinkSync(path: string): void;
     export function rmdir(path: string, callback?: (err?: ErrnoException) => void): void;

From 12766b5357c6339c9b93f2c4bddfe7a868df782e Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Mon, 31 Mar 2014 18:20:20 +0200
Subject: [PATCH 245/309] added hash & path to node's UrlOptions

---
 node/node.d.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/node/node.d.ts b/node/node.d.ts
index c81d795bd..69fabfb10 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -644,6 +644,8 @@ declare module "url" {
         pathname?: string;
         search?: string;
         query?: any;
+        hash?: string;
+        path?: string;
     }
 
     export function parse(urlStr: string, parseQueryString?: boolean , slashesDenoteHost?: boolean ): Url;

From 2fdba9cbbeb1cdad30bdb654fde03ed16e41c50d Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Mon, 31 Mar 2014 21:21:42 +0200
Subject: [PATCH 246/309] add hash/path to both Url & UrlOptions

---
 node/node.d.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/node/node.d.ts b/node/node.d.ts
index 69fabfb10..b8cc7d933 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -633,6 +633,8 @@ declare module "url" {
         search: string;
         query: string;
         slashes: boolean;
+        hash?: string;
+        path?: string;
     }
 
     export interface UrlOptions {

From 17bcd6dda4b16dea588fcdc6454e5ea5674ba6e5 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 00:36:01 +0200
Subject: [PATCH 247/309] added definitions for source-map-support

---
 source-map-support/source-map-support-tests.d.ts | 5 +++++
 source-map-support/source-map-support.d.ts       | 8 ++++++++
 2 files changed, 13 insertions(+)
 create mode 100644 source-map-support/source-map-support-tests.d.ts
 create mode 100644 source-map-support/source-map-support.d.ts

diff --git a/source-map-support/source-map-support-tests.d.ts b/source-map-support/source-map-support-tests.d.ts
new file mode 100644
index 000000000..ddd6308cc
--- /dev/null
+++ b/source-map-support/source-map-support-tests.d.ts
@@ -0,0 +1,5 @@
+/// <reference path="source-map-support.d.ts" />
+
+import sms = require('source-map-support');
+
+sms.install();
diff --git a/source-map-support/source-map-support.d.ts b/source-map-support/source-map-support.d.ts
new file mode 100644
index 000000000..c03c23d85
--- /dev/null
+++ b/source-map-support/source-map-support.d.ts
@@ -0,0 +1,8 @@
+// Type definitions for source-map-support 0.2.5
+// Project: https://github.com/evanw/source-map-support
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'source-map-support' {
+	export function install();
+}

From 172625be86cc3eb580180dfc9ef4331b67a3a1b9 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 00:36:13 +0200
Subject: [PATCH 248/309] added definitions for detect-indent

---
 detect-indent/detect-indent-tests.d.ts | 8 ++++++++
 detect-indent/detect-indent.d.ts       | 9 +++++++++
 2 files changed, 17 insertions(+)
 create mode 100644 detect-indent/detect-indent-tests.d.ts
 create mode 100644 detect-indent/detect-indent.d.ts

diff --git a/detect-indent/detect-indent-tests.d.ts b/detect-indent/detect-indent-tests.d.ts
new file mode 100644
index 000000000..d56854ae0
--- /dev/null
+++ b/detect-indent/detect-indent-tests.d.ts
@@ -0,0 +1,8 @@
+/// <reference path="detect-indent-tests.d.ts" />
+
+import di = require('detect-indent');
+
+var str: string;
+
+str = di(str);
+str = di(str, str);
diff --git a/detect-indent/detect-indent.d.ts b/detect-indent/detect-indent.d.ts
new file mode 100644
index 000000000..3ce72401d
--- /dev/null
+++ b/detect-indent/detect-indent.d.ts
@@ -0,0 +1,9 @@
+// Type definitions for detect-indent 0.1.3
+// Project: https://github.com/sindresorhus/detect-indent
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'detect-indent' {
+	function DetectIndent (dir: string, alt?: string): string;
+	export = DetectIndent;
+}

From 0230d3aa6370d0060b284e4b772040fce79a5d49 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 00:36:25 +0200
Subject: [PATCH 249/309] added definitions for open

---
 open/open-tests.ts | 6 ++++++
 open/open.d.ts     | 9 +++++++++
 2 files changed, 15 insertions(+)
 create mode 100644 open/open-tests.ts
 create mode 100644 open/open.d.ts

diff --git a/open/open-tests.ts b/open/open-tests.ts
new file mode 100644
index 000000000..a529fa9cf
--- /dev/null
+++ b/open/open-tests.ts
@@ -0,0 +1,6 @@
+/// <reference path="open.d.ts" />
+
+import open = require('open');
+
+open('foo');
+open('foo', 'bar');
diff --git a/open/open.d.ts b/open/open.d.ts
new file mode 100644
index 000000000..c32e80bfe
--- /dev/null
+++ b/open/open.d.ts
@@ -0,0 +1,9 @@
+// Type definitions for open 0.0.3
+// Project: https://github.com/jjrdn/node-open
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'open' {
+	function open(target: string, app?: string): void;
+	export = open;
+}

From a349c7811a5c54a7a1f0cb1d1440f26abd0631a4 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 00:36:35 +0200
Subject: [PATCH 250/309] added definitions for exit

---
 exit/exit-tests.ts | 5 +++++
 exit/exit.d.ts     | 9 +++++++++
 2 files changed, 14 insertions(+)
 create mode 100644 exit/exit-tests.ts
 create mode 100644 exit/exit.d.ts

diff --git a/exit/exit-tests.ts b/exit/exit-tests.ts
new file mode 100644
index 000000000..0b5b51dc8
--- /dev/null
+++ b/exit/exit-tests.ts
@@ -0,0 +1,5 @@
+/// <reference path="exit.d.ts" />
+
+import exit = require('exit');
+
+exit(42);
diff --git a/exit/exit.d.ts b/exit/exit.d.ts
new file mode 100644
index 000000000..103984d86
--- /dev/null
+++ b/exit/exit.d.ts
@@ -0,0 +1,9 @@
+// Type definitions for exit 0.1.2
+// Project: https://github.com/cowboy/node-exit
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'exit' {
+	function exit(code: number): void;
+	export = exit;
+}

From 2d6c5ce48d8817f043c0bda966b7c76a44491bd3 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 00:36:47 +0200
Subject: [PATCH 251/309] added definitions for mkdirp

---
 mkdirp/mkdirp-tests.ts | 16 ++++++++++++++++
 mkdirp/mkdirp.d.ts     | 15 +++++++++++++++
 2 files changed, 31 insertions(+)
 create mode 100644 mkdirp/mkdirp-tests.ts
 create mode 100644 mkdirp/mkdirp.d.ts

diff --git a/mkdirp/mkdirp-tests.ts b/mkdirp/mkdirp-tests.ts
new file mode 100644
index 000000000..e256e61ad
--- /dev/null
+++ b/mkdirp/mkdirp-tests.ts
@@ -0,0 +1,16 @@
+/// <reference path="mkdirp.d.ts" />
+
+import mkdirp = require('mkdirp');
+
+var str: string;
+var num: number;
+
+mkdirp(str, num, (err, made) => {
+	str = made;
+});
+mkdirp(str, (err, made) => {
+	str = made;
+});
+
+str = mkdirp.sync(str, num);
+str = mkdirp.sync(str);
\ No newline at end of file
diff --git a/mkdirp/mkdirp.d.ts b/mkdirp/mkdirp.d.ts
new file mode 100644
index 000000000..c3fca38a2
--- /dev/null
+++ b/mkdirp/mkdirp.d.ts
@@ -0,0 +1,15 @@
+// Type definitions for mkdirp 0.3.0
+// Project: http://github.com/substack/node-mkdirp
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'mkdirp' {
+
+	function mkdirp(dir: string, cb: (err: any, made: string) => void): void;
+	function mkdirp(dir: string, flags: any, cb: (err: any, made: string) => void): void;
+
+	module mkdirp {
+		function sync(dir: string, flags?: any): string;
+	}
+	export = mkdirp;
+}

From 851a305add463db1d34bc3c863c527f265b714bf Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 00:37:28 +0200
Subject: [PATCH 252/309] added definitions for gracefull-fs

---
 graceful-fs/graceful-fs-tests.ts |  8 ++++++++
 graceful-fs/graceful-fs.d.ts     | 11 +++++++++++
 2 files changed, 19 insertions(+)
 create mode 100644 graceful-fs/graceful-fs-tests.ts
 create mode 100644 graceful-fs/graceful-fs.d.ts

diff --git a/graceful-fs/graceful-fs-tests.ts b/graceful-fs/graceful-fs-tests.ts
new file mode 100644
index 000000000..ca0a5e7b8
--- /dev/null
+++ b/graceful-fs/graceful-fs-tests.ts
@@ -0,0 +1,8 @@
+/// <reference path="graceful-fs.d.ts" />
+
+import fs = require('graceful-fs');
+
+var str: string;
+var buf: NodeBuffer;
+
+fs.renameSync(str, str);
\ No newline at end of file
diff --git a/graceful-fs/graceful-fs.d.ts b/graceful-fs/graceful-fs.d.ts
new file mode 100644
index 000000000..e77dc8893
--- /dev/null
+++ b/graceful-fs/graceful-fs.d.ts
@@ -0,0 +1,11 @@
+// Type definitions for graceful-fs 2.0.0
+// Project: https://github.com/cowboy/graceful-fs
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module 'graceful-fs' {
+	import fs = require('fs');
+	export = fs;
+}

From 6527fc4a3d033c6f10340b546e634e672d83a4da Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 00:37:42 +0200
Subject: [PATCH 253/309] added definitions for jsesc

---
 jsesc/jsesc-tests.ts | 45 ++++++++++++++++++++++++++++++++++++++++++++
 jsesc/jsesc.d.ts     | 25 ++++++++++++++++++++++++
 2 files changed, 70 insertions(+)
 create mode 100644 jsesc/jsesc-tests.ts
 create mode 100644 jsesc/jsesc.d.ts

diff --git a/jsesc/jsesc-tests.ts b/jsesc/jsesc-tests.ts
new file mode 100644
index 000000000..355b2a798
--- /dev/null
+++ b/jsesc/jsesc-tests.ts
@@ -0,0 +1,45 @@
+/// <reference path="jsesc.d.ts" />
+
+import jsesc = require('jsesc');
+import Opts = jsesc.Opts;
+
+// ---- ---- ---- ---- ---- ---- ----
+
+var num: number;
+var str: string;
+var bool: boolean;
+var opts: Opts;
+var opts: Opts;
+
+// ---- ---- ---- ---- ---- ---- ----
+
+str = jsesc.version;
+
+// ---- ---- ---- ---- ---- ---- ----
+
+opts = {
+	quotes: str
+};
+opts = {
+	wrap: bool
+};
+opts = {
+	es6: bool
+};
+opts = {
+	escapeEverything: bool
+};
+opts = {
+	compact: bool
+};
+opts = {
+	indent: str
+};
+opts = {
+	json: bool
+};
+
+// ---- ---- ---- ---- ---- ---- ----
+
+str = jsesc(str);
+str = jsesc(str, opts);
diff --git a/jsesc/jsesc.d.ts b/jsesc/jsesc.d.ts
new file mode 100644
index 000000000..76b40cf45
--- /dev/null
+++ b/jsesc/jsesc.d.ts
@@ -0,0 +1,25 @@
+// Type definitions for jsesc 0.4.3
+// Project: https://github.com/mathiasbynens/jsesc
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'jsesc' {
+
+	function jsesc(str: string, opts?: any): string;
+
+	module jsesc {
+		var version: string;
+
+		interface Opts {
+			quotes?: string;
+			wrap?: boolean;
+			es6?: boolean;
+			escapeEverything?: boolean;
+			compact?: boolean;
+			indent?: string;
+			json?: boolean;
+		}
+	}
+
+	export = jsesc;
+}

From 0d1397aba631f8c4b66f702e0172a1d615c68e2e Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 00:42:13 +0200
Subject: [PATCH 254/309] added definitions for json-pointer

---
 README.md                          |  1 +
 json-pointer/json-pointer-tests.ts | 41 +++++++++++++++
 json-pointer/json-pointer.d.ts     | 83 ++++++++++++++++++++++++++++++
 3 files changed, 125 insertions(+)
 create mode 100644 json-pointer/json-pointer-tests.ts
 create mode 100644 json-pointer/json-pointer.d.ts

diff --git a/README.md b/README.md
index b2149c5cb..e41116fa1 100755
--- a/README.md
+++ b/README.md
@@ -169,6 +169,7 @@ List of Definitions
 * [jScrollPane](http://jscrollpane.kelvinluck.com) (by [Dániel Tar](https://github.com/qcz))
 * [JSDeferred](http://cho45.stfuawsc.com/jsdeferred/) (by [Daisuke Mino](https://github.com/minodisk))
 * [JSONEditorOnline](https://github.com/josdejong/jsoneditoronline) (by [Vincent Bortone](https://github.com/vbortone/))
+* [JSON-Pointer](https://www.npmjs.org/package/json-pointer) (by [Bart van der Schoor](https://github.com/Bartvds))
 * [jStorage](http://www.jstorage.info/) (by [Danil Flores](https://github.com/dflor003/))
 * [JWPlayer](http://developer.longtailvideo.com/trac/) (by [Martin Duparc](https://github.com/martinduparc/))
 * [KeyboardJS](https://github.com/RobertWHurst/KeyboardJS) (by [Vincent Bortone](https://github.com/vbortone/))
diff --git a/json-pointer/json-pointer-tests.ts b/json-pointer/json-pointer-tests.ts
new file mode 100644
index 000000000..79297c0f0
--- /dev/null
+++ b/json-pointer/json-pointer-tests.ts
@@ -0,0 +1,41 @@
+/// <reference path="json-pointer.d.ts" />
+
+import JsonPointer = require('json-pointer');
+
+var value: any;
+var str: string;
+var strArr: string[];
+var pointer: string;
+var bool: any;
+var object:Object;
+
+bool = JsonPointer.has(object, pointer);
+value = JsonPointer.get(object, pointer);
+JsonPointer.set(object, pointer, value);
+JsonPointer.remove(object, pointer);
+
+object = JsonPointer.dict(object);
+
+JsonPointer.walk(object, (elem) => {
+
+});
+
+str = JsonPointer.escape(str);
+str = JsonPointer.unescape(str);
+
+strArr = JsonPointer.parse(str);
+str = JsonPointer.compile(strArr);
+
+var wrap = JsonPointer(object);
+
+bool = wrap.has(pointer);
+value = wrap.get(pointer);
+wrap.set(pointer, value);
+wrap.remove(pointer);
+
+object = wrap.dict();
+
+wrap.walk((elem, key) => {
+	value = elem;
+	str = key;
+});
\ No newline at end of file
diff --git a/json-pointer/json-pointer.d.ts b/json-pointer/json-pointer.d.ts
new file mode 100644
index 000000000..fa8b57f4c
--- /dev/null
+++ b/json-pointer/json-pointer.d.ts
@@ -0,0 +1,83 @@
+// Type definitions for json-pointer 1.0 l
+// Project: https://www.npmjs.org/package/json-pointer
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "json-pointer" {
+	function JSON_Pointer(object: Object): JSON_Pointer.JSON_PointerWrap;
+
+	module JSON_Pointer {
+		/**
+		 *  Wrap an object with accessors
+		 */
+		/**
+		 *  Looks up a JSON pointer in an object.
+		 */
+		function get(object: Object, pointer: string): any;
+		/**
+		 *  Set a value for a JSON pointer on object.
+		 */
+		function set(object: Object, pointer: string, value: any): void;
+		/**
+		 *  Removes an attribute of object referenced by pointer
+		 */
+		function remove(object: Object, pointer: string): void;
+		/**
+		 *  Creates a dictionary object (pointer -> value).
+		 */
+		function dict(object: Object): Object;
+		/**
+		 *  Just like: each(pointer.dict(obj), iterator);
+		 */
+		function walk(object: Object, iterator: (value: any, key: string) =>  void): void;
+		/**
+		 *  Tests if an object has a value for a JSON pointer.
+		 */
+		function has(object: Object, pointer: string): boolean;
+		/**
+		 *  Escapes a reference token.
+		 */
+		function escape(str: string): string;
+		/**
+		 *  Unescape a reference token.
+		 */
+		function unescape(str: string): string;
+		/**
+		 *  Converts a JSON pointer into an array of reference tokens.
+		 */
+		function parse(str: string): string[];
+		/**
+		 *  Builds a json pointer from an array of reference tokens.
+		 */
+		function compile(str: string[]): string;
+
+		interface JSON_PointerWrap {
+			/**
+			 *  Looks up a JSON pointer in an object.
+			 */
+			get(pointer: string): any;
+			/**
+			 *  Set a value for a JSON pointer on object.
+			 */
+			set(pointer: string, value: any): void;
+			/**
+			 *  Removes an attribute of object referenced by pointer
+			 */
+			remove(pointer: string): void;
+			/**
+			 *  Creates a dictionary object (pointer -> value).
+			 */
+			dict(): Object;
+			/**
+			 *  Just like: each(pointer.dict(obj), iterator);
+			 */
+			walk(iterator: (value: any, key: string) =>  void): void;
+			/**
+			 *  Tests if an object has a value for a JSON pointer.
+			 */
+			has(pointer: string): boolean;
+		}
+	}
+
+	export = JSON_Pointer;
+}

From c7e024eb0533098d59a96b349a221d226797ed43 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 00:39:37 +0200
Subject: [PATCH 255/309] added definitions for configstore

---
 README.md                        |  1 +
 configstore/configstore-tests.ts | 18 +++++++++++++++
 configstore/configstore.d.ts     | 38 ++++++++++++++++++++++++++++++++
 3 files changed, 57 insertions(+)
 create mode 100644 configstore/configstore-tests.ts
 create mode 100644 configstore/configstore.d.ts

diff --git a/README.md b/README.md
index b2149c5cb..a9aace0ed 100755
--- a/README.md
+++ b/README.md
@@ -58,6 +58,7 @@ List of Definitions
 * [CKEditor](https://github.com/ckeditor/ckeditor-dev) (by [Ondrej Sevcik](https://github.com/ondrejsevcik))
 * [CodeMirror](http://codemirror.net) (by [François de Campredon](https://github.com/fdecampredon))
 * [Commander](http://github.com/visionmedia/commander.js) (by [Marcelo Dezem](https://github.com/mdezem))
+* [configstore](http://github.com/yeoman/configstore) (by [Bart van der Schoor](https://github.com/Bartvds))
 * [Couchbase / Couchnode](https://github.com/couchbase/couchnode) (by [Basarat Ali Syed](https://github.com/basarat))
 * [Crossfilter](https://github.com/square/crossfilter) (by [Schmulik Raskin](https://github.com/schmuli))
 * [crypto-js](https://code.google.com/p/crypto-js/) (by [Gia Bảo @ Sân Đình](https://github.com/giabao)). @see [cryptojs.d.ts repo](https://github.com/giabao/cryptojs.d.ts)
diff --git a/configstore/configstore-tests.ts b/configstore/configstore-tests.ts
new file mode 100644
index 000000000..e616707af
--- /dev/null
+++ b/configstore/configstore-tests.ts
@@ -0,0 +1,18 @@
+/// <reference path="configstore.d.ts" />
+
+import cs = require('configstore');
+
+var value: any;
+var key: string;
+var num: number;
+var bool: any;
+var object:Object;
+
+cs.set(key, value);
+value = cs.get(key);
+cs.del(key);
+
+object = cs.all;
+cs.all = object;
+num = cs.size;
+key = cs.path;
\ No newline at end of file
diff --git a/configstore/configstore.d.ts b/configstore/configstore.d.ts
new file mode 100644
index 000000000..94849d847
--- /dev/null
+++ b/configstore/configstore.d.ts
@@ -0,0 +1,38 @@
+// Type definitions for configstore 0.3.0
+// Project: https://github.com/yeoman/configstore
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'configstore' {
+	/*
+	 Set an item
+	 */
+	export function set(key: string, val: any): void;
+
+	/*
+	 Get an item
+	 */
+	export function get(key: string): any;
+
+	/*
+	 Delete an item
+	 */
+	export function del(key: string): void;
+
+	/*
+	 Get all items as an object or replace the current config with an object:
+
+	 conf.all = {
+	    hello: 'world'
+	 };
+	 */
+	export var all: Object;
+	/*
+	 Get the item count
+	 */
+	export var size: number;
+	/*
+	 Get the path to the config file. Can be used to show the user where the config file is located or even better open it for them.
+	 */
+	export var path: string;
+}

From 69f04bbab60db6d296a1eabaecca91d11762a8c5 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 00:49:55 +0200
Subject: [PATCH 256/309] added definitions for minimist

---
 README.md                  |  1 +
 minimist/minimist-tests.ts | 27 +++++++++++++++++++++++++++
 minimist/minimist.d.ts     | 26 ++++++++++++++++++++++++++
 3 files changed, 54 insertions(+)
 create mode 100644 minimist/minimist-tests.ts
 create mode 100644 minimist/minimist.d.ts

diff --git a/README.md b/README.md
index b2149c5cb..d07776600 100755
--- a/README.md
+++ b/README.md
@@ -199,6 +199,7 @@ List of Definitions
 * [mCustomScrollbar](https://github.com/malihu/malihu-custom-scrollbar-plugin) (by [Sarah Williams](https://github.com/flurg))
 * [Meteor](https://www.meteor.com) (by [Dave Allen](https://github.com/fullflavedave))
 * [Microsoft Live Connect](http://msdn.microsoft.com/en-us/library/live/hh243643.aspx) (by [John Vilk](https://github.com/jvilk))
+* [minimist](https://github.com/substack/minimist) (by [Bart van der Schoor](https://github.com/Bartvds))
 * [Modernizr](http://modernizr.com/) (by [Boris Yankov](https://github.com/borisyankov) and [Theodore Brown](https://github.com/theodorejb/))
 * [Moment.js](https://github.com/timrwood/moment) (by [Michael Lakerveld](https://github.com/Lakerfield))
 * [MongoDB](http://mongodb.github.io/node-mongodb-native/) (from TypeScript samples, updated by [Niklas Mollenhauer](https://github.com/nikeee))
diff --git a/minimist/minimist-tests.ts b/minimist/minimist-tests.ts
new file mode 100644
index 000000000..b96b7d13a
--- /dev/null
+++ b/minimist/minimist-tests.ts
@@ -0,0 +1,27 @@
+/// <reference path="minimist.d.ts" />
+
+import minimist = require('minimist');
+import Opts = minimist.Opts;
+
+var num: string;
+var str: string;
+var strArr: string[];
+var args: string[];
+var obj: Object;
+var opts: Opts;
+
+opts.string = strArr;
+opts.boolean = strArr;
+opts.alias = {
+	foo: strArr
+};
+opts.default = {
+	foo: str
+};
+opts.default = {
+	foo: num
+};
+
+obj = minimist();
+obj = minimist(strArr);
+obj = minimist(strArr, opts);
diff --git a/minimist/minimist.d.ts b/minimist/minimist.d.ts
new file mode 100644
index 000000000..2d65e3aac
--- /dev/null
+++ b/minimist/minimist.d.ts
@@ -0,0 +1,26 @@
+// Type definitions for minimist 0.0.8
+// Project: https://github.com/substack/minimist
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'minimist' {
+	function minimist(args?: string[], opts?: minimist.Opts):Object;
+
+	module minimist {
+		export interface Opts {
+			// a string or array of strings argument names to always treat as strings
+			// string?: string;
+			string?: string[];
+			// a string or array of strings to always treat as booleans
+			// boolean?: string;
+			boolean?: string[];
+			// an object mapping string names to strings or arrays of string argument names to use
+			// alias?: {[key:string]: string};
+			alias?: {[key:string]: string[]};
+			// an object mapping string argument names to default values
+			default?: {[key:string]: any};
+		}
+	}
+
+	export = minimist;
+}

From f5f60a4cb3e54f560f623cf5000f7cdb471a4b24 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 01:08:27 +0200
Subject: [PATCH 257/309] added definitions for assertion-error

---
 assertion-error/assertion-error-tests.d.ts | 15 +++++++++++++++
 assertion-error/assertion-error.d.ts       | 15 +++++++++++++++
 2 files changed, 30 insertions(+)
 create mode 100644 assertion-error/assertion-error-tests.d.ts
 create mode 100644 assertion-error/assertion-error.d.ts

diff --git a/assertion-error/assertion-error-tests.d.ts b/assertion-error/assertion-error-tests.d.ts
new file mode 100644
index 000000000..b2a33a307
--- /dev/null
+++ b/assertion-error/assertion-error-tests.d.ts
@@ -0,0 +1,15 @@
+/// <reference path="assertion-error.d.ts" />
+
+import AssertionError = require('assertion-error');
+
+var e: AssertionError;
+var str: string;
+
+function foo () {
+
+}
+
+e = new AssertionError(str);
+e = new AssertionError(str, {a:1, b2});
+e = new AssertionError(str, {a:1, b2}, foo);
+
diff --git a/assertion-error/assertion-error.d.ts b/assertion-error/assertion-error.d.ts
new file mode 100644
index 000000000..5b63d63cf
--- /dev/null
+++ b/assertion-error/assertion-error.d.ts
@@ -0,0 +1,15 @@
+// Type definitions for assertion-error 1.0 0
+// Project: https://github.com/chaijs/assertion-error
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'assertion-error' {
+	class AssertionError implements Error {
+		constructor(message: string, props?: any, ssf?: Function);
+		name: string;
+		message: string;
+		showDiff: boolean;
+		stack: string;
+	}
+	export = AssertionError;
+}

From 3c4eb52a1aa9a400627787993d902b2cf6de491e Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 01:12:49 +0200
Subject: [PATCH 258/309] added definitions for uri-templates

---
 README.md                            |  1 +
 uri-templates/uri-templates-tests.ts | 16 ++++++++++++++++
 uri-templates/uri-templates.d.ts     | 18 ++++++++++++++++++
 3 files changed, 35 insertions(+)
 create mode 100644 uri-templates/uri-templates-tests.ts
 create mode 100644 uri-templates/uri-templates.d.ts

diff --git a/README.md b/README.md
index b2149c5cb..ff46ce78c 100755
--- a/README.md
+++ b/README.md
@@ -272,6 +272,7 @@ List of Definitions
 * [Underscore-ko.js](https://github.com/kamranayub/UnderscoreKO) (by [Maurits Elbers](https://github.com/MagicMau))
 * [universal-analytics](https://github.com/peaksandpies/universal-analytics) (by [Bart van der Schoor](https://github.com/Bartvds))
 * [update-notifier](https://github.com/yeoman/update-notifier) (by [vvakame](https://github.com/vvakame))
+* [uri-templates](https://github.com/geraintluff/uri-variables) (by [Bart van der Schoor](https://github.com/Bartvds))
 * [urlrouter](https://github.com/fengmk2/urlrouter) (by [Carlos Ballesteros Velasco](https://github.com/soywiz))
 * [UUID.js](https://github.com/LiosK/UUID.js) (by [Jason Jarrett](https://github.com/staxmanade))
 * [Valerie](https://github.com/davewatts/valerie) (by [Howard Richards](https://github.com/conficient))
diff --git a/uri-templates/uri-templates-tests.ts b/uri-templates/uri-templates-tests.ts
new file mode 100644
index 000000000..4809b7883
--- /dev/null
+++ b/uri-templates/uri-templates-tests.ts
@@ -0,0 +1,16 @@
+/// <reference path="uri-templates.d.ts" />
+
+import utmpl = require('uri-templates');
+import URITemplate = utmpl.URITemplate;
+
+var str: string;
+var u: URITemplate;
+var obj: Object;
+
+u = utmpl(str);
+
+str = u.fillFromObject(obj);
+str = u.fill((key) => {
+	return str;
+});
+obj = u.fromUri(str);
diff --git a/uri-templates/uri-templates.d.ts b/uri-templates/uri-templates.d.ts
new file mode 100644
index 000000000..b732ac435
--- /dev/null
+++ b/uri-templates/uri-templates.d.ts
@@ -0,0 +1,18 @@
+// Type definitions for uri-templates 0.1.2
+// Project: https://github.com/geraintluff/uri-templates
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'uri-templates' {
+	function utpl(template: string): utpl.URITemplate;
+
+	module utpl {
+		export interface URITemplate {
+			fillFromObject(vars: Object): string;
+			fill(callback: (varName: string) => string): string;
+			fromUri(uri: string): Object;
+		}
+	}
+
+	export = utpl;
+}

From f730d125d043e8e48eded89b3806864c7b3b363e Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 01:08:59 +0200
Subject: [PATCH 259/309] added definitions for buffer-equal

---
 buffer-equal/buffer-equal-tests.ts |  8 ++++++++
 buffer-equal/buffer-equal.d.ts     | 11 +++++++++++
 2 files changed, 19 insertions(+)
 create mode 100644 buffer-equal/buffer-equal-tests.ts
 create mode 100644 buffer-equal/buffer-equal.d.ts

diff --git a/buffer-equal/buffer-equal-tests.ts b/buffer-equal/buffer-equal-tests.ts
new file mode 100644
index 000000000..743ed187e
--- /dev/null
+++ b/buffer-equal/buffer-equal-tests.ts
@@ -0,0 +1,8 @@
+/// <reference path="buffer-equal.d.ts" />
+
+import bufferEqual = require('buffer-equal');
+
+var bool: boolean;
+var buf: NodeBuffer;
+
+bool = bufferEqual(buf, buf);
diff --git a/buffer-equal/buffer-equal.d.ts b/buffer-equal/buffer-equal.d.ts
new file mode 100644
index 000000000..bc8b1ce28
--- /dev/null
+++ b/buffer-equal/buffer-equal.d.ts
@@ -0,0 +1,11 @@
+// Type definitions for buffer-equal 1.0 0
+// Project: https://github.com/chaijs/assertion-error
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module 'buffer-equal' {
+	function bufferEqual(actual:NodeBuffer, expected:NodeBuffer): boolean;
+	export = bufferEqual;
+}

From 651153e509713f812544e482ca0dfdc6c3151303 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 00:21:49 +0200
Subject: [PATCH 260/309] added definitions for js-yaml

---
 README.md                |  1 +
 js-yaml/js-yaml-tests.ts | 84 ++++++++++++++++++++++++++++++++++++++++
 js-yaml/js-yaml.d.ts     | 48 +++++++++++++++++++++++
 3 files changed, 133 insertions(+)
 create mode 100644 js-yaml/js-yaml-tests.ts
 create mode 100644 js-yaml/js-yaml.d.ts

diff --git a/README.md b/README.md
index b2149c5cb..02fa53fba 100755
--- a/README.md
+++ b/README.md
@@ -166,6 +166,7 @@ List of Definitions
 * [jQuery.Watermark](http://jquery-watermark.googlecode.com) (by [Anwar Javed](https://github.com/anwarjaved))
 * [jQuery.base64](https://github.com/yatt/jquery.base64) (by [Shinya Mochizuki](https://github.com/enrapt-mochizuki))
 * [js-git](https://github.com/creationix/js-git) (by [Bart van der Schoor](https://github.com/Bartvds))
+* [js-yaml](https://github.com/nodeca/js-yaml) (by [Bart van der Schoor](https://github.com/Bartvds/))
 * [jScrollPane](http://jscrollpane.kelvinluck.com) (by [Dániel Tar](https://github.com/qcz))
 * [JSDeferred](http://cho45.stfuawsc.com/jsdeferred/) (by [Daisuke Mino](https://github.com/minodisk))
 * [JSONEditorOnline](https://github.com/josdejong/jsoneditoronline) (by [Vincent Bortone](https://github.com/vbortone/))
diff --git a/js-yaml/js-yaml-tests.ts b/js-yaml/js-yaml-tests.ts
new file mode 100644
index 000000000..91596b756
--- /dev/null
+++ b/js-yaml/js-yaml-tests.ts
@@ -0,0 +1,84 @@
+/// <reference path="js-yaml.d.ts" />
+
+import yaml = require('js-yaml');
+import LoadOptions = yaml.LoadOptions;
+import DumpOptions = yaml.DumpOptions;
+
+var bool: boolean;
+var num: number;
+var str: string;
+var obj: Object;
+var value: any;
+
+var loadOpts: LoadOptions;
+var dumpOpts: DumpOptions;
+
+// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+yaml.FAILSAFE_SCHEMA;
+yaml.JSON_SCHEMA;
+yaml.CORE_SCHEMA;
+yaml.DEFAULT_SAFE_SCHEMA;
+yaml.DEFAULT_FULL_SCHEMA;
+
+// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+loadOpts = {
+	filename: str
+};
+loadOpts = {
+	strict: bool
+};
+loadOpts = {
+	schema: bool
+};
+
+// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+dumpOpts = {
+	indent: num
+};
+dumpOpts = {
+	skipInvalid: bool
+};
+dumpOpts = {
+	flowLevel: num
+};
+dumpOpts = {
+	styles: obj
+};
+dumpOpts = {
+	schema: value
+};
+
+// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+value = yaml.safeLoad(str);
+value = yaml.safeLoad(str, loadOpts);
+
+value = yaml.load(str);
+value = yaml.load(str, loadOpts);
+
+// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+value = yaml.safeLoadAll(str, (doc) => {
+	value = doc;
+});
+value = yaml.safeLoadAll(str, (doc) => {
+	value = doc;
+}, loadOpts);
+
+value = yaml.loadAll(str, (doc) => {
+	value = doc;
+});
+value = yaml.loadAll(str, (doc) => {
+	value = doc;
+}, loadOpts);
+
+// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+value = yaml.safeDump(str);
+value = yaml.safeDump(str, dumpOpts);
+
+value = yaml.dump(str);
+value = yaml.dump(str, dumpOpts);
diff --git a/js-yaml/js-yaml.d.ts b/js-yaml/js-yaml.d.ts
new file mode 100644
index 000000000..0607b4891
--- /dev/null
+++ b/js-yaml/js-yaml.d.ts
@@ -0,0 +1,48 @@
+// Type definitions for js-yaml 3.0.2
+// Project: https://github.com/nodeca/js-yaml
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'js-yaml' {
+	export function safeLoad(str: string, opts?: LoadOptions): any;
+	export function load(str: string, opts?: LoadOptions): any;
+
+	export function safeLoadAll(str: string, iterator: (doc: any) => void, opts?: LoadOptions): any;
+	export function loadAll(str: string, iterator: (doc: any) => void, opts?: LoadOptions): any;
+
+	export function safeDump(obj: any, opts?: DumpOptions): string;
+	export function dump(obj: any, opts?: DumpOptions): string
+
+	export interface LoadOptions {
+		// string to be used as a file path in error/warning messages.
+		filename?: string;
+		// makes the loader to throw errors instead of warnings.
+		strict?: boolean;
+		// specifies a schema to use.
+		schema?: any;
+	}
+
+	export interface DumpOptions {
+		// indentation width to use (in spaces).
+		indent?: number;
+		// do not throw on invalid types (like function in the safe schema) and skip pairs and single values with such types.
+		skipInvalid?: boolean;
+		// specifies level of nesting, when to switch from block to flow style for collections. -1 means block style everwhere
+		flowLevel?: number;
+		// Each tag may have own set of styles.  - "tag" => "style" map.
+		styles?: Object;
+		// specifies a schema to use.
+		schema?: any;
+	}
+
+	// only strings, arrays and plain objects: http://www.yaml.org/spec/1.2/spec.html#id2802346
+	export var FAILSAFE_SCHEMA: any;
+	// only strings, arrays and plain objects: http://www.yaml.org/spec/1.2/spec.html#id2802346
+	export var JSON_SCHEMA: any;
+	// same as JSON_SCHEMA: http://www.yaml.org/spec/1.2/spec.html#id2804923
+	export var CORE_SCHEMA: any;
+	// all supported YAML types, without unsafe ones (!!js/undefined, !!js/regexp and !!js/function): http://yaml.org/type/
+	export var DEFAULT_SAFE_SCHEMA: any;
+	// all supported YAML types.
+	export var DEFAULT_FULL_SCHEMA: any;
+}

From 526b68f31a296fdc0b04ee586ad41c90c97548bd Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 02:08:55 +0200
Subject: [PATCH 261/309] fixed some tests for npm module

---
 .../{assertion-error-tests.d.ts => assertion-error-tests.ts}  | 4 ++--
 .../{detect-indent-tests.d.ts => detect-indent-tests.ts}      | 2 +-
 ...rce-map-support-tests.d.ts => source-map-support-tests.ts} | 0
 source-map-support/source-map-support.d.ts                    | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)
 rename assertion-error/{assertion-error-tests.d.ts => assertion-error-tests.ts} (68%)
 rename detect-indent/{detect-indent-tests.d.ts => detect-indent-tests.ts} (65%)
 rename source-map-support/{source-map-support-tests.d.ts => source-map-support-tests.ts} (100%)

diff --git a/assertion-error/assertion-error-tests.d.ts b/assertion-error/assertion-error-tests.ts
similarity index 68%
rename from assertion-error/assertion-error-tests.d.ts
rename to assertion-error/assertion-error-tests.ts
index b2a33a307..f03e9cb52 100644
--- a/assertion-error/assertion-error-tests.d.ts
+++ b/assertion-error/assertion-error-tests.ts
@@ -10,6 +10,6 @@ function foo () {
 }
 
 e = new AssertionError(str);
-e = new AssertionError(str, {a:1, b2});
-e = new AssertionError(str, {a:1, b2}, foo);
+e = new AssertionError(str, {a:1, b:2});
+e = new AssertionError(str, {a:1, b:2}, foo);
 
diff --git a/detect-indent/detect-indent-tests.d.ts b/detect-indent/detect-indent-tests.ts
similarity index 65%
rename from detect-indent/detect-indent-tests.d.ts
rename to detect-indent/detect-indent-tests.ts
index d56854ae0..4ee02471b 100644
--- a/detect-indent/detect-indent-tests.d.ts
+++ b/detect-indent/detect-indent-tests.ts
@@ -1,4 +1,4 @@
-/// <reference path="detect-indent-tests.d.ts" />
+/// <reference path="detect-indent.d.ts" />
 
 import di = require('detect-indent');
 
diff --git a/source-map-support/source-map-support-tests.d.ts b/source-map-support/source-map-support-tests.ts
similarity index 100%
rename from source-map-support/source-map-support-tests.d.ts
rename to source-map-support/source-map-support-tests.ts
diff --git a/source-map-support/source-map-support.d.ts b/source-map-support/source-map-support.d.ts
index c03c23d85..8d4e22579 100644
--- a/source-map-support/source-map-support.d.ts
+++ b/source-map-support/source-map-support.d.ts
@@ -4,5 +4,5 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 declare module 'source-map-support' {
-	export function install();
+	export function install(): any;
 }

From 49b672dc085f8a37f084891175de9bd6b09d8ce7 Mon Sep 17 00:00:00 2001
From: Dan Quirk <danquirk@microsoft.com>
Date: Mon, 31 Mar 2014 19:14:03 -0700
Subject: [PATCH 262/309] Reorder select2 overloads from most specific to least
 specific so overload resolution behaves as expected.

---
 select2/select2.d.ts | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/select2/select2.d.ts b/select2/select2.d.ts
index 3cf787a95..b719ecfac 100644
--- a/select2/select2.d.ts
+++ b/select2/select2.d.ts
@@ -87,9 +87,7 @@ interface JQuery {
 
     select2(): JQuery;
     select2(it: IdTextPair): JQuery;
-    select2(options: Select2Options): JQuery;
-    select2(method: string): any;
-    select2(method: string, value: any, trigger?: boolean): any;
+
     /**
     * Get the id value of the current selection
     */
@@ -144,4 +142,8 @@ interface JQuery {
     * Notifies Select2 that a drag and drop sorting operation has finished
     */
     select2(method: 'onSortEnd'): void;
+
+    select2(method: string): any;
+    select2(method: string, value: any, trigger?: boolean): any;
+    select2(options: Select2Options): JQuery;
 }

From 22a2021fbde211852ca4911936bbda5e9f47a57b Mon Sep 17 00:00:00 2001
From: Nathan Ridley <axefrog@gmail.com>
Date: Tue, 1 Apr 2014 13:24:23 +0700
Subject: [PATCH 263/309] Fixed incorrect declaration of countBy function

---
 underscore/underscore.d.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/underscore/underscore.d.ts b/underscore/underscore.d.ts
index 10e4ccb23..9e44c0c63 100644
--- a/underscore/underscore.d.ts
+++ b/underscore/underscore.d.ts
@@ -499,7 +499,7 @@ interface UnderscoreStatic {
 	countBy<T>(
 		list: _.Collection<T>,
 		iterator?: _.ListIterator<T, any>,
-		context?: any): _.Dictionary<number[]>;
+		context?: any): _.Dictionary<number>;
 
 	/**
 	* @see _.countBy
@@ -508,7 +508,7 @@ interface UnderscoreStatic {
 	countBy<T>(
 		list: _.Collection<T>,
 		iterator: string,
-		context?: any): _.Dictionary<number[]>;
+		context?: any): _.Dictionary<number>;
 
 	/**
 	* Returns a shuffled copy of the list, using a version of the Fisher-Yates shuffle.
@@ -1612,13 +1612,13 @@ interface Underscore<T> {
 	* Wrapped type `any[]`.
 	* @see _.countBy
 	**/
-	countBy(iterator?: _.ListIterator<T, any>, context?: any): _.Dictionary<number[]>;
+	countBy(iterator?: _.ListIterator<T, any>, context?: any): _.Dictionary<number>;
 
 	/**
 	* Wrapped type `any[]`.
 	* @see _.countBy
 	**/
-	countBy(iterator: string, context?: any): _.Dictionary<number[]>;
+	countBy(iterator: string, context?: any): _.Dictionary<number>;
 
 	/**
 	* Wrapped type `any[]`.

From b79ba7c76f2856933d2a7217e24b88cd0a759cec Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 1 Apr 2014 12:02:47 +0400
Subject: [PATCH 264/309] Added Rx.helpers functions.

---
 rx.js/rx-lite.ts | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/rx.js/rx-lite.ts b/rx.js/rx-lite.ts
index 1e387af48..201e7143f 100644
--- a/rx.js/rx-lite.ts
+++ b/rx.js/rx-lite.ts
@@ -45,6 +45,19 @@ declare module Rx {
 		export var Promise: { new <T>(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; };
 	}
 
+	export module helpers {
+		function noop(): void;
+		function identity<T>(value: T): T;
+		function defaultNow(): number;
+		function defaultComparer(left: any, right: any): boolean;
+		function defaultSubComparer(left: any, right: any): number;
+		function defaultKeySerializer(key: any): string;
+		function defaultError(err: any): void;
+		function isPromise(p: any): boolean;
+		function asArray<T>(...args: T[]): T[];
+		function not(value: any): boolean;
+	}
+
 	export interface IDisposable {
 		dispose(): void;
 	}

From 5094254e616a4ddd9825fdf05820cf847c3c257e Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 1 Apr 2014 13:39:04 +0400
Subject: [PATCH 265/309] Added overloads of `defer` and
 `catch`/`catchException` with handle promises.

---
 rx.js/rx-lite.ts | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/rx.js/rx-lite.ts b/rx.js/rx-lite.ts
index 201e7143f..c0a27c3c4 100644
--- a/rx.js/rx-lite.ts
+++ b/rx.js/rx-lite.ts
@@ -320,6 +320,7 @@ declare module Rx {
 		create<T>(subscribe: (observer: Observer<T>) => IDisposable): Observable<T>;
 		createWithDisposable<T>(subscribe: (observer: Observer<T>) => IDisposable): Observable<T>;
 		defer<T>(observableFactory: () => Observable<T>): Observable<T>;
+		defer<T>(observableFactory: () => IPromise<T>): Observable<T>;
 		empty<T>(scheduler?: IScheduler): Observable<T>;
 		fromArray<T>(array: T[], scheduler?: IScheduler): Observable<T>;
 		fromArray<T>(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): Observable<T>;
@@ -360,9 +361,13 @@ declare module Rx {
 		throwException<T>(exception: any, scheduler?: IScheduler): Observable<T>;	// alias for throw
 
 		catch<T>(sources: Observable<T>[]): Observable<T>;
+		catch<T>(sources: IPromise<T>[]): Observable<T>;
 		catchException<T>(sources: Observable<T>[]): Observable<T>;	// alias for catch
+		catchException<T>(sources: IPromise<T>[]): Observable<T>;	// alias for catch
 		catch<T>(...sources: Observable<T>[]): Observable<T>;
+		catch<T>(...sources: IPromise<T>[]): Observable<T>;
 		catchException<T>(...sources: Observable<T>[]): Observable<T>;	// alias for catch
+		catchException<T>(...sources: IPromise<T>[]): Observable<T>;	// alias for catch
 		concat<T>(...sources: Observable<T>[]): Observable<T>;
 		concat<T>(...sources: IPromise<T>[]): Observable<T>;
 		concat<T>(sources: Observable<T>[]): Observable<T>;

From d27c018d05cd7ea726eb15c6414e39dabeb7cf80 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 1 Apr 2014 13:39:25 +0400
Subject: [PATCH 266/309] Version bump to 2.2.18

---
 rx.js/rx.async.d.ts        | 2 +-
 rx.js/rx.backpressure.d.ts | 2 +-
 rx.js/rx.binding.d.ts      | 2 +-
 rx.js/rx.d.ts              | 2 +-
 rx.js/rx.lite.d.ts         | 2 +-
 rx.js/rx.time.d.ts         | 2 +-
 rx.js/rx.virtualtime.d.ts  | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/rx.js/rx.async.d.ts b/rx.js/rx.async.d.ts
index b24191ae4..ff8b61c49 100644
--- a/rx.js/rx.async.d.ts
+++ b/rx.js/rx.async.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Async v2.2.17
+// Type definitions for RxJS-Async v2.2.18
 // Project: http://rx.codeplex.com/
 // Definitions by: zoetrope <https://github.com/zoetrope>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
diff --git a/rx.js/rx.backpressure.d.ts b/rx.js/rx.backpressure.d.ts
index 7d7b878fd..4c9a9ae7d 100644
--- a/rx.js/rx.backpressure.d.ts
+++ b/rx.js/rx.backpressure.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-BackPressure v2.2.15
+// Type definitions for RxJS-BackPressure v2.2.18
 // Project: http://rx.codeplex.com/
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
diff --git a/rx.js/rx.binding.d.ts b/rx.js/rx.binding.d.ts
index 505522e38..526546353 100644
--- a/rx.js/rx.binding.d.ts
+++ b/rx.js/rx.binding.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Binding v2.2.17
+// Type definitions for RxJS-Binding v2.2.18
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index 99bec0f3c..3d9c0e0d5 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS v2.2.17
+// Type definitions for RxJS v2.2.18
 // Project: http://rx.codeplex.com/
 // Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
diff --git a/rx.js/rx.lite.d.ts b/rx.js/rx.lite.d.ts
index 70d228bad..a50f8c84d 100644
--- a/rx.js/rx.lite.d.ts
+++ b/rx.js/rx.lite.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Lite v2.2.17
+// Type definitions for RxJS-Lite v2.2.18
 // Project: http://rx.codeplex.com/
 // Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
diff --git a/rx.js/rx.time.d.ts b/rx.js/rx.time.d.ts
index 47482bca4..925d16220 100644
--- a/rx.js/rx.time.d.ts
+++ b/rx.js/rx.time.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Time v2.2.17
+// Type definitions for RxJS-Time v2.2.18
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
diff --git a/rx.js/rx.virtualtime.d.ts b/rx.js/rx.virtualtime.d.ts
index afa398264..c57cbd664 100644
--- a/rx.js/rx.virtualtime.d.ts
+++ b/rx.js/rx.virtualtime.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-VirtualTime package 2.2
+// Type definitions for RxJS-VirtualTime package 2.2.18
 // Project: http://rx.codeplex.com/
 // Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>

From 19a4c0363181f8790131f95a29358aed3eb73435 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 20:58:33 +0200
Subject: [PATCH 267/309] added definitions for parsimmon

---
 README.md                    |   1 +
 parsimmon/parsimmon-tests.ts | 116 ++++++++++++++++++++++++++++
 parsimmon/parsimmon.d.ts     | 146 +++++++++++++++++++++++++++++++++++
 3 files changed, 263 insertions(+)
 create mode 100644 parsimmon/parsimmon-tests.ts
 create mode 100644 parsimmon/parsimmon.d.ts

diff --git a/README.md b/README.md
index 30c81dd14..35bd97dc7 100755
--- a/README.md
+++ b/README.md
@@ -219,6 +219,7 @@ List of Definitions
 * [Numeral.js](https://github.com/adamwdraper/Numeral-js) (by [Vincent Bortone](https://github.com/vbortone/))
 * [OpenLayers](https://github.com/openlayers/openlayers) (by [Ilya Bolkhovsky](https://github.com/bolhovsky/))
 * [Parallel.js](https://github.com/adambom/parallel.js) (by [Josh Baldwin](https://github.com/jbaldwin))
+* [Parsimmon](https://github.com/jayferd/parsimmon) (by [Bart van der Schoor](https://github.com/Bartvds))
 * [PDF.js](https://github.com/mozilla/pdf.js) (by [Josh Baldwin](https://github.com/jbaldwin))
 * [Persona](http://www.mozilla.org/en-US/persona) (by [James Frasca](https://github.com/Nycto))
 * [PhantomJS](http://phantomjs.org) (by [Jed Hunsaker](https://github.com/jedhunsaker))
diff --git a/parsimmon/parsimmon-tests.ts b/parsimmon/parsimmon-tests.ts
new file mode 100644
index 000000000..16d1510b5
--- /dev/null
+++ b/parsimmon/parsimmon-tests.ts
@@ -0,0 +1,116 @@
+/// <reference path="parsimmon.d.ts" />
+
+import P = require('parsimmon');
+import Parser = P.Parser;
+import Mark = P.Mark;
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+class Foo {
+	bar: Bar;
+}
+
+class Bar {
+	foo: Foo;
+}
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+var str: string;
+var num: number;
+var regex: RegExp;
+
+var foo: Foo;
+var bar: Bar;
+
+var strArr: string[];
+var fooArr: Foo[];
+var barArr: Bar[];
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+var strPar: Parser<string>;
+var numPar: Parser<number>;
+var voidPar: Parser<void>;
+var anyPar: Parser<any>;
+
+var fooPar: Parser<Foo>;
+var barPar: Parser<Bar>;
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+var anyArrPar: Parser<any[]>;
+
+var fooArrPar: Parser<Foo[]>;
+var barArrPar: Parser<Bar[]>;
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+var fooMarkPar: Parser<Mark<Foo>>;
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+foo = fooPar.parse(str);
+
+fooPar = fooPar.or(fooPar);
+anyPar = fooPar.or(barPar);
+
+barPar = fooPar.then((f) => {
+	foo = f;
+	return barPar;
+});
+barPar = fooPar.then(barPar);
+
+barPar = fooPar.map((f) => {
+	foo = f;
+	return bar;
+});
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+fooPar = fooPar.skip(barPar);
+
+barPar = barPar = fooPar.result(bar);
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+fooArrPar = fooPar.many();
+fooArrPar = fooPar.times(num);
+fooArrPar = fooPar.times(num, num);
+fooArrPar = fooPar.atMost(num);
+fooArrPar = fooPar.atLeast(num);
+
+fooMarkPar = fooPar.mark();
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+strPar = P.string(str);
+strPar = P.regex(regex);
+
+fooPar = P.succeed(foo);
+
+fooArrPar = P.seq(fooPar, fooPar);
+anyArrPar = P.seq(barPar, fooPar, numPar);
+
+fooPar = P.lazy(() => {
+	return fooPar;
+});
+
+voidPar = P.fail(str);
+fooPar = P.fail<Foo>(str);
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+strPar = P.letter;
+strPar = P.letters;
+
+strPar = P.digit;
+strPar = P.digits;
+
+strPar = P.whitespace;
+strPar = P.optWhitespace;
+
+strPar = P.any;
+strPar = P.all;
+strPar = P.eof;
+numPar = P.index;
\ No newline at end of file
diff --git a/parsimmon/parsimmon.d.ts b/parsimmon/parsimmon.d.ts
new file mode 100644
index 000000000..435ea285a
--- /dev/null
+++ b/parsimmon/parsimmon.d.ts
@@ -0,0 +1,146 @@
+// Type definitions for Parsimmon 0.3.0
+// Project: https://github.com/jayferd/parsimmon
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// TODO convert to generics
+
+declare module 'parsimmon' {
+	module Parsimmon {
+
+		export interface Mark<T> {
+			start: number;
+			end: number;
+			value: T;
+		}
+
+		export interface Parser<T> {
+			/*
+			 parse the string
+			 */
+			parse(input: string): T;
+			/*
+			 returns a new parser which tries parser, and if it fails uses otherParser.
+			 */
+			or(otherParser: Parser<T>): Parser<T>;
+			or<U>(otherParser: Parser<U>): Parser<any>;
+			/*
+			 returns a new parser which tries parser, and on success calls the given function with the result of the parse, which is expected to return another parser.
+			 */
+			then<U>(call: (result: T) => Parser<U>): Parser<U>;
+			/*
+			 expects anotherParser to follow parser, and yields the result of anotherParser. NB: the result of parser here is ignored.
+			 */
+			then<U>(anotherParser: Parser<U>): Parser<U>;
+			/*
+			 transforms the output of parser with the given function.
+			 */
+			map<U>(call: (result: T) => U): Parser<U>;
+			/*
+			 expects otherParser after parser, but preserves the yield value of parser.
+			 */
+			skip<U>(otherParser: Parser<U>): Parser<T>;
+			/*
+			 returns a new parser with the same behavior, but which yields aResult.
+			 */
+			result<U>(aResult: U): Parser<U>;
+			/*
+			 expects parser zero or more times, and yields an array of the results.
+			 */
+			many(): Parser<T[]>;
+			/*
+			 expects parser exactly n times, and yields an array of the results.
+			 */
+			times(n: number): Parser<T[]>;
+			/*
+			 expects parser between min and max times, and yields an array of the results.
+			 */
+			times(min: number, max: number): Parser<T[]>;
+			/*
+			 expects parser at most n times. Yields an array of the results.
+			 */
+			atMost(n: number): Parser<T[]>;
+			/*
+			 expects parser at least n times. Yields an array of the results.
+			 */
+			atLeast(n: number): Parser<T[]>;
+			/*
+			 yields an object with start, value, and end keys, where value is the original value yielded by the parser, and start and end are the indices in the stream that contain the parsed text.
+			 */
+			mark(): Parser<Mark<T>>;
+		}
+		/*
+		 is a parser that expects to find "my-string", and will yield the same.
+		 */
+		export function string(mystring: string): Parser<string>;
+
+		/*
+		 is a parser that expects the stream to match the given regex.
+		 */
+		export function regex(myregex: RegExp): Parser<string>;
+
+		/*
+		 is a parser that doesn't consume any of the string, and yields result.
+		 */
+		export function succeed<U>(result: U): Parser<U>;
+
+		/*
+		 accepts a variable number of parsers that it expects to find in order, yielding an array of the results.
+		 */
+		export function seq(...parsers: Parser<any>[]): Parser<any[]>;
+
+		/*
+		 accepts a function that returns a parser, which is evaluated the first time the parser is used. This is useful for referencing parsers that haven't yet been defined.
+		 */
+		export function lazy<U>(f: () => Parser<U>): Parser<U>;
+
+		/*
+		 fail paring with a message
+		 */
+		export function fail(message: string): Parser<void>;
+		export function fail<U>(message: string): Parser<U>;
+
+		/*
+		 is equivalent to Parsimmon.regex(/[a-z]/i)
+		 */
+		export var letter: Parser<string>;
+		/*
+		 is equivalent to Parsimmon.regex(/[a-z]*`/i)
+		 */
+		export var letters: Parser<string>;
+		/*
+		 is equivalent to Parsimmon.regex(/[0-9]/)
+		 */
+		export var digit: Parser<string>;
+		/*
+		 is equivalent to Parsimmon.regex(/[0-9]*`/)
+		 */
+		export var digits: Parser<string>;
+		/*
+		 is equivalent to Parsimmon.regex(/\s+/)
+		 */
+		export var whitespace: Parser<string>;
+		/*
+		 is equivalent to Parsimmon.regex(/\s*`/)
+		 */
+		export var optWhitespace: Parser<string>;
+		/*
+		 consumes and yields the next character of the stream.
+		 */
+		export var any: Parser<string>;
+		/*
+		 consumes and yields the entire remainder of the stream.
+		 */
+		export var all: Parser<string>;
+		/*
+		 expects the end of the stream.
+		 */
+		export var eof: Parser<string>;
+		/*
+		 is a parser that yields the current index of the parse.
+		 */
+		export var index: Parser<number>;
+	}
+
+	export = Parsimmon;
+}

From 1c0a4da2e5660c72c7e4ba9725426c351dc10b02 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 21:07:11 +0200
Subject: [PATCH 268/309] added definitions for XRegExp

---
 README.md                |   1 +
 xregexp/xregexp-tests.ts | 134 +++++++++++++++++++++++++++++++++++++++
 xregexp/xregexp.d.ts     |  62 ++++++++++++++++++
 3 files changed, 197 insertions(+)
 create mode 100644 xregexp/xregexp-tests.ts
 create mode 100644 xregexp/xregexp.d.ts

diff --git a/README.md b/README.md
index 30c81dd14..214494c3e 100755
--- a/README.md
+++ b/README.md
@@ -287,6 +287,7 @@ List of Definitions
 * [WinJS](http://msdn.microsoft.com/en-us/library/windows/apps/br229773.aspx) (from TypeScript samples)
 * [WinRT](http://msdn.microsoft.com/en-us/library/windows/apps/br211377.aspx) (from TypeScript samples)
 * [ws](http://einaros.github.io/ws/) (by [Paul Loyd](https://github.com/loyd))
+* [XRegExp](http://xregexp.com/) (by [Bart van der Schoor](https://github.com/Bartvds))
 * [YouTube](https://developers.google.com/youtube/) (by [Daz Wilkin](https://github.com/DazWilkin/))
 * [YouTube Analytics API](https://developers.google.com/youtube/analytics/) (by [Frank M](https://github.com/sgtfrankieboy))
 * [YouTube Data API](https://developers.google.com/youtube/v3/) (by [Frank M](https://github.com/sgtfrankieboy/))
diff --git a/xregexp/xregexp-tests.ts b/xregexp/xregexp-tests.ts
new file mode 100644
index 000000000..62d37439e
--- /dev/null
+++ b/xregexp/xregexp-tests.ts
@@ -0,0 +1,134 @@
+/// <reference path="xregexp.d.ts" />
+
+import X = require('xregexp');
+import XRegExp = X.XRegExp;
+import TokenOpts = X.TokenOpts;
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+var exp: RegExp;
+var expArr: RegExp[];
+var chain: RegExp[];
+var regex: RegExp;
+var value: any;
+var str: string;
+var scope: string;
+var search: string;
+var searchEx: RegExp;
+var bool: boolean;
+var strArr: string[];
+var pattern: string;
+var flags: string;
+var right: string;
+var left: string;
+var sticky: boolean;
+var pos: number;
+var num: number;
+var limit: number;
+var obj: Object;
+var matchArr: RegExpExecArray;
+var options: TokenOpts;
+var replacer: Function;
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+regex = XRegExp(str);
+regex = XRegExp(str, flags);
+regex = XRegExp(regex);
+
+str =  XRegExp.version;
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+XRegExp.addToken(regex, (arr, scope) => {
+	matchArr = arr;
+	str = scope;
+	return str;
+});
+
+XRegExp.addToken(regex, (arr, scope) => {
+	matchArr = arr;
+	str = scope;
+	return str;
+}, options);
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+regex = XRegExp.build(pattern, strArr, flags);
+regex = XRegExp.build(pattern, strArr);
+regex = XRegExp.cache(pattern);
+regex = XRegExp.cache(pattern, flags);
+
+str = XRegExp.escape(str);
+
+matchArr = XRegExp.exec(str, regex, pos, sticky);
+matchArr = XRegExp.exec(str, regex, pos);
+matchArr = XRegExp.exec(str, regex);
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+matchArr = XRegExp.forEach(str, regex, (match, index, input, regexp) => {
+	exp = regexp;
+	str = input;
+	num = index;
+	matchArr = match;
+}, obj);
+
+matchArr = XRegExp.forEach(str, regex, (match, index, input, regexp) => {
+	exp = regexp;
+	str = input;
+	num = index;
+	matchArr = match;
+});
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+regex = XRegExp.globalize(regex);
+
+XRegExp.install(str);
+XRegExp.install(obj);
+
+bool = XRegExp.isInstalled(str);
+bool = XRegExp.isRegExp(value);
+strArr = XRegExp.matchChain(str, chain);
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+strArr = XRegExp.matchRecursive(str, left, right, flags, options);
+strArr = XRegExp.matchRecursive(str, left, right, flags);
+strArr = XRegExp.matchRecursive(str, left, right);
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+str = XRegExp.replace(str, search, str, scope);
+str = XRegExp.replace(str, search, str);
+str = XRegExp.replace(str, search, replacer, scope);
+str = XRegExp.replace(str, search, replacer);
+
+str = XRegExp.replace(str, searchEx, str, scope);
+str = XRegExp.replace(str, searchEx, str);
+str = XRegExp.replace(str, searchEx, replacer, scope);
+str = XRegExp.replace(str, searchEx, replacer);
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+strArr = XRegExp.split(str, search, limit);
+strArr = XRegExp.split(str, search);
+strArr = XRegExp.split(str, searchEx, limit);
+strArr = XRegExp.split(str, searchEx);
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+bool = XRegExp.test(str, regex, pos, bool);
+bool = XRegExp.test(str, regex, pos);
+bool = XRegExp.test(str, regex);
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
+XRegExp.uninstall(obj);
+XRegExp.uninstall(str);
+
+regex = XRegExp.union(strArr, flags);
+regex = XRegExp.union(strArr);
+
+// --  --  --  --  --  --  --  --  --  --  --  --  --
+
diff --git a/xregexp/xregexp.d.ts b/xregexp/xregexp.d.ts
new file mode 100644
index 000000000..9e30a2d07
--- /dev/null
+++ b/xregexp/xregexp.d.ts
@@ -0,0 +1,62 @@
+// Type definitions for XRegExp 2.0.0
+// Project: http://xregexp.com
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'xregexp' {
+	// scopes: 'default', 'class', or 'all'
+	/*
+	 Native flags:
+	 g - global
+	 i - ignore case
+	 m - multiline anchors
+	 y - sticky (Firefox 3+)
+	 Additional XRegExp flags:
+	 n - explicit capture
+	 s - dot matches all (aka singleline)
+	 x - free-spacing and line comments (aka extended)
+	 */
+	export interface TokenOpts {
+		scope?: string;
+		trigger?: () => boolean;
+		customFlags?: string;
+	}
+
+	export function XRegExp(pattern: string, flags?: string): RegExp;
+	export function XRegExp(pattern: RegExp): RegExp;
+
+	export module XRegExp {
+		function addToken(regex: RegExp, handler: (matchArr: RegExpExecArray, scope: string) => string, options?: TokenOpts): void;
+
+		function build(pattern: string, subs: string[], flags?: string): RegExp;
+		function cache(pattern: string, flags?: string): RegExp;
+		function escape(str: string): string;
+		function exec(str: string, regex: RegExp, pos?: number, sticky?: boolean): RegExpExecArray;
+		function forEach(str: string, regex: RegExp, callback: (matchArr: RegExpExecArray, index: number, input: string, regexp: RegExp) => void, context?: Object): any;
+		function globalize(regex: RegExp): RegExp;
+
+		function install(options: string): void;
+		function install(options: Object): void;
+
+		function isInstalled(feature: string): boolean;
+		function isRegExp(value: any): boolean;
+		function matchChain(str: string, chain: RegExp[]): string[];
+		function matchRecursive(str: string, left: string, right: string, flags?: string, options?: Object): string[];
+
+		function replace(str: string, search: string, replacement: string, scope?: string): string;
+		function replace(str: string, search: string, replacement: Function, scope?: string): string;
+		function replace(str: string, search: RegExp, replacement: string, scope?: string): string;
+		function replace(str: string, search: RegExp, replacement: Function, scope?: string): string;
+
+		function split(str: string, separator: string, limit?: number): string[];
+		function split(str: string, separator: RegExp, limit?: number): string[];
+
+		function test(str: string, regex: RegExp, pos?: number, sticky?: boolean): boolean;
+
+		function uninstall(options: Object): void;
+		function uninstall(options: string): void;
+
+		function union(patterns: string[], flags?: string): RegExp;
+		var version: string;
+	}
+}

From 5dc86a3801ec0a8c2cc3396c67e45da086cea631 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Tue, 1 Apr 2014 21:22:36 +0200
Subject: [PATCH 269/309] fixed error in README.md for url-templates

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index ff46ce78c..1c8193680 100755
--- a/README.md
+++ b/README.md
@@ -272,7 +272,7 @@ List of Definitions
 * [Underscore-ko.js](https://github.com/kamranayub/UnderscoreKO) (by [Maurits Elbers](https://github.com/MagicMau))
 * [universal-analytics](https://github.com/peaksandpies/universal-analytics) (by [Bart van der Schoor](https://github.com/Bartvds))
 * [update-notifier](https://github.com/yeoman/update-notifier) (by [vvakame](https://github.com/vvakame))
-* [uri-templates](https://github.com/geraintluff/uri-variables) (by [Bart van der Schoor](https://github.com/Bartvds))
+* [uri-templates](https://github.com/geraintluff/uri-templates) (by [Bart van der Schoor](https://github.com/Bartvds))
 * [urlrouter](https://github.com/fengmk2/urlrouter) (by [Carlos Ballesteros Velasco](https://github.com/soywiz))
 * [UUID.js](https://github.com/LiosK/UUID.js) (by [Jason Jarrett](https://github.com/staxmanade))
 * [Valerie](https://github.com/davewatts/valerie) (by [Howard Richards](https://github.com/conficient))

From c6fcc96c17ba9315fa172635b584e96984b24a70 Mon Sep 17 00:00:00 2001
From: Horiuchi_H <horiuchi.g@gmail.com>
Date: Tue, 1 Apr 2014 12:37:43 -0700
Subject: [PATCH 270/309] add test file

---
 passport/passport-test.ts | 61 +++++++++++++++++++++++++++++++++++++++
 passport/passport.d.ts    | 60 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 121 insertions(+)
 create mode 100644 passport/passport-test.ts
 create mode 100644 passport/passport.d.ts

diff --git a/passport/passport-test.ts b/passport/passport-test.ts
new file mode 100644
index 000000000..f102b306e
--- /dev/null
+++ b/passport/passport-test.ts
@@ -0,0 +1,61 @@
+/// <reference path="passport.d.ts" />
+/// <reference path="../express/express.d.ts" />
+
+import express = require('express');
+import passport = require('passport');
+
+class TestStrategy implements passport.Strategy {
+  public name: string = 'test';
+  constructor() {}
+  authenticate(req: passport.Request) {}
+}
+
+passport.use(new TestStrategy());
+passport.framework('test');
+passport.serializeUser((user, done) => {});
+passport.deserializeUser((id, done) => {});
+
+passport.use(new TestStrategy())
+  .unuse('test')
+  .use(new TestStrategy())
+  .framework('test-fw');
+
+
+var app = express();
+app.configure(() => {
+  app.use(passport.initialize());
+  app.use(passport.session());
+});
+
+app.post('/login', 
+  passport.authenticate('local', { failureRedirect: '/login', failureFlash: true }),
+  function(req, res) {
+    res.redirect('/');
+  });
+
+app.post('/login', function(req: passport.Request, res: passport.Response, next: (err?: any) => void) {
+  passport.authenticate('local', function(err, user, info) {
+    if (err) { return next(err) }
+    if (!user) {
+      req.session.error = info.message;
+      return res.redirect('/login')
+    }
+    req.logIn(user, function(err) {
+      if (err) { return next(err); }
+      return res.redirect('/users/' + user.username);
+    });
+  })(req, res, next);
+});
+
+app.get('/logout', function(req: passport.Request, res: passport.Response) {
+  req.logout();
+  res.redirect('/');
+});
+
+function ensureAuthenticated(req: passport.Request, res: passport.Response, next: (err?: any) => void) {
+  if (req.isAuthenticated()) { return next(); }
+  if (req.isUnauthenticated()) {
+    res.redirect('/login');
+  }
+}
+
diff --git a/passport/passport.d.ts b/passport/passport.d.ts
new file mode 100644
index 000000000..ae401b252
--- /dev/null
+++ b/passport/passport.d.ts
@@ -0,0 +1,60 @@
+// Type definitions for Passport v0.2.0
+// Project: http://passportjs.org
+// Definitions by: Horiuchi_H <https://github.com/horiuchi/>
+// DefinitelyTyped: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../express/express.d.ts" />
+
+declare module 'passport' {
+    import express = require('express');
+
+    function use(strategy: Strategy): Passport;
+    function use(name: string, strategy: Strategy): Passport;
+    function unuse(name: string): Passport;
+    function framework(fw: string): Passport;
+    function initialize(options?: { userProperty: string; }): express.Handler;
+    function session(options?: { pauseStream: boolean; }): express.Handler;
+
+    function authenticate(strategy: string, options: Object, callback?: express.Handler): express.Handler;
+    function authenticate(strategy: string, callback2: (err: any, user: any, info: any) => void): express.Handler;
+    function authorize(strategy: string, options: Object, callback?: express.Handler): express.Handler;
+    function serializeUser(fn: (user: any, done: (err: any, id: any) => void) => void): void;
+    function deserializeUser(fn: (id: any, done: (err: any, user: any) => void) => void): void;
+    function transformAuthInfo(fn: (info: any, done: (err: any, info: any) => void) => void): void;
+
+    interface Passport {
+        use(strategy: Strategy): Passport;
+        use(name: string, strategy: Strategy): Passport;
+        unuse(name: string): Passport;
+        framework(fw: string): Passport;
+        initialize(options?: { userProperty: string; }): express.Handler;
+        session(options?: { pauseStream: boolean; }): express.Handler;
+
+        authenticate(strategy: string, callback2: (err: any, user: any, info: any) => void): express.Handler;
+        authenticate(strategy: string, options: Object, callback?: express.Handler): express.Handler;
+        authorize(strategy: string, options: Object, callback?: express.Handler): express.Handler;
+        serializeUser(fn: (user: any, done: (err: any, id: any) => void) => void): void;
+        deserializeUser(fn: (id: any, done: (err: any, user: any) => void) => void): void;
+        transformAuthInfo(fn: (info: any, done: (err: any, info: any) => void) => void): void;
+    }
+
+    interface Request extends express.Request {
+        login(user: any, done: (err: any) => void): void;
+        login(user: any, options: Object, done: (err: any) => void): void;
+        logIn(user: any, done: (err: any) => void): void;
+        logIn(user: any, options: Object, done: (err: any) => void): void;
+
+        logout(): void;
+        logOut(): void;
+
+        isAuthenticated(): boolean;
+        isUnauthenticated(): boolean;
+    }
+    interface Response extends express.Response {}
+
+    interface Strategy {
+        name?: string;
+        authenticate(req: Request, options?: Object): void;
+    }
+}
+

From a66b047ffa4b0937acfc76c85e3b3820f2449dcf Mon Sep 17 00:00:00 2001
From: Horiuchi_H <horiuchi.g@gmail.com>
Date: Tue, 1 Apr 2014 18:42:18 -0700
Subject: [PATCH 271/309] add passport library

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 30c81dd14..0b06d7a0c 100755
--- a/README.md
+++ b/README.md
@@ -218,6 +218,7 @@ List of Definitions
 * [NProgress](https://github.com/rstacruz/nprogress) (by [Judah Gabriel Himango](https://github.com/judahgabriel))
 * [Numeral.js](https://github.com/adamwdraper/Numeral-js) (by [Vincent Bortone](https://github.com/vbortone/))
 * [OpenLayers](https://github.com/openlayers/openlayers) (by [Ilya Bolkhovsky](https://github.com/bolhovsky/))
+* [Passport](http://passportjs.org/) (by [Hiroki Horiuchi](https://github.com/horiuchi/))
 * [Parallel.js](https://github.com/adambom/parallel.js) (by [Josh Baldwin](https://github.com/jbaldwin))
 * [PDF.js](https://github.com/mozilla/pdf.js) (by [Josh Baldwin](https://github.com/jbaldwin))
 * [Persona](http://www.mozilla.org/en-US/persona) (by [James Frasca](https://github.com/Nycto))

From 2e37cabb317eb5d50b6f2014d5680dbf71a099c5 Mon Sep 17 00:00:00 2001
From: satoru kimura <s_kimura@sa.il24.net>
Date: Wed, 2 Apr 2014 15:08:22 +0900
Subject: [PATCH 272/309] Update Hammer.js to v1.0.10.

---
 hammerjs/hammerjs-tests.ts |  47 +++++++++++-----
 hammerjs/hammerjs.d.ts     | 110 ++++++++++++++++++++++++++-----------
 2 files changed, 111 insertions(+), 46 deletions(-)

diff --git a/hammerjs/hammerjs-tests.ts b/hammerjs/hammerjs-tests.ts
index bb9324fdd..23fa92d4d 100644
--- a/hammerjs/hammerjs-tests.ts
+++ b/hammerjs/hammerjs-tests.ts
@@ -1,32 +1,49 @@
 /// <reference path="../jquery/jquery.d.ts"/>
 /// <reference path="hammerjs.d.ts" />
 
-var hammer = new Hammer(document.getElementById("container"));
-hammer.ondragstart = function (ev) { };
-hammer.ondrag = function (ev) { };
-hammer.ondragend = function (ev) { };
-hammer.onswipe = function (ev) { };
+// plugin check
+if (!Hammer.HAS_TOUCHEVENTS && !Hammer.HAS_POINTEREVENTS) {
+    Hammer.plugins.fakeMultitouch();
+    Hammer.plugins.showTouches();
+}
 
-hammer.ontap = function (ev) { };
-hammer.ondoubletap = function (ev) { };
-hammer.onhold = function (ev) { };
+// instance method check
+var el = document.getElementById("container");
 
-hammer.ontransformstart = function (ev) { };
-hammer.ontransform = function (ev) { };
-hammer.ontransformend = function (ev) { };
+Hammer(el).on("doubletap", function () {
+    alert('you doubletapped me!');
+});
 
-hammer.onrelease = function (ev) { };
+var hammertime = Hammer(el, {
+    drag: false,
+    transform: false
+}).off("tap", function (event:HammerEvent) {
+    alert('hello!');
+});
 
+hammertime.enable(false);
+
+hammertime.on("touch drag transform", function (ev: HammerEvent) {
+    if (!ev.gesture) {
+        return;
+    }
+
+    if (ev.gesture.deltaX >= 20) {
+        hammertime.trigger("swipe", ev.gesture);
+    }
+});
+
+// jQuery check
 $("#element")
    .hammer({
        // Options
    })
-   .bind("tap", function (ev) {
+   .on("tap", function (ev) {
        console.log(ev);
    });
 
 $("#container").hammer({
     prevent_default: false,
-    drag_vertical: false
-}).bind("hold tap doubletap transformstart transform transformend dragstart drag dragend release swipe", function (ev) {
+    drag_block_vertical: false
+}).on("hold tap doubletap transformstart transform transformend dragstart drag dragend release swipe", function (ev) {
 });
\ No newline at end of file
diff --git a/hammerjs/hammerjs.d.ts b/hammerjs/hammerjs.d.ts
index 722598153..72f09a5e0 100644
--- a/hammerjs/hammerjs.d.ts
+++ b/hammerjs/hammerjs.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Hammer.js 1.0.5
+// Type definitions for Hammer.js 1.0.10
 // Project: http://eightmedia.github.com/hammer.js/
 // Definitions by: Boris Yankov <https://github.com/borisyankov/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -6,6 +6,46 @@
 
 /// <reference path="../jquery/jquery.d.ts"/>
 
+declare var Hammer: HammerStatic;
+
+interface HammerStatic {
+    (element: any, options?: HammerOptions): HammerInstance;
+
+    VERSION: number;
+    HAS_POINTEREVENTS: boolean;
+    HAS_TOUCHEVENTS: boolean;
+    UPDATE_VELOCITY_INTERVAL: number;
+    POINTER_MOUSE: HammerPointerType;
+    POINTER_TOUCH: HammerPointerType;
+    POINTER_PEN: HammerPointerType;
+
+    DIRECTION_UP: HammerDirectionType;
+    DIRECTION_DOWN: HammerDirectionType;
+    DIRECTION_LEFT: HammerDirectionType;
+    DIRECTION_RIGH: HammerDirectionType;
+
+    EVENT_START: HammerTouchEventState;
+    EVENT_MOVE: HammerTouchEventState;
+    EVENT_END: HammerTouchEventState;
+
+    plugins: any;
+    gestures: any;
+    READY: boolean;
+
+
+}
+
+declare class HammerInstance {
+    constructor(element: any, options?: HammerOptions);
+
+    on(gesture: string, handler: (event: HammerEvent) => void): HammerInstance;
+    off(gesture: string, handler: (event: HammerEvent) => void): HammerInstance;
+    enable(toggle: boolean): HammerInstance;
+
+    // You shouldn't use this, this is an internally method use by the gestures. Only use it when you know what you're doing! You can read the sourcecode about how to use this.
+    trigger(gesture: string, eventData: HammerGestureEventData): HammerInstance;
+}
+
 // Gesture Options : https://github.com/EightMedia/hammer.js/wiki/Getting-Started#gesture-options
 interface HammerOptions {
     drag?: boolean;
@@ -38,44 +78,52 @@ interface HammerOptions {
     transform_min_scale?: number;
 }
 
+interface HammerGestureEventData {
+    timestamp: number;
+    target: HTMLElement;
+    touches: HammerPoint[];
+    pointerType: HammerPointerType;
+    center: HammerPoint;
+    deltaTime: number;
+    deltaX: number;
+    deltaY: number;
+    velocityX: number;
+    velocityY: number;
+    angle: number;
+    interimAngle: number;
+    direction: HammerDirectionType;
+    interimDirection: HammerDirectionType;
+    distance: number;
+    scale: number;
+    rotation: number;
+    eventType: HammerTouchEventState;
+    srcEvent: any;
+    startEvent: any;
+
+    stopPropagation(): void;
+    preventDefault(): void;
+    stopDetect(): void;
+}
+
 interface HammerPoint {
-    x: number;
-    y: number;
+    pageX: number;
+    pageY: number;
 }
 
 interface HammerEvent {
-    originalEvent: Event;
-    position: HammerPoint;
-    touches: HammerPoint[];
+    type: string;
+    gesture: HammerGestureEventData;
+
+    stopPropagation(): void;
+    preventDefault(): void;
+
 }
 
-interface HammertTransformEvent extends HammerEvent {
-    scale: number;
-    rotation: number;
+declare enum HammerPointerType {
 }
-
-interface HammerDirectionEvent extends HammerEvent {
-    angle: number;
-    direction: string;
-    distance: number;
-    distanceX: number;
-    distanceY: number;
+declare enum HammerDirectionType {
 }
-
-declare class Hammer {
-    constructor (element: any, options?: HammerOptions);
-
-    ondragstart: (event: HammerDirectionEvent) => void;
-    ondrag: (event: HammerDirectionEvent) => void;
-    ondragend: (event: HammerDirectionEvent) => void;
-    onswipe: (event: HammerDirectionEvent) => void;
-    ontap: (event: HammerEvent) => void;
-    ondoubletap: (event: HammerEvent) => void;
-    onhold: (event: HammerEvent) => void;
-    ontransformstart: (event: HammertTransformEvent) => void;
-    ontransform: (event:  HammertTransformEvent) => void;
-    ontransformend: (event: HammertTransformEvent) => void;
-    onrelease: (event: HammerEvent) => void;
+declare enum HammerTouchEventState {
 }
 
 interface JQuery {

From aacdbf04b3af5826e08dac683d06349792705f35 Mon Sep 17 00:00:00 2001
From: Jacob Eggers <jacob.eggers@wellsfargo.com>
Date: Thu, 3 Apr 2014 01:35:04 +0600
Subject: [PATCH 273/309] Adding noTracking function definition to EntityQuery.

---
 breeze/breeze.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/breeze/breeze.d.ts b/breeze/breeze.d.ts
index f4f7ff8ce..3614e3446 100644
--- a/breeze/breeze.d.ts
+++ b/breeze/breeze.d.ts
@@ -502,6 +502,7 @@ declare module breeze {
         static fromEntityKey(entityKey: EntityKey): EntityQuery;
         static fromEntityNavigation(entity: Entity, navigationProperty: NavigationProperty): EntityQuery;
         inlineCount(enabled?: boolean): EntityQuery;
+        noTracking(enabled: boolean): EntityQuery;
         orderBy(propertyPaths: string): EntityQuery;
         orderBy(propertyPaths: string[]): EntityQuery;
         orderByDesc(propertyPaths: string): EntityQuery;

From 74ba04beb34a98066e0e1ca556e9dd3357bfff33 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Stroi=C5=84ski?= <pol84@live.com>
Date: Thu, 3 Apr 2014 00:32:35 +0100
Subject: [PATCH 274/309] Add dependency-less define overload

---
 requirejs/require.d.ts | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/requirejs/require.d.ts b/requirejs/require.d.ts
index a85699c77..6b2cc125f 100644
--- a/requirejs/require.d.ts
+++ b/requirejs/require.d.ts
@@ -322,6 +322,14 @@ interface RequireDefine {
 	*	callback return module definition
 	**/
 	(name: string, deps: string[], ready: Function): void;
+
+	/**
+	* Define a module with a name.
+	* @param name The name of the module.
+	* @param ready Callback function when the dependencies are loaded.
+	*	callback return module definition
+	**/
+	(name: string, ready: Function): void;
 }
 
 // Ambient declarations for 'require' and 'define'

From a732bb1c40d34e125ac462b1529119e7ccdcb2ce Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Thu, 3 Apr 2014 09:07:26 +0900
Subject: [PATCH 275/309] added TypeScript 1.0 LKG to
 _infrastructure/tests/typescript/1.0.0/

---
 .../tests/typescript/1.0.0/lib.d.ts           | 14958 ++++
 _infrastructure/tests/typescript/1.0.0/tsc    |     2 +
 _infrastructure/tests/typescript/1.0.0/tsc.js | 62789 ++++++++++++++++
 .../tests/typescript/1.0.0/typescript.js      | 61379 +++++++++++++++
 4 files changed, 139128 insertions(+)
 create mode 100644 _infrastructure/tests/typescript/1.0.0/lib.d.ts
 create mode 100644 _infrastructure/tests/typescript/1.0.0/tsc
 create mode 100644 _infrastructure/tests/typescript/1.0.0/tsc.js
 create mode 100644 _infrastructure/tests/typescript/1.0.0/typescript.js

diff --git a/_infrastructure/tests/typescript/1.0.0/lib.d.ts b/_infrastructure/tests/typescript/1.0.0/lib.d.ts
new file mode 100644
index 000000000..25b453173
--- /dev/null
+++ b/_infrastructure/tests/typescript/1.0.0/lib.d.ts
@@ -0,0 +1,14958 @@
+/* *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved. 
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0  
+ 
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
+MERCHANTABLITY OR NON-INFRINGEMENT. 
+ 
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+/// <reference no-default-lib="true"/>
+
+/////////////////////////////
+/// ECMAScript APIs
+/////////////////////////////
+
+declare var NaN: number;
+declare var Infinity: number;
+
+/**
+  * Evaluates JavaScript code and executes it. 
+  * @param x A String value that contains valid JavaScript code.
+  */
+declare function eval(x: string): any;
+
+/**
+  * Converts A string to an integer.
+  * @param s A string to convert into a number.
+  * @param radix A value between 2 and 36 that specifies the base of the number in numString. 
+  * If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal.
+  * All other strings are considered decimal.
+  */
+declare function parseInt(s: string, radix?: number): number;
+
+/**
+  * Converts a string to a floating-point number. 
+  * @param string A string that contains a floating-point number. 
+  */
+declare function parseFloat(string: string): number;
+
+/**
+  * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a number). 
+  * @param number A numeric value.
+  */
+declare function isNaN(number: number): boolean;
+
+/** 
+  * Determines whether a supplied number is finite.
+  * @param number Any numeric value.
+  */
+declare function isFinite(number: number): boolean;
+
+/**
+  * Gets the unencoded version of an encoded Uniform Resource Identifier (URI).
+  * @param encodedURI A value representing an encoded URI.
+  */
+declare function decodeURI(encodedURI: string): string;
+
+/**
+  * Gets the unencoded version of an encoded component of a Uniform Resource Identifier (URI).
+  * @param encodedURIComponent A value representing an encoded URI component.
+  */
+declare function decodeURIComponent(encodedURIComponent: string): string;
+
+/** 
+  * Encodes a text string as a valid Uniform Resource Identifier (URI)
+  * @param uri A value representing an encoded URI.
+  */
+declare function encodeURI(uri: string): string;
+
+/**
+  * Encodes a text string as a valid component of a Uniform Resource Identifier (URI).
+  * @param uriComponent A value representing an encoded URI component.
+  */
+declare function encodeURIComponent(uriComponent: string): string;
+
+interface PropertyDescriptor {
+    configurable?: boolean;
+    enumerable?: boolean;
+    value?: any;
+    writable?: boolean;
+    get? (): any;
+    set? (v: any): void;
+}
+
+interface PropertyDescriptorMap {
+    [s: string]: PropertyDescriptor;
+}
+
+interface Object {
+    /** The initial value of Object.prototype.constructor is the standard built-in Object constructor. */
+    constructor: Function;
+
+    /** Returns a string representation of an object. */
+    toString(): string;
+
+    /** Returns a date converted to a string using the current locale. */
+    toLocaleString(): string;
+
+    /** Returns the primitive value of the specified object. */
+    valueOf(): Object;
+
+    /**
+      * Determines whether an object has a property with the specified name. 
+      * @param v A property name.
+      */
+    hasOwnProperty(v: string): boolean;
+
+    /**
+      * Determines whether an object exists in another object's prototype chain. 
+      * @param v Another object whose prototype chain is to be checked.
+      */
+    isPrototypeOf(v: Object): boolean;
+
+    /** 
+      * Determines whether a specified property is enumerable.
+      * @param v A property name.
+      */
+    propertyIsEnumerable(v: string): boolean;
+}
+
+/**
+  * Provides functionality common to all JavaScript objects.
+  */
+declare var Object: {
+    new (value?: any): Object;
+    (): any;
+    (value: any): any;
+
+    /** A reference to the prototype for a class of objects. */
+    prototype: Object;
+
+    /** 
+      * Returns the prototype of an object. 
+      * @param o The object that references the prototype.
+      */
+    getPrototypeOf(o: any): any;
+
+    /**
+      * Gets the own property descriptor of the specified object. 
+      * An own property descriptor is one that is defined directly on the object and is not inherited from the object's prototype. 
+      * @param o Object that contains the property.
+      * @param p Name of the property.
+    */
+    getOwnPropertyDescriptor(o: any, p: string): PropertyDescriptor;
+
+    /** 
+      * Returns the names of the own properties of an object. The own properties of an object are those that are defined directly 
+      * on that object, and are not inherited from the object's prototype. The properties of an object include both fields (objects) and functions.
+      * @param o Object that contains the own properties.
+      */
+    getOwnPropertyNames(o: any): string[];
+
+    /** 
+      * Creates an object that has the specified prototype, and that optionally contains specified properties.
+      * @param o Object to use as a prototype. May be null
+      * @param properties JavaScript object that contains one or more property descriptors. 
+      */
+    create(o: any, properties?: PropertyDescriptorMap): any;
+
+    /**
+      * Adds a property to an object, or modifies attributes of an existing property. 
+      * @param o Object on which to add or modify the property. This can be a native JavaScript object (that is, a user-defined object or a built in object) or a DOM object.
+      * @param p The property name.
+      * @param attributes Descriptor for the property. It can be for a data property or an accessor property.
+      */
+    defineProperty(o: any, p: string, attributes: PropertyDescriptor): any;
+
+    /**
+      * Adds one or more properties to an object, and/or modifies attributes of existing properties. 
+      * @param o Object on which to add or modify the properties. This can be a native JavaScript object or a DOM object.
+      * @param properties JavaScript object that contains one or more descriptor objects. Each descriptor object describes a data property or an accessor property.
+      */
+    defineProperties(o: any, properties: PropertyDescriptorMap): any;
+
+    /**
+      * Prevents the modification of attributes of existing properties, and prevents the addition of new properties.
+      * @param o Object on which to lock the attributes. 
+      */
+    seal(o: any): any;
+
+    /**
+      * Prevents the modification of existing property attributes and values, and prevents the addition of new properties.
+      * @param o Object on which to lock the attributes.
+      */
+    freeze(o: any): any;
+
+    /**
+      * Prevents the addition of new properties to an object.
+      * @param o Object to make non-extensible. 
+      */
+    preventExtensions(o: any): any;
+
+    /**
+      * Returns true if existing property attributes cannot be modified in an object and new properties cannot be added to the object.
+      * @param o Object to test. 
+      */
+    isSealed(o: any): boolean;
+
+    /**
+      * Returns true if existing property attributes and values cannot be modified in an object, and new properties cannot be added to the object.
+      * @param o Object to test.  
+      */
+    isFrozen(o: any): boolean;
+
+    /**
+      * Returns a value that indicates whether new properties can be added to an object.
+      * @param o Object to test. 
+      */
+    isExtensible(o: any): boolean;
+
+    /**
+      * Returns the names of the enumerable properties and methods of an object.
+      * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+      */
+    keys(o: any): string[];
+}
+
+/**
+  * Creates a new function.
+  */
+interface Function {
+    /**
+      * Calls the function, substituting the specified object for the this value of the function, and the specified array for the arguments of the function.
+      * @param thisArg The object to be used as the this object.
+      * @param argArray A set of arguments to be passed to the function.
+      */
+    apply(thisArg: any, argArray?: any): any;
+
+    /**
+      * Calls a method of an object, substituting another object for the current object.
+      * @param thisArg The object to be used as the current object.
+      * @param argArray A list of arguments to be passed to the method.
+      */
+    call(thisArg: any, ...argArray: any[]): any;
+
+    /**
+      * For a given function, creates a bound function that has the same body as the original function. 
+      * The this object of the bound function is associated with the specified object, and has the specified initial parameters.
+      * @param thisArg An object to which the this keyword can refer inside the new function.
+      * @param argArray A list of arguments to be passed to the new function.
+      */
+    bind(thisArg: any, ...argArray: any[]): any;
+
+    prototype: any;
+    length: number;
+
+    // Non-standard extensions
+    arguments: any;
+    caller: Function;
+}
+
+declare var Function: {
+    /** 
+      * Creates a new function.
+      * @param args A list of arguments the function accepts.
+      */
+    new (...args: string[]): Function;
+    (...args: string[]): Function;
+    prototype: Function;
+}
+
+interface IArguments {
+    [index: number]: any;
+    length: number;
+    callee: Function;
+}
+
+interface String {
+    /** Returns a string representation of a string. */
+    toString(): string;
+
+    /**
+      * Returns the character at the specified index.
+      * @param pos The zero-based index of the desired character.
+      */
+    charAt(pos: number): string;
+
+    /** 
+      * Returns the Unicode value of the character at the specified location.
+      * @param index The zero-based index of the desired character. If there is no character at the specified index, NaN is returned.
+      */
+    charCodeAt(index: number): number;
+
+    /**
+      * Returns a string that contains the concatenation of two or more strings.
+      * @param strings The strings to append to the end of the string.  
+      */
+    concat(...strings: string[]): string;
+
+    /**
+      * Returns the position of the first occurrence of a substring. 
+      * @param searchString The substring to search for in the string
+      * @param position The index at which to begin searching the String object. If omitted, search starts at the beginning of the string.
+      */
+    indexOf(searchString: string, position?: number): number;
+
+    /**
+      * Returns the last occurrence of a substring in the string.
+      * @param searchString The substring to search for.
+      * @param position The index at which to begin searching. If omitted, the search begins at the end of the string.
+      */
+    lastIndexOf(searchString: string, position?: number): number;
+
+    /**
+      * Determines whether two strings are equivalent in the current locale.
+      * @param that String to compare to target string
+      */
+    localeCompare(that: string): number;
+
+    /** 
+      * Matches a string with a regular expression, and returns an array containing the results of that search.
+      * @param regexp A variable name or string literal containing the regular expression pattern and flags.
+      */
+    match(regexp: string): string[];
+
+    /** 
+      * Matches a string with a regular expression, and returns an array containing the results of that search.
+      * @param regexp A regular expression object that contains the regular expression pattern and applicable flags. 
+      */
+    match(regexp: RegExp): string[];
+
+    /**
+      * Replaces text in a string, using a regular expression or search string.
+      * @param searchValue A String object or string literal that represents the regular expression
+      * @param replaceValue A String object or string literal containing the text to replace for every successful match of rgExp in stringObj.
+      */
+    replace(searchValue: string, replaceValue: string): string;
+
+    /**
+      * Replaces text in a string, using a regular expression or search string.
+      * @param searchValue A String object or string literal that represents the regular expression
+      * @param replaceValue A function that returns the replacement text.
+      */
+    replace(searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string;
+
+    /**
+      * Replaces text in a string, using a regular expression or search string.
+      * @param searchValue A Regular Expression object containing the regular expression pattern and applicable flags
+      * @param replaceValue A String object or string literal containing the text to replace for every successful match of rgExp in stringObj.
+      */
+    replace(searchValue: RegExp, replaceValue: string): string;
+
+    /**
+      * Replaces text in a string, using a regular expression or search string.
+      * @param searchValue A Regular Expression object containing the regular expression pattern and applicable flags
+      * @param replaceValue A function that returns the replacement text.
+      */
+    replace(searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string;
+
+    /**
+      * Finds the first substring match in a regular expression search.
+      * @param regexp The regular expression pattern and applicable flags. 
+      */
+    search(regexp: string): number;
+
+    /**
+      * Finds the first substring match in a regular expression search.
+      * @param regexp The regular expression pattern and applicable flags. 
+      */
+    search(regexp: RegExp): number;
+
+    /**
+      * Returns a section of a string.
+      * @param start The index to the beginning of the specified portion of stringObj. 
+      * @param end The index to the end of the specified portion of stringObj. The substring includes the characters up to, but not including, the character indicated by end. 
+      * If this value is not specified, the substring continues to the end of stringObj.
+      */
+    slice(start?: number, end?: number): string;
+
+    /**
+      * Split a string into substrings using the specified separator and return them as an array.
+      * @param separator A string that identifies character or characters to use in separating the string. If omitted, a single-element array containing the entire string is returned. 
+      * @param limit A value used to limit the number of elements returned in the array.
+      */
+    split(separator: string, limit?: number): string[];
+
+    /**
+      * Split a string into substrings using the specified separator and return them as an array.
+      * @param separator A Regular Express that identifies character or characters to use in separating the string. If omitted, a single-element array containing the entire string is returned. 
+      * @param limit A value used to limit the number of elements returned in the array.
+      */
+    split(separator: RegExp, limit?: number): string[];
+
+    /**
+      * Returns the substring at the specified location within a String object. 
+      * @param start The zero-based index number indicating the beginning of the substring.
+      * @param end Zero-based index number indicating the end of the substring. The substring includes the characters up to, but not including, the character indicated by end.
+      * If end is omitted, the characters from start through the end of the original string are returned.
+      */
+    substring(start: number, end?: number): string;
+
+    /** Converts all the alphabetic characters in a string to lowercase. */
+    toLowerCase(): string;
+
+    /** Converts all alphabetic characters to lowercase, taking into account the host environment's current locale. */
+    toLocaleLowerCase(): string;
+
+    /** Converts all the alphabetic characters in a string to uppercase. */
+    toUpperCase(): string;
+
+    /** Returns a string where all alphabetic characters have been converted to uppercase, taking into account the host environment's current locale. */
+    toLocaleUpperCase(): string;
+
+    /** Removes the leading and trailing white space and line terminator characters from a string. */
+    trim(): string;
+
+    /** Returns the length of a String object. */
+    length: number;
+
+    // IE extensions
+    /**
+      * Gets a substring beginning at the specified location and having the specified length.
+      * @param from The starting position of the desired substring. The index of the first character in the string is zero.
+      * @param length The number of characters to include in the returned substring.
+      */
+    substr(from: number, length?: number): string;
+
+    [index: number]: string;
+}
+
+/** 
+  * Allows manipulation and formatting of text strings and determination and location of substrings within strings. 
+  */
+declare var String: {
+    new (value?: any): String;
+    (value?: any): string;
+    prototype: String;
+    fromCharCode(...codes: number[]): string;
+}
+
+interface Boolean {
+}
+declare var Boolean: {
+    new (value?: any): Boolean;
+    (value?: any): boolean;
+    prototype: Boolean;
+}
+
+interface Number {
+    /**
+      * Returns a string representation of an object.
+      * @param radix Specifies a radix for converting numeric values to strings. This value is only used for numbers.
+      */
+    toString(radix?: number): string;
+
+    /** 
+      * Returns a string representing a number in fixed-point notation.
+      * @param fractionDigits Number of digits after the decimal point. Must be in the range 0 - 20, inclusive.
+      */
+    toFixed(fractionDigits?: number): string;
+
+    /**
+      * Returns a string containing a number represented in exponential notation.
+      * @param fractionDigits Number of digits after the decimal point. Must be in the range 0 - 20, inclusive.
+      */
+    toExponential(fractionDigits?: number): string;
+
+    /**
+      * Returns a string containing a number represented either in exponential or fixed-point notation with a specified number of digits.
+      * @param precision Number of significant digits. Must be in the range 1 - 21, inclusive.
+      */
+    toPrecision(precision?: number): string;
+}
+
+/** An object that represents a number of any kind. All JavaScript numbers are 64-bit floating-point numbers. */
+declare var Number: {
+    new (value?: any): Number;
+    (value?: any): number;
+    prototype: Number;
+
+    /** The largest number that can be represented in JavaScript. Equal to approximately 1.79E+308. */
+    MAX_VALUE: number;
+
+    /** The closest number to zero that can be represented in JavaScript. Equal to approximately 5.00E-324. */
+    MIN_VALUE: number;
+
+    /** 
+      * A value that is not a number.
+      * In equality comparisons, NaN does not equal any value, including itself. To test whether a value is equivalent to NaN, use the isNaN function.
+      */
+    NaN: number;
+
+    /** 
+      * A value that is less than the largest negative number that can be represented in JavaScript.
+      * JavaScript displays NEGATIVE_INFINITY values as -infinity. 
+      */
+    NEGATIVE_INFINITY: number;
+
+    /**
+      * A value greater than the largest number that can be represented in JavaScript. 
+      * JavaScript displays POSITIVE_INFINITY values as infinity. 
+      */
+    POSITIVE_INFINITY: number;
+}
+
+interface Math {
+    /** The mathematical constant e. This is Euler's number, the base of natural logarithms. */
+    E: number;
+    /** The natural logarithm of 10. */
+    LN10: number;
+    /** The natural logarithm of 2. */
+    LN2: number;
+    /** The base-2 logarithm of e. */
+    LOG2E: number;
+    /** The base-10 logarithm of e. */
+    LOG10E: number;
+    /** Pi. This is the ratio of the circumference of a circle to its diameter. */
+    PI: number;
+    /** The square root of 0.5, or, equivalently, one divided by the square root of 2. */
+    SQRT1_2: number;
+    /** The square root of 2. */
+    SQRT2: number;
+    /**
+      * Returns the absolute value of a number (the value without regard to whether it is positive or negative). 
+      * For example, the absolute value of -5 is the same as the absolute value of 5.
+      * @param x A numeric expression for which the absolute value is needed.
+      */
+    abs(x: number): number;
+    /**
+      * Returns the arc cosine (or inverse cosine) of a number. 
+      * @param x A numeric expression.
+      */
+    acos(x: number): number;
+    /** 
+      * Returns the arcsine of a number. 
+      * @param x A numeric expression.
+      */
+    asin(x: number): number;
+    /**
+      * Returns the arctangent of a number. 
+      * @param x A numeric expression for which the arctangent is needed.
+      */
+    atan(x: number): number;
+    /**
+      * Returns the angle (in radians) from the X axis to a point (y,x).
+      * @param y A numeric expression representing the cartesian y-coordinate.
+      * @param x A numeric expression representing the cartesian x-coordinate.
+      */
+    atan2(y: number, x: number): number;
+    /**
+      * Returns the smallest number greater than or equal to its numeric argument. 
+      * @param x A numeric expression.
+      */
+    ceil(x: number): number;
+    /**
+      * Returns the cosine of a number. 
+      * @param x A numeric expression that contains an angle measured in radians.
+      */
+    cos(x: number): number;
+    /**
+      * Returns e (the base of natural logarithms) raised to a power. 
+      * @param x A numeric expression representing the power of e.
+      */
+    exp(x: number): number;
+    /**
+      * Returns the greatest number less than or equal to its numeric argument. 
+      * @param x A numeric expression.
+      */
+    floor(x: number): number;
+    /**
+      * Returns the natural logarithm (base e) of a number. 
+      * @param x A numeric expression.
+      */
+    log(x: number): number;
+    /**
+      * Returns the larger of a set of supplied numeric expressions. 
+      * @param values Numeric expressions to be evaluated.
+      */
+    max(...values: number[]): number;
+    /**
+      * Returns the smaller of a set of supplied numeric expressions. 
+      * @param values Numeric expressions to be evaluated.
+      */
+    min(...values: number[]): number;
+    /**
+      * Returns the value of a base expression taken to a specified power. 
+      * @param x The base value of the expression.
+      * @param y The exponent value of the expression.
+      */
+    pow(x: number, y: number): number;
+    /** Returns a pseudorandom number between 0 and 1. */
+    random(): number;
+    /** 
+      * Returns a supplied numeric expression rounded to the nearest number.
+      * @param x The value to be rounded to the nearest number.
+      */
+    round(x: number): number;
+    /**
+      * Returns the sine of a number.
+      * @param x A numeric expression that contains an angle measured in radians.
+      */
+    sin(x: number): number;
+    /**
+      * Returns the square root of a number.
+      * @param x A numeric expression.
+      */
+    sqrt(x: number): number;
+    /**
+      * Returns the tangent of a number.
+      * @param x A numeric expression that contains an angle measured in radians.
+      */
+    tan(x: number): number;
+}
+/** An intrinsic object that provides basic mathematics functionality and constants. */
+declare var Math: Math;
+
+/** Enables basic storage and retrieval of dates and times. */
+interface Date {
+    /** Returns a string representation of a date. The format of the string depends on the locale. */
+    toString(): string;
+    /** Returns a date as a string value. */
+    toDateString(): string;
+    /** Returns a time as a string value. */
+    toTimeString(): string;
+    /** Returns a value as a string value appropriate to the host environment's current locale. */
+    toLocaleString(): string;
+    /** Returns a date as a string value appropriate to the host environment's current locale. */
+    toLocaleDateString(): string;
+    /** Returns a time as a string value appropriate to the host environment's current locale. */
+    toLocaleTimeString(): string;
+    /** Returns the stored time value in milliseconds since midnight, January 1, 1970 UTC. */
+    valueOf(): number;
+    /** Gets the time value in milliseconds. */
+    getTime(): number;
+    /** Gets the year, using local time. */
+    getFullYear(): number;
+    /** Gets the year using Universal Coordinated Time (UTC). */
+    getUTCFullYear(): number;
+    /** Gets the month, using local time. */
+    getMonth(): number;
+    /** Gets the month of a Date object using Universal Coordinated Time (UTC). */
+    getUTCMonth(): number;
+    /** Gets the day-of-the-month, using local time. */
+    getDate(): number;
+    /** Gets the day-of-the-month, using Universal Coordinated Time (UTC). */
+    getUTCDate(): number;
+    /** Gets the day of the week, using local time. */
+    getDay(): number;
+    /** Gets the day of the week using Universal Coordinated Time (UTC). */
+    getUTCDay(): number;
+    /** Gets the hours in a date, using local time. */
+    getHours(): number;
+    /** Gets the hours value in a Date object using Universal Coordinated Time (UTC). */
+    getUTCHours(): number;
+    /** Gets the minutes of a Date object, using local time. */
+    getMinutes(): number;
+    /** Gets the minutes of a Date object using Universal Coordinated Time (UTC). */
+    getUTCMinutes(): number;
+    /** Gets the seconds of a Date object, using local time. */
+    getSeconds(): number;
+    /** Gets the seconds of a Date object using Universal Coordinated Time (UTC). */
+    getUTCSeconds(): number;
+    /** Gets the milliseconds of a Date, using local time. */
+    getMilliseconds(): number;
+    /** Gets the milliseconds of a Date object using Universal Coordinated Time (UTC). */
+    getUTCMilliseconds(): number;
+    /** Gets the difference in minutes between the time on the local computer and Universal Coordinated Time (UTC). */
+    getTimezoneOffset(): number;
+    /** 
+      * Sets the date and time value in the Date object.
+      * @param time A numeric value representing the number of elapsed milliseconds since midnight, January 1, 1970 GMT. 
+      */
+    setTime(time: number): number;
+    /**
+      * Sets the milliseconds value in the Date object using local time. 
+      * @param ms A numeric value equal to the millisecond value.
+      */
+    setMilliseconds(ms: number): number;
+    /** 
+      * Sets the milliseconds value in the Date object using Universal Coordinated Time (UTC).
+      * @param ms A numeric value equal to the millisecond value. 
+      */
+    setUTCMilliseconds(ms: number): number;
+
+    /**
+      * Sets the seconds value in the Date object using local time. 
+      * @param sec A numeric value equal to the seconds value.
+      * @param ms A numeric value equal to the milliseconds value.
+      */
+    setSeconds(sec: number, ms?: number): number;
+    /**
+      * Sets the seconds value in the Date object using Universal Coordinated Time (UTC).
+      * @param sec A numeric value equal to the seconds value.
+      * @param ms A numeric value equal to the milliseconds value.
+      */
+    setUTCSeconds(sec: number, ms?: number): number;
+    /**
+      * Sets the minutes value in the Date object using local time. 
+      * @param min A numeric value equal to the minutes value. 
+      * @param sec A numeric value equal to the seconds value. 
+      * @param ms A numeric value equal to the milliseconds value.
+      */
+    setMinutes(min: number, sec?: number, ms?: number): number;
+    /**
+      * Sets the minutes value in the Date object using Universal Coordinated Time (UTC).
+      * @param min A numeric value equal to the minutes value. 
+      * @param sec A numeric value equal to the seconds value. 
+      * @param ms A numeric value equal to the milliseconds value.
+      */
+    setUTCMinutes(min: number, sec?: number, ms?: number): number;
+    /**
+      * Sets the hour value in the Date object using local time.
+      * @param hours A numeric value equal to the hours value.
+      * @param min A numeric value equal to the minutes value.
+      * @param sec A numeric value equal to the seconds value. 
+      * @param ms A numeric value equal to the milliseconds value.
+      */
+    setHours(hours: number, min?: number, sec?: number, ms?: number): number;
+    /**
+      * Sets the hours value in the Date object using Universal Coordinated Time (UTC).
+      * @param hours A numeric value equal to the hours value.
+      * @param min A numeric value equal to the minutes value.
+      * @param sec A numeric value equal to the seconds value. 
+      * @param ms A numeric value equal to the milliseconds value.
+      */
+    setUTCHours(hours: number, min?: number, sec?: number, ms?: number): number;
+    /**
+      * Sets the numeric day-of-the-month value of the Date object using local time. 
+      * @param date A numeric value equal to the day of the month.
+      */
+    setDate(date: number): number;
+    /** 
+      * Sets the numeric day of the month in the Date object using Universal Coordinated Time (UTC).
+      * @param date A numeric value equal to the day of the month. 
+      */
+    setUTCDate(date: number): number;
+    /** 
+      * Sets the month value in the Date object using local time. 
+      * @param month A numeric value equal to the month. The value for January is 0, and other month values follow consecutively. 
+      * @param date A numeric value representing the day of the month. If this value is not supplied, the value from a call to the getDate method is used.
+      */
+    setMonth(month: number, date?: number): number;
+    /**
+      * Sets the month value in the Date object using Universal Coordinated Time (UTC).
+      * @param month A numeric value equal to the month. The value for January is 0, and other month values follow consecutively.
+      * @param date A numeric value representing the day of the month. If it is not supplied, the value from a call to the getUTCDate method is used.
+      */
+    setUTCMonth(month: number, date?: number): number;
+    /**
+      * Sets the year of the Date object using local time.
+      * @param year A numeric value for the year.
+      * @param month A zero-based numeric value for the month (0 for January, 11 for December). Must be specified if numDate is specified.
+      * @param date A numeric value equal for the day of the month.
+      */
+    setFullYear(year: number, month?: number, date?: number): number;
+    /**
+      * Sets the year value in the Date object using Universal Coordinated Time (UTC).
+      * @param year A numeric value equal to the year.
+      * @param month A numeric value equal to the month. The value for January is 0, and other month values follow consecutively. Must be supplied if numDate is supplied.
+      * @param date A numeric value equal to the day of the month.
+      */
+    setUTCFullYear(year: number, month?: number, date?: number): number;
+    /** Returns a date converted to a string using Universal Coordinated Time (UTC). */
+    toUTCString(): string;
+    /** Returns a date as a string value in ISO format. */
+    toISOString(): string;
+    /** Used by the JSON.stringify method to enable the transformation of an object's data for JavaScript Object Notation (JSON) serialization. */
+    toJSON(key?: any): string;
+}
+
+declare var Date: {
+    new (): Date;
+    new (value: number): Date;
+    new (value: string): Date;
+    new (year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): Date;
+    (): string;
+    prototype: Date;
+    /**
+      * Parses a string containing a date, and returns the number of milliseconds between that date and midnight, January 1, 1970.
+      * @param s A date string
+      */
+    parse(s: string): number;
+    /**
+      * Returns the number of milliseconds between midnight, January 1, 1970 Universal Coordinated Time (UTC) (or GMT) and the specified date. 
+      * @param year The full year designation is required for cross-century date accuracy. If year is between 0 and 99 is used, then year is assumed to be 1900 + year.
+      * @param month The month as an number between 0 and 11 (January to December).
+      * @param date The date as an number between 1 and 31.
+      * @param hours Must be supplied if minutes is supplied. An number from 0 to 23 (midnight to 11pm) that specifies the hour.
+      * @param minutes Must be supplied if seconds is supplied. An number from 0 to 59 that specifies the minutes.
+      * @param seconds Must be supplied if milliseconds is supplied. An number from 0 to 59 that specifies the seconds.
+      * @param ms An number from 0 to 999 that specifies the milliseconds.
+      */
+    UTC(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number;
+    now(): number;
+}
+
+interface RegExpExecArray {
+    [index: number]: string;
+    length: number;
+
+    index: number;
+    input: string;
+
+    toString(): string;
+    toLocaleString(): string;
+    concat(...items: string[][]): string[];
+    join(separator?: string): string;
+    pop(): string;
+    push(...items: string[]): number;
+    reverse(): string[];
+    shift(): string;
+    slice(start?: number, end?: number): string[];
+    sort(compareFn?: (a: string, b: string) => number): string[];
+    splice(start: number): string[];
+    splice(start: number, deleteCount: number, ...items: string[]): string[];
+    unshift(...items: string[]): number;
+
+    indexOf(searchElement: string, fromIndex?: number): number;
+    lastIndexOf(searchElement: string, fromIndex?: number): number;
+    every(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any): boolean;
+    some(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any): boolean;
+    forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any): void;
+    map(callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): any[];
+    filter(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any): string[];
+    reduce(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: string[]) => any, initialValue?: any): any;
+    reduceRight(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: string[]) => any, initialValue?: any): any;
+}
+
+
+interface RegExp {
+    /** 
+      * Executes a search on a string using a regular expression pattern, and returns an array containing the results of that search.
+      * @param string The String object or string literal on which to perform the search.
+      */
+    exec(string: string): RegExpExecArray;
+
+    /** 
+      * Returns a Boolean value that indicates whether or not a pattern exists in a searched string.
+      * @param string String on which to perform the search.
+      */
+    test(string: string): boolean;
+
+    /** Returns a copy of the text of the regular expression pattern. Read-only. The rgExp argument is a Regular expression object. It can be a variable name or a literal. */
+    source: string;
+
+    /** Returns a Boolean value indicating the state of the global flag (g) used with a regular expression. Default is false. Read-only. */
+    global: boolean;
+
+    /** Returns a Boolean value indicating the state of the ignoreCase flag (i) used with a regular expression. Default is false. Read-only. */
+    ignoreCase: boolean;
+
+    /** Returns a Boolean value indicating the state of the multiline flag (m) used with a regular expression. Default is false. Read-only. */
+    multiline: boolean;
+
+    lastIndex: number;
+
+    // Non-standard extensions
+    compile(): RegExp;
+}
+declare var RegExp: {
+    new (pattern: string, flags?: string): RegExp;
+    (pattern: string, flags?: string): RegExp;
+
+    // Non-standard extensions
+    $1: string;
+    $2: string;
+    $3: string;
+    $4: string;
+    $5: string;
+    $6: string;
+    $7: string;
+    $8: string;
+    $9: string;
+    lastMatch: string;
+}
+
+interface Error {
+    name: string;
+    message: string;
+}
+declare var Error: {
+    new (message?: string): Error;
+    (message?: string): Error;
+    prototype: Error;
+}
+
+interface EvalError extends Error {
+}
+declare var EvalError: {
+    new (message?: string): EvalError;
+    (message?: string): EvalError;
+    prototype: EvalError;
+}
+
+interface RangeError extends Error {
+}
+declare var RangeError: {
+    new (message?: string): RangeError;
+    (message?: string): RangeError;
+    prototype: RangeError;
+}
+
+interface ReferenceError extends Error {
+}
+declare var ReferenceError: {
+    new (message?: string): ReferenceError;
+    (message?: string): ReferenceError;
+    prototype: ReferenceError;
+}
+
+interface SyntaxError extends Error {
+}
+declare var SyntaxError: {
+    new (message?: string): SyntaxError;
+    (message?: string): SyntaxError;
+    prototype: SyntaxError;
+}
+
+interface TypeError extends Error {
+}
+declare var TypeError: {
+    new (message?: string): TypeError;
+    (message?: string): TypeError;
+    prototype: TypeError;
+}
+
+interface URIError extends Error {
+}
+declare var URIError: {
+    new (message?: string): URIError;
+    (message?: string): URIError;
+    prototype: URIError;
+}
+
+interface JSON {
+    /**
+      * Converts a JavaScript Object Notation (JSON) string into an object.
+      * @param text A valid JSON string.
+      * @param reviver A function that transforms the results. This function is called for each member of the object. 
+      * If a member contains nested objects, the nested objects are transformed before the parent object is. 
+      */
+    parse(text: string, reviver?: (key: any, value: any) => any): any;
+    /**
+      * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+      * @param value A JavaScript value, usually an object or array, to be converted.
+      */
+    stringify(value: any): string;
+    /**
+      * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+      * @param value A JavaScript value, usually an object or array, to be converted.
+      * @param replacer A function that transforms the results.
+      */
+    stringify(value: any, replacer: (key: string, value: any) => any): string;
+    /**
+      * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+      * @param value A JavaScript value, usually an object or array, to be converted.
+      * @param replacer Array that transforms the results.
+      */
+    stringify(value: any, replacer: any[]): string;
+    /**
+      * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+      * @param value A JavaScript value, usually an object or array, to be converted.
+      * @param replacer A function that transforms the results.
+      * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+      */
+    stringify(value: any, replacer: (key: string, value: any) => any, space: any): string;
+    /**
+      * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+      * @param value A JavaScript value, usually an object or array, to be converted.
+      * @param replacer Array that transforms the results.
+      * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+      */
+    stringify(value: any, replacer: any[], space: any): string;
+}
+/**
+  * An intrinsic object that provides functions to convert JavaScript values to and from the JavaScript Object Notation (JSON) format.
+  */
+declare var JSON: JSON;
+
+
+/////////////////////////////
+/// ECMAScript Array API (specially handled by compiler)
+/////////////////////////////
+
+interface Array<T> {
+    /**
+      * Returns a string representation of an array.
+      */
+    toString(): string;
+    toLocaleString(): string;
+    /**
+      * Combines two or more arrays.
+      * @param items Additional items to add to the end of array1.
+      */
+    concat<U extends T[]>(...items: U[]): T[];
+    /**
+      * Combines two or more arrays.
+      * @param items Additional items to add to the end of array1.
+      */
+    concat(...items: T[]): T[];
+    /**
+      * Adds all the elements of an array separated by the specified separator string.
+      * @param separator A string used to separate one element of an array from the next in the resulting String. If omitted, the array elements are separated with a comma.
+      */
+    join(separator?: string): string;
+    /**
+      * Removes the last element from an array and returns it.
+      */
+    pop(): T;
+    /**
+      * Appends new elements to an array, and returns the new length of the array.
+      * @param items New elements of the Array.
+      */
+    push(...items: T[]): number;
+    /**
+      * Reverses the elements in an Array. 
+      */
+    reverse(): T[];
+    /**
+      * Removes the first element from an array and returns it.
+      */
+    shift(): T;
+    /** 
+      * Returns a section of an array.
+      * @param start The beginning of the specified portion of the array.
+      * @param end The end of the specified portion of the array.
+      */
+    slice(start?: number, end?: number): T[];
+
+    /**
+      * Sorts an array.
+      * @param compareFn The name of the function used to determine the order of the elements. If omitted, the elements are sorted in ascending, ASCII character order.
+      */
+    sort(compareFn?: (a: T, b: T) => number): T[];
+
+    /**
+      * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
+      * @param start The zero-based location in the array from which to start removing elements.
+      */
+    splice(start: number): T[];
+
+    /**
+      * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
+      * @param start The zero-based location in the array from which to start removing elements.
+      * @param deleteCount The number of elements to remove.
+      * @param items Elements to insert into the array in place of the deleted elements.
+      */
+    splice(start: number, deleteCount: number, ...items: T[]): T[];
+
+    /**
+      * Inserts new elements at the start of an array.
+      * @param items  Elements to insert at the start of the Array.
+      */
+    unshift(...items: T[]): number;
+
+    /**
+      * Returns the index of the first occurrence of a value in an array.
+      * @param searchElement The value to locate in the array.
+      * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
+      */
+    indexOf(searchElement: T, fromIndex?: number): number;
+
+    /**
+      * Returns the index of the last occurrence of a specified value in an array.
+      * @param searchElement The value to locate in the array.
+      * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at the last index in the array.
+      */
+    lastIndexOf(searchElement: T, fromIndex?: number): number;
+
+    /**
+      * Determines whether all the members of an array satisfy the specified test.
+      * @param callbackfn A function that accepts up to three arguments. The every method calls the callbackfn function for each element in array1 until the callbackfn returns false, or until the end of the array.
+      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+      */
+    every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
+
+    /**
+      * Determines whether the specified callback function returns true for any element of an array.
+      * @param callbackfn A function that accepts up to three arguments. The some method calls the callbackfn function for each element in array1 until the callbackfn returns true, or until the end of the array.
+      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+      */
+    some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
+
+    /**
+      * Performs the specified action for each element in an array.
+      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. 
+      * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+      */
+    forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
+
+    /**
+      * Calls a defined callback function on each element of an array, and returns an array that contains the results.
+      * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. 
+      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+      */
+    map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
+
+    /**
+      * Returns the elements of an array that meet the condition specified in a callback function. 
+      * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array. 
+      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+      */
+    filter(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[];
+
+    /**
+      * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+      * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
+      * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
+      */
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
+    /**
+      * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+      * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
+      * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
+      */
+    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+
+    /** 
+      * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. 
+      * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
+      */
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
+    /** 
+      * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. 
+      * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
+      */
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+
+    /**
+      * Gets or sets the length of the array. This is a number one higher than the highest element defined in an array.
+      */
+    length: number;
+
+    [n: number]: T;
+}
+declare var Array: {
+    new (arrayLength?: number): any[];
+    new <T>(arrayLength: number): T[];
+    new <T>(...items: T[]): T[];
+    (arrayLength?: number): any[];
+    <T>(arrayLength: number): T[];
+    <T>(...items: T[]): T[];
+    isArray(arg: any): boolean;
+    prototype: Array<any>;
+}
+
+
+/////////////////////////////
+/// IE10 ECMAScript Extensions
+/////////////////////////////
+
+/**
+  * Represents a raw buffer of binary data, which is used to store data for the 
+  * different typed arrays. ArrayBuffers cannot be read from or written to directly, 
+  * but can be passed to a typed array or DataView Object to interpret the raw 
+  * buffer as needed. 
+  */
+interface ArrayBuffer {
+    /**
+      * Read-only. The length of the ArrayBuffer (in bytes).
+      */
+    byteLength: number;
+}
+
+declare var ArrayBuffer: {
+    prototype: ArrayBuffer;
+    new (byteLength: number): ArrayBuffer;
+}
+
+interface ArrayBufferView {
+    buffer: ArrayBuffer;
+    byteOffset: number;
+    byteLength: number;
+}
+
+/**
+  * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised.
+  */
+interface Int8Array extends ArrayBufferView {
+    /**
+      * The size in bytes of each element in the array. 
+      */
+    BYTES_PER_ELEMENT: number;
+
+    /**
+      * The length of the array.
+      */
+    length: number;
+
+    [index: number]: number;
+
+    /**
+      * Gets the element at the specified index.
+      * @param index The index at which to get the element of the array.
+      */
+    get(index: number): number;
+
+    /**
+      * Sets a value or an array of values.
+      * @param index The index of the location to set.
+      * @param value The value to set.
+      */
+    set(index: number, value: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: Int8Array, offset?: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: number[], offset?: number): void;
+
+    /**
+      * Gets a new Int8Array view of the ArrayBuffer store for this array, referencing the elements at begin, inclusive, up to end, exclusive. 
+      * @param begin The index of the beginning of the array.
+      * @param end The index of the end of the array.
+      */
+    subarray(begin: number, end?: number): Int8Array;
+}
+declare var Int8Array: {
+    prototype: Int8Array;
+    new (length: number): Int8Array;
+    new (array: Int8Array): Int8Array;
+    new (array: number[]): Int8Array;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int8Array;
+    BYTES_PER_ELEMENT: number;
+}
+
+/**
+  * A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised.
+  */
+interface Uint8Array extends ArrayBufferView {
+    /**
+      * The size in bytes of each element in the array. 
+      */
+    BYTES_PER_ELEMENT: number;
+
+    /**
+      * The length of the array.
+      */
+    length: number;
+    [index: number]: number;
+
+    /**
+      * Gets the element at the specified index.
+      * @param index The index at which to get the element of the array.
+      */
+    get(index: number): number;
+
+    /**
+      * Sets a value or an array of values.
+      * @param index The index of the location to set.
+      * @param value The value to set.
+      */
+    set(index: number, value: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: Uint8Array, offset?: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: number[], offset?: number): void;
+
+    /**
+      * Gets a new Uint8Array view of the ArrayBuffer Object store for this array, specifying the first and last members of the subarray. 
+      * @param begin The index of the beginning of the array.
+      * @param end The index of the end of the array.
+      */
+    subarray(begin: number, end?: number): Uint8Array;
+}
+declare var Uint8Array: {
+    prototype: Uint8Array;
+    new (length: number): Uint8Array;
+    new (array: Uint8Array): Uint8Array;
+    new (array: number[]): Uint8Array;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint8Array;
+    BYTES_PER_ELEMENT: number;
+}
+
+/**
+  * A typed array of 16-bit integer values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised.
+  */
+interface Int16Array extends ArrayBufferView {
+    /**
+      * The size in bytes of each element in the array. 
+      */
+    BYTES_PER_ELEMENT: number;
+
+    /**
+      * The length of the array.
+      */
+    length: number;
+    [index: number]: number;
+
+    /**
+      * Gets the element at the specified index.
+      * @param index The index at which to get the element of the array.
+      */
+    get(index: number): number;
+
+    /**
+      * Sets a value or an array of values.
+      * @param index The index of the location to set.
+      * @param value The value to set.
+      */
+    set(index: number, value: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: Int16Array, offset?: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: number[], offset?: number): void;
+
+    /**
+      * Gets a new Int16Array view of the ArrayBuffer Object store for this array, specifying the first and last members of the subarray. 
+      * @param begin The index of the beginning of the array.
+      * @param end The index of the end of the array.
+      */
+    subarray(begin: number, end?: number): Int16Array;
+}
+declare var Int16Array: {
+    prototype: Int16Array;
+    new (length: number): Int16Array;
+    new (array: Int16Array): Int16Array;
+    new (array: number[]): Int16Array;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int16Array;
+    BYTES_PER_ELEMENT: number;
+}
+
+/**
+  * A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised.
+  */
+interface Uint16Array extends ArrayBufferView {
+    /**
+      * The size in bytes of each element in the array. 
+      */
+    BYTES_PER_ELEMENT: number;
+
+    /**
+      * The length of the array.
+      */
+    length: number;
+    [index: number]: number;
+
+    /**
+      * Gets the element at the specified index.
+      * @param index The index at which to get the element of the array.
+      */
+    get(index: number): number;
+
+    /**
+      * Sets a value or an array of values.
+      * @param index The index of the location to set.
+      * @param value The value to set.
+      */
+    set(index: number, value: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: Uint16Array, offset?: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: number[], offset?: number): void;
+
+    /**
+      * Gets a new Uint16Array view of the ArrayBuffer Object store for this array, specifying the first and last members of the subarray.
+      * @param begin The index of the beginning of the array.
+      * @param end The index of the end of the array.
+      */
+    subarray(begin: number, end?: number): Uint16Array;
+}
+declare var Uint16Array: {
+    prototype: Uint16Array;
+    new (length: number): Uint16Array;
+    new (array: Uint16Array): Uint16Array;
+    new (array: number[]): Uint16Array;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint16Array;
+    BYTES_PER_ELEMENT: number;
+}
+
+/**
+  * A typed array of 32-bit integer values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised.
+  */
+interface Int32Array extends ArrayBufferView {
+    /**
+      * The size in bytes of each element in the array. 
+      */
+    BYTES_PER_ELEMENT: number;
+
+    /**
+      * The length of the array.
+      */
+    length: number;
+    [index: number]: number;
+
+    /**
+      * Gets the element at the specified index.
+      * @param index The index at which to get the element of the array.
+      */
+    get(index: number): number;
+
+    /**
+      * Sets a value or an array of values.
+      * @param index The index of the location to set.
+      * @param value The value to set.
+      */
+    set(index: number, value: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: Int32Array, offset?: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: number[], offset?: number): void;
+
+    /**
+      * Gets a new Int32Array view of the ArrayBuffer Object store for this array, specifying the first and last members of the subarray. 
+      * @param begin The index of the beginning of the array.
+      * @param end The index of the end of the array.
+      */
+    subarray(begin: number, end?: number): Int32Array;
+}
+declare var Int32Array: {
+    prototype: Int32Array;
+    new (length: number): Int32Array;
+    new (array: Int32Array): Int32Array;
+    new (array: number[]): Int32Array;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int32Array;
+    BYTES_PER_ELEMENT: number;
+}
+
+/**
+  * A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised.
+  */
+interface Uint32Array extends ArrayBufferView {
+    /**
+      * The size in bytes of each element in the array. 
+      */
+    BYTES_PER_ELEMENT: number;
+
+    /**
+      * The length of the array.
+      */
+    length: number;
+    [index: number]: number;
+
+    /**
+      * Gets the element at the specified index.
+      * @param index The index at which to get the element of the array.
+      */
+    get(index: number): number;
+
+    /**
+      * Sets a value or an array of values.
+      * @param index The index of the location to set.
+      * @param value The value to set.
+      */
+    set(index: number, value: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: Uint32Array, offset?: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: number[], offset?: number): void;
+
+    /**
+      * Gets a new Int8Array view of the ArrayBuffer Object store for this array, specifying the first and last members of the subarray. 
+      * @param begin The index of the beginning of the array.
+      * @param end The index of the end of the array.
+      */
+    subarray(begin: number, end?: number): Uint32Array;
+}
+declare var Uint32Array: {
+    prototype: Uint32Array;
+    new (length: number): Uint32Array;
+    new (array: Uint32Array): Uint32Array;
+    new (array: number[]): Uint32Array;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint32Array;
+    BYTES_PER_ELEMENT: number;
+}
+
+/**
+  * A typed array of 32-bit float values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised.
+  */
+interface Float32Array extends ArrayBufferView {
+    /**
+      * The size in bytes of each element in the array. 
+      */
+    BYTES_PER_ELEMENT: number;
+
+    /**
+      * The length of the array.
+      */
+    length: number;
+    [index: number]: number;
+
+    /**
+      * Gets the element at the specified index.
+      * @param index The index at which to get the element of the array.
+      */
+    get(index: number): number;
+
+    /**
+      * Sets a value or an array of values.
+      * @param index The index of the location to set.
+      * @param value The value to set.
+      */
+    set(index: number, value: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: Float32Array, offset?: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: number[], offset?: number): void;
+
+    /**
+      * Gets a new Float32Array view of the ArrayBuffer Object store for this array, specifying the first and last members of the subarray. 
+      * @param begin The index of the beginning of the array.
+      * @param end The index of the end of the array.
+      */
+    subarray(begin: number, end?: number): Float32Array;
+}
+declare var Float32Array: {
+    prototype: Float32Array;
+    new (length: number): Float32Array;
+    new (array: Float32Array): Float32Array;
+    new (array: number[]): Float32Array;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Float32Array;
+    BYTES_PER_ELEMENT: number;
+}
+
+/**
+  * A typed array of 64-bit float values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised.
+  */
+interface Float64Array extends ArrayBufferView {
+    /**
+      * The size in bytes of each element in the array. 
+      */
+    BYTES_PER_ELEMENT: number;
+
+    /**
+      * The length of the array.
+      */
+    length: number;
+    [index: number]: number;
+
+    /**
+      * Gets the element at the specified index.
+      * @param index The index at which to get the element of the array.
+      */
+    get(index: number): number;
+
+    /**
+      * Sets a value or an array of values.
+      * @param index The index of the location to set.
+      * @param value The value to set.
+      */
+    set(index: number, value: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: Float64Array, offset?: number): void;
+
+    /**
+      * Sets a value or an array of values.
+      * @param A typed or untyped array of values to set.
+      * @param offset The index in the current array at which the values are to be written.
+      */
+    set(array: number[], offset?: number): void;
+
+    /**
+      * Gets a new Float64Array view of the ArrayBuffer Object store for this array, specifying the first and last members of the subarray. 
+      * @param begin The index of the beginning of the array.
+      * @param end The index of the end of the array.
+      */
+    subarray(begin: number, end?: number): Float64Array;
+}
+declare var Float64Array: {
+    prototype: Float64Array;
+    new (length: number): Float64Array;
+    new (array: Float64Array): Float64Array;
+    new (array: number[]): Float64Array;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Float64Array;
+    BYTES_PER_ELEMENT: number;
+}
+
+/**
+  * You can use a DataView object to read and write the different kinds of binary data to any location in the ArrayBuffer. 
+  */
+interface DataView extends ArrayBufferView {
+    /**
+      * Gets the Int8 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. 
+      * @param byteOffset The place in the buffer at which the value should be retrieved.
+      */
+    getInt8(byteOffset: number): number;
+
+    /**
+      * Gets the Uint8 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. 
+      * @param byteOffset The place in the buffer at which the value should be retrieved.
+      */
+    getUint8(byteOffset: number): number;
+
+    /**
+      * Gets the Int16 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. 
+      * @param byteOffset The place in the buffer at which the value should be retrieved.
+      */
+    getInt16(byteOffset: number, littleEndian?: boolean): number;
+
+    /**
+      * Gets the Uint16 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. 
+      * @param byteOffset The place in the buffer at which the value should be retrieved.
+      */
+    getUint16(byteOffset: number, littleEndian?: boolean): number;
+
+    /**
+      * Gets the Int32 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. 
+      * @param byteOffset The place in the buffer at which the value should be retrieved.
+      */
+    getInt32(byteOffset: number, littleEndian?: boolean): number;
+
+    /**
+      * Gets the Uint32 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. 
+      * @param byteOffset The place in the buffer at which the value should be retrieved.
+      */
+    getUint32(byteOffset: number, littleEndian?: boolean): number;
+
+    /**
+      * Gets the Float32 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. 
+      * @param byteOffset The place in the buffer at which the value should be retrieved.
+      */
+    getFloat32(byteOffset: number, littleEndian?: boolean): number;
+
+    /**
+      * Gets the Float64 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. 
+      * @param byteOffset The place in the buffer at which the value should be retrieved.
+      */
+    getFloat64(byteOffset: number, littleEndian?: boolean): number;
+
+    /**
+      * Stores an Int8 value at the specified byte offset from the start of the view. 
+      * @param byteOffset The place in the buffer at which the value should be set.
+      * @param value The value to set.
+      */
+    setInt8(byteOffset: number, value: number): void;
+
+    /**
+      * Stores an Uint8 value at the specified byte offset from the start of the view. 
+      * @param byteOffset The place in the buffer at which the value should be set.
+      * @param value The value to set.
+      */
+    setUint8(byteOffset: number, value: number): void;
+
+    /**
+      * Stores an Int16 value at the specified byte offset from the start of the view. 
+      * @param byteOffset The place in the buffer at which the value should be set.
+      * @param value The value to set.
+      * @param littleEndian If false or undefined, a big-endian value should be written, otherwise a little-endian value should be written.
+      */
+    setInt16(byteOffset: number, value: number, littleEndian?: boolean): void;
+
+    /**
+      * Stores an Uint16 value at the specified byte offset from the start of the view. 
+      * @param byteOffset The place in the buffer at which the value should be set.
+      * @param value The value to set.
+      * @param littleEndian If false or undefined, a big-endian value should be written, otherwise a little-endian value should be written.
+      */
+    setUint16(byteOffset: number, value: number, littleEndian?: boolean): void;
+
+    /**
+      * Stores an Int32 value at the specified byte offset from the start of the view. 
+      * @param byteOffset The place in the buffer at which the value should be set.
+      * @param value The value to set.
+      * @param littleEndian If false or undefined, a big-endian value should be written, otherwise a little-endian value should be written.
+      */
+    setInt32(byteOffset: number, value: number, littleEndian?: boolean): void;
+
+    /**
+      * Stores an Uint32 value at the specified byte offset from the start of the view. 
+      * @param byteOffset The place in the buffer at which the value should be set.
+      * @param value The value to set.
+      * @param littleEndian If false or undefined, a big-endian value should be written, otherwise a little-endian value should be written.
+      */
+    setUint32(byteOffset: number, value: number, littleEndian?: boolean): void;
+
+    /**
+      * Stores an Float32 value at the specified byte offset from the start of the view. 
+      * @param byteOffset The place in the buffer at which the value should be set.
+      * @param value The value to set.
+      * @param littleEndian If false or undefined, a big-endian value should be written, otherwise a little-endian value should be written.
+      */
+    setFloat32(byteOffset: number, value: number, littleEndian?: boolean): void;
+
+    /**
+      * Stores an Float64 value at the specified byte offset from the start of the view. 
+      * @param byteOffset The place in the buffer at which the value should be set.
+      * @param value The value to set.
+      * @param littleEndian If false or undefined, a big-endian value should be written, otherwise a little-endian value should be written.
+      */
+    setFloat64(byteOffset: number, value: number, littleEndian?: boolean): void;
+}
+declare var DataView: {
+    prototype: DataView;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): DataView;
+}
+
+/////////////////////////////
+/// IE11 ECMAScript Extensions
+/////////////////////////////
+
+interface Map<K, V> {
+    clear(): void;
+    delete(key: K): boolean;
+    forEach(callbackfn: (value: V, index: K, map: Map<K, V>) => void, thisArg?: any): void;
+    get(key: K): V;
+    has(key: K): boolean;
+    set(key: K, value: V): Map<K, V>;
+    size: number;
+}
+declare var Map: {
+    new <K, V>(): Map<K, V>;
+}
+
+interface WeakMap<K, V> {
+    clear(): void;
+    delete(key: K): boolean;
+    get(key: K): V;
+    has(key: K): boolean;
+    set(key: K, value: V): WeakMap<K, V>;
+}
+declare var WeakMap: {
+    new <K, V>(): WeakMap<K, V>;
+}
+
+interface Set<T> {
+    add(value: T): Set<T>;
+    clear(): void;
+    delete(value: T): boolean;
+    forEach(callbackfn: (value: T, index: T, set: Set<T>) => void, thisArg?: any): void;
+    has(value: T): boolean;
+    size: number;
+}
+declare var Set: {
+    new <T>(): Set<T>;
+}
+
+declare module Intl {
+
+    interface CollatorOptions {
+        usage?: string;
+        localeMatcher?: string;
+        numeric?: boolean;
+        caseFirst?: string;
+        sensitivity?: string;
+        ignorePunctuation?: boolean;
+    }
+
+    interface ResolvedCollatorOptions {
+        locale: string;
+        usage: string;
+        sensitivity: string;
+        ignorePunctuation: boolean;
+        collation: string;
+        caseFirst: string;
+        numeric: boolean;
+    }
+
+    interface Collator {
+        compare(x: string, y: string): number;
+        resolvedOptions(): ResolvedCollatorOptions;
+    }
+    var Collator: {
+        new (locales?: string[], options?: CollatorOptions): Collator;
+        new (locale?: string, options?: CollatorOptions): Collator;
+        (locales?: string[], options?: CollatorOptions): Collator;
+        (locale?: string, options?: CollatorOptions): Collator;
+        supportedLocalesOf(locales: string[], options?: CollatorOptions): string[];
+        supportedLocalesOf(locale: string, options?: CollatorOptions): string[];
+    }
+
+    interface NumberFormatOptions {
+        localeMatcher?: string;
+        style?: string;
+        currency?: string;
+        currencyDisplay?: string;
+        useGrouping?: boolean;
+    }
+
+    interface ResolvedNumberFormatOptions {
+        locale: string;
+        numberingSystem: string;
+        style: string;
+        currency?: string;
+        currencyDisplay?: string;
+        minimumintegerDigits: number;
+        minimumFractionDigits: number;
+        maximumFractionDigits: number;
+        minimumSignificantDigits?: number;
+        maximumSignificantDigits?: number;
+        useGrouping: boolean;
+    }
+
+    interface NumberFormat {
+        format(value: number): string;
+        resolvedOptions(): ResolvedNumberFormatOptions;
+    }
+    var NumberFormat: {
+        new (locales?: string[], options?: NumberFormatOptions): Collator;
+        new (locale?: string, options?: NumberFormatOptions): Collator;
+        (locales?: string[], options?: NumberFormatOptions): Collator;
+        (locale?: string, options?: NumberFormatOptions): Collator;
+        supportedLocalesOf(locales: string[], options?: NumberFormatOptions): string[];
+        supportedLocalesOf(locale: string, options?: NumberFormatOptions): string[];
+    }
+
+    interface DateTimeFormatOptions {
+        localeMatcher?: string;
+        weekday?: string;
+        era?: string;
+        year?: string;
+        month?: string;
+        day?: string;
+        hour?: string;
+        minute?: string;
+        second?: string;
+        timeZoneName?: string;
+        formatMatcher?: string;
+        hour12: boolean;
+    }
+
+    interface ResolvedDateTimeFormatOptions {
+        locale: string;
+        calendar: string;
+        numberingSystem: string;
+        timeZone: string;
+        hour12?: boolean;
+        weekday?: string;
+        era?: string;
+        year?: string;
+        month?: string;
+        day?: string;
+        hour?: string;
+        minute?: string;
+        second?: string;
+        timeZoneName?: string;
+    }
+
+    interface DateTimeFormat {
+        format(date: number): string;
+        resolvedOptions(): ResolvedDateTimeFormatOptions;
+    }
+    var DateTimeFormat: {
+        new (locales?: string[], options?: DateTimeFormatOptions): Collator;
+        new (locale?: string, options?: DateTimeFormatOptions): Collator;
+        (locales?: string[], options?: DateTimeFormatOptions): Collator;
+        (locale?: string, options?: DateTimeFormatOptions): Collator;
+        supportedLocalesOf(locales: string[], options?: DateTimeFormatOptions): string[];
+        supportedLocalesOf(locale: string, options?: DateTimeFormatOptions): string[];
+    }
+}
+
+interface String {
+    localeCompare(that: string, locales: string[], options?: Intl.CollatorOptions): number;
+    localeCompare(that: string, locale: string, options?: Intl.CollatorOptions): number;
+}
+
+interface Number {
+    toLocaleString(locales?: string[], options?: Intl.NumberFormatOptions): string;
+    toLocaleString(locale?: string, options?: Intl.NumberFormatOptions): string;
+}
+
+interface Date {
+    toLocaleString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
+    toLocaleString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+}
+
+
+/////////////////////////////
+/// IE9 DOM APIs 
+/////////////////////////////
+
+interface PositionOptions {
+    enableHighAccuracy?: boolean;
+    timeout?: number;
+    maximumAge?: number;
+}
+
+interface NavigatorID {
+    appVersion: string;
+    appName: string;
+    userAgent: string;
+    platform: string;
+}
+
+interface HTMLTableElement extends HTMLElement, MSDataBindingTableExtensions, MSDataBindingExtensions, DOML2DeprecatedBackgroundStyle, DOML2DeprecatedBackgroundColorStyle {
+    /**
+      * Sets or retrieves the width of the object.
+      */
+    width: string;
+    /**
+      * Sets or retrieves the color for one of the two colors used to draw the 3-D border of the object.
+      */
+    borderColorLight: any;
+    /**
+      * Sets or retrieves the amount of space between cells in a table.
+      */
+    cellSpacing: string;
+    /**
+      * Retrieves the tFoot object of the table.
+      */
+    tFoot: HTMLTableSectionElement;
+    /**
+      * Sets or retrieves the way the border frame around the table is displayed.
+      */
+    frame: string;
+    /**
+      * Sets or retrieves the border color of the object. 
+      */
+    borderColor: any;
+    /**
+      * Sets or retrieves the number of horizontal rows contained in the object.
+      */
+    rows: HTMLCollection;
+    /**
+      * Sets or retrieves which dividing lines (inner borders) are displayed.
+      */
+    rules: string;
+    /**
+      * Sets or retrieves the number of columns in the table.
+      */
+    cols: number;
+    /**
+      * Sets or retrieves a description and/or structure of the object.
+      */
+    summary: string;
+    /**
+      * Retrieves the caption object of a table.
+      */
+    caption: HTMLTableCaptionElement;
+    /**
+      * Retrieves a collection of all tBody objects in the table. Objects in this collection are in source order.
+      */
+    tBodies: HTMLCollection;
+    /**
+      * Retrieves the tHead object of the table.
+      */
+    tHead: HTMLTableSectionElement;
+    /**
+      * Sets or retrieves a value that indicates the table alignment.
+      */
+    align: string;
+    /**
+      * Retrieves a collection of all cells in the table row or in the entire table.
+      */
+    cells: HTMLCollection;
+    /**
+      * Sets or retrieves the height of the object.
+      */
+    height: any;
+    /**
+      * Sets or retrieves the amount of space between the border of the cell and the content of the cell.
+      */
+    cellPadding: string;
+    /**
+      * Sets or retrieves the width of the border to draw around the object.
+      */
+    border: string;
+    /**
+      * Sets or retrieves the color for one of the two colors used to draw the 3-D border of the object.
+      */
+    borderColorDark: any;
+    /**
+      * Removes the specified row (tr) from the element and from the rows collection.
+      * @param index Number that specifies the zero-based position in the rows collection of the row to remove.
+      */
+    deleteRow(index?: number): void;
+    /**
+      * Creates an empty tBody element in the table.
+      */
+    createTBody(): HTMLElement;
+    /**
+      * Deletes the caption element and its contents from the table.
+      */
+    deleteCaption(): void;
+    /**
+      * Creates a new row (tr) in the table, and adds the row to the rows collection.
+      * @param index Number that specifies where to insert the row in the rows collection. The default value is -1, which appends the new row to the end of the rows collection.
+      */
+    insertRow(index?: number): HTMLElement;
+    /**
+      * Deletes the tFoot element and its contents from the table.
+      */
+    deleteTFoot(): void;
+    /**
+      * Returns the tHead element object if successful, or null otherwise.
+      */
+    createTHead(): HTMLElement;
+    /**
+      * Deletes the tHead element and its contents from the table.
+      */
+    deleteTHead(): void;
+    /**
+      * Creates an empty caption element in the table.
+      */
+    createCaption(): HTMLElement;
+    /**
+      * Moves a table row to a new position.
+      * @param indexFrom Number that specifies the index in the rows collection of the table row that is moved.
+      * @param indexTo Number that specifies where the row is moved within the rows collection.
+      */
+    moveRow(indexFrom?: number, indexTo?: number): Object;
+    /**
+      * Creates an empty tFoot element in the table.
+      */
+    createTFoot(): HTMLElement;
+}
+declare var HTMLTableElement: {
+    prototype: HTMLTableElement;
+    new (): HTMLTableElement;
+}
+
+interface TreeWalker {
+    whatToShow: number;
+    filter: NodeFilter;
+    root: Node;
+    currentNode: Node;
+    expandEntityReferences: boolean;
+    previousSibling(): Node;
+    lastChild(): Node;
+    nextSibling(): Node;
+    nextNode(): Node;
+    parentNode(): Node;
+    firstChild(): Node;
+    previousNode(): Node;
+}
+declare var TreeWalker: {
+    prototype: TreeWalker;
+    new (): TreeWalker;
+}
+
+interface GetSVGDocument {
+    getSVGDocument(): Document;
+}
+
+interface SVGPathSegCurvetoQuadraticRel extends SVGPathSeg {
+    y: number;
+    y1: number;
+    x: number;
+    x1: number;
+}
+declare var SVGPathSegCurvetoQuadraticRel: {
+    prototype: SVGPathSegCurvetoQuadraticRel;
+    new (): SVGPathSegCurvetoQuadraticRel;
+}
+
+interface Performance {
+    navigation: PerformanceNavigation;
+    timing: PerformanceTiming;
+    getEntriesByType(entryType: string): any;
+    toJSON(): any;
+    getMeasures(measureName?: string): any;
+    clearMarks(markName?: string): void;
+    getMarks(markName?: string): any;
+    clearResourceTimings(): void;
+    mark(markName: string): void;
+    measure(measureName: string, startMarkName?: string, endMarkName?: string): void;
+    getEntriesByName(name: string, entryType?: string): any;
+    getEntries(): any;
+    clearMeasures(measureName?: string): void;
+    setResourceTimingBufferSize(maxSize: number): void;
+}
+declare var Performance: {
+    prototype: Performance;
+    new (): Performance;
+}
+
+interface MSDataBindingTableExtensions {
+    dataPageSize: number;
+    nextPage(): void;
+    firstPage(): void;
+    refresh(): void;
+    previousPage(): void;
+    lastPage(): void;
+}
+
+interface CompositionEvent extends UIEvent {
+    data: string;
+    locale: string;
+    initCompositionEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, dataArg: string, locale: string): void;
+}
+declare var CompositionEvent: {
+    prototype: CompositionEvent;
+    new (): CompositionEvent;
+}
+
+interface WindowTimers {
+    clearTimeout(handle: number): void;
+    setTimeout(handler: any, timeout?: any, ...args: any[]): number;
+    clearInterval(handle: number): void;
+    setInterval(handler: any, timeout?: any, ...args: any[]): number;
+}
+
+interface SVGMarkerElement extends SVGElement, SVGStylable, SVGLangSpace, SVGFitToViewBox, SVGExternalResourcesRequired {
+    orientType: SVGAnimatedEnumeration;
+    markerUnits: SVGAnimatedEnumeration;
+    markerWidth: SVGAnimatedLength;
+    markerHeight: SVGAnimatedLength;
+    orientAngle: SVGAnimatedAngle;
+    refY: SVGAnimatedLength;
+    refX: SVGAnimatedLength;
+    setOrientToAngle(angle: SVGAngle): void;
+    setOrientToAuto(): void;
+    SVG_MARKER_ORIENT_UNKNOWN: number;
+    SVG_MARKER_ORIENT_ANGLE: number;
+    SVG_MARKERUNITS_UNKNOWN: number;
+    SVG_MARKERUNITS_STROKEWIDTH: number;
+    SVG_MARKER_ORIENT_AUTO: number;
+    SVG_MARKERUNITS_USERSPACEONUSE: number;
+}
+declare var SVGMarkerElement: {
+    prototype: SVGMarkerElement;
+    new (): SVGMarkerElement;
+    SVG_MARKER_ORIENT_UNKNOWN: number;
+    SVG_MARKER_ORIENT_ANGLE: number;
+    SVG_MARKERUNITS_UNKNOWN: number;
+    SVG_MARKERUNITS_STROKEWIDTH: number;
+    SVG_MARKER_ORIENT_AUTO: number;
+    SVG_MARKERUNITS_USERSPACEONUSE: number;
+}
+
+interface CSSStyleDeclaration {
+    backgroundAttachment: string;
+    visibility: string;
+    textAlignLast: string;
+    borderRightStyle: string;
+    counterIncrement: string;
+    orphans: string;
+    cssText: string;
+    borderStyle: string;
+    pointerEvents: string;
+    borderTopColor: string;
+    markerEnd: string;
+    textIndent: string;
+    listStyleImage: string;
+    cursor: string;
+    listStylePosition: string;
+    wordWrap: string;
+    borderTopStyle: string;
+    alignmentBaseline: string;
+    opacity: string;
+    direction: string;
+    strokeMiterlimit: string;
+    maxWidth: string;
+    color: string;
+    clip: string;
+    borderRightWidth: string;
+    verticalAlign: string;
+    overflow: string;
+    mask: string;
+    borderLeftStyle: string;
+    emptyCells: string;
+    stopOpacity: string;
+    paddingRight: string;
+    parentRule: CSSRule;
+    background: string;
+    boxSizing: string;
+    textJustify: string;
+    height: string;
+    paddingTop: string;
+    length: number;
+    right: string;
+    baselineShift: string;
+    borderLeft: string;
+    widows: string;
+    lineHeight: string;
+    left: string;
+    textUnderlinePosition: string;
+    glyphOrientationHorizontal: string;
+    display: string;
+    textAnchor: string;
+    cssFloat: string;
+    strokeDasharray: string;
+    rubyAlign: string;
+    fontSizeAdjust: string;
+    borderLeftColor: string;
+    backgroundImage: string;
+    listStyleType: string;
+    strokeWidth: string;
+    textOverflow: string;
+    fillRule: string;
+    borderBottomColor: string;
+    zIndex: string;
+    position: string;
+    listStyle: string;
+    msTransformOrigin: string;
+    dominantBaseline: string;
+    overflowY: string;
+    fill: string;
+    captionSide: string;
+    borderCollapse: string;
+    boxShadow: string;
+    quotes: string;
+    tableLayout: string;
+    unicodeBidi: string;
+    borderBottomWidth: string;
+    backgroundSize: string;
+    textDecoration: string;
+    strokeDashoffset: string;
+    fontSize: string;
+    border: string;
+    pageBreakBefore: string;
+    borderTopRightRadius: string;
+    msTransform: string;
+    borderBottomLeftRadius: string;
+    textTransform: string;
+    rubyPosition: string;
+    strokeLinejoin: string;
+    clipPath: string;
+    borderRightColor: string;
+    fontFamily: string;
+    clear: string;
+    content: string;
+    backgroundClip: string;
+    marginBottom: string;
+    counterReset: string;
+    outlineWidth: string;
+    marginRight: string;
+    paddingLeft: string;
+    borderBottom: string;
+    wordBreak: string;
+    marginTop: string;
+    top: string;
+    fontWeight: string;
+    borderRight: string;
+    width: string;
+    kerning: string;
+    pageBreakAfter: string;
+    borderBottomStyle: string;
+    fontStretch: string;
+    padding: string;
+    strokeOpacity: string;
+    markerStart: string;
+    bottom: string;
+    borderLeftWidth: string;
+    clipRule: string;
+    backgroundPosition: string;
+    backgroundColor: string;
+    pageBreakInside: string;
+    backgroundOrigin: string;
+    strokeLinecap: string;
+    borderTopWidth: string;
+    outlineStyle: string;
+    borderTop: string;
+    outlineColor: string;
+    paddingBottom: string;
+    marginLeft: string;
+    font: string;
+    outline: string;
+    wordSpacing: string;
+    maxHeight: string;
+    fillOpacity: string;
+    letterSpacing: string;
+    borderSpacing: string;
+    backgroundRepeat: string;
+    borderRadius: string;
+    borderWidth: string;
+    borderBottomRightRadius: string;
+    whiteSpace: string;
+    fontStyle: string;
+    minWidth: string;
+    stopColor: string;
+    borderTopLeftRadius: string;
+    borderColor: string;
+    marker: string;
+    glyphOrientationVertical: string;
+    markerMid: string;
+    fontVariant: string;
+    minHeight: string;
+    stroke: string;
+    rubyOverhang: string;
+    overflowX: string;
+    textAlign: string;
+    margin: string;
+    getPropertyPriority(propertyName: string): string;
+    getPropertyValue(propertyName: string): string;
+    removeProperty(propertyName: string): string;
+    item(index: number): string;
+    [index: number]: string;
+    setProperty(propertyName: string, value: string, priority?: string): void;
+}
+declare var CSSStyleDeclaration: {
+    prototype: CSSStyleDeclaration;
+    new (): CSSStyleDeclaration;
+}
+
+interface SVGGElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired {
+}
+declare var SVGGElement: {
+    prototype: SVGGElement;
+    new (): SVGGElement;
+}
+
+interface MSStyleCSSProperties extends MSCSSProperties {
+    pixelWidth: number;
+    posHeight: number;
+    posLeft: number;
+    pixelTop: number;
+    pixelBottom: number;
+    textDecorationNone: boolean;
+    pixelLeft: number;
+    posTop: number;
+    posBottom: number;
+    textDecorationOverline: boolean;
+    posWidth: number;
+    textDecorationLineThrough: boolean;
+    pixelHeight: number;
+    textDecorationBlink: boolean;
+    posRight: number;
+    pixelRight: number;
+    textDecorationUnderline: boolean;
+}
+declare var MSStyleCSSProperties: {
+    prototype: MSStyleCSSProperties;
+    new (): MSStyleCSSProperties;
+}
+
+interface Navigator extends NavigatorID, NavigatorOnLine, NavigatorContentUtils, MSNavigatorExtensions, NavigatorGeolocation, MSNavigatorDoNotTrack, NavigatorStorageUtils {
+}
+declare var Navigator: {
+    prototype: Navigator;
+    new (): Navigator;
+}
+
+interface SVGPathSegCurvetoCubicSmoothAbs extends SVGPathSeg {
+    y: number;
+    x2: number;
+    x: number;
+    y2: number;
+}
+declare var SVGPathSegCurvetoCubicSmoothAbs: {
+    prototype: SVGPathSegCurvetoCubicSmoothAbs;
+    new (): SVGPathSegCurvetoCubicSmoothAbs;
+}
+
+interface SVGZoomEvent extends UIEvent {
+    zoomRectScreen: SVGRect;
+    previousScale: number;
+    newScale: number;
+    previousTranslate: SVGPoint;
+    newTranslate: SVGPoint;
+}
+declare var SVGZoomEvent: {
+    prototype: SVGZoomEvent;
+    new (): SVGZoomEvent;
+}
+
+interface NodeSelector {
+    querySelectorAll(selectors: string): NodeList;
+    querySelector(selectors: string): Element;
+}
+
+interface HTMLTableDataCellElement extends HTMLTableCellElement {
+}
+declare var HTMLTableDataCellElement: {
+    prototype: HTMLTableDataCellElement;
+    new (): HTMLTableDataCellElement;
+}
+
+interface HTMLBaseElement extends HTMLElement {
+    /**
+      * Sets or retrieves the window or frame at which to target content.
+      */
+    target: string;
+    /**
+      * Gets or sets the baseline URL on which relative links are based.
+      */
+    href: string;
+}
+declare var HTMLBaseElement: {
+    prototype: HTMLBaseElement;
+    new (): HTMLBaseElement;
+}
+
+interface ClientRect {
+    left: number;
+    width: number;
+    right: number;
+    top: number;
+    bottom: number;
+    height: number;
+}
+declare var ClientRect: {
+    prototype: ClientRect;
+    new (): ClientRect;
+}
+
+interface PositionErrorCallback {
+    (error: PositionError): void;
+}
+
+interface DOMImplementation {
+    createDocumentType(qualifiedName: string, publicId: string, systemId: string): DocumentType;
+    createDocument(namespaceURI: string, qualifiedName: string, doctype: DocumentType): Document;
+    hasFeature(feature: string, version?: string): boolean;
+    createHTMLDocument(title: string): Document;
+}
+declare var DOMImplementation: {
+    prototype: DOMImplementation;
+    new (): DOMImplementation;
+}
+
+interface SVGUnitTypes {
+    SVG_UNIT_TYPE_UNKNOWN: number;
+    SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number;
+    SVG_UNIT_TYPE_USERSPACEONUSE: number;
+}
+declare var SVGUnitTypes: {
+    prototype: SVGUnitTypes;
+    new (): SVGUnitTypes;
+    SVG_UNIT_TYPE_UNKNOWN: number;
+    SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number;
+    SVG_UNIT_TYPE_USERSPACEONUSE: number;
+}
+
+interface Element extends Node, NodeSelector, ElementTraversal {
+    scrollTop: number;
+    clientLeft: number;
+    scrollLeft: number;
+    tagName: string;
+    clientWidth: number;
+    scrollWidth: number;
+    clientHeight: number;
+    clientTop: number;
+    scrollHeight: number;
+    getAttribute(name?: string): string;
+    getElementsByTagNameNS(namespaceURI: string, localName: string): NodeList;
+    hasAttributeNS(namespaceURI: string, localName: string): boolean;
+    getBoundingClientRect(): ClientRect;
+    getAttributeNS(namespaceURI: string, localName: string): string;
+    getAttributeNodeNS(namespaceURI: string, localName: string): Attr;
+    setAttributeNodeNS(newAttr: Attr): Attr;
+    msMatchesSelector(selectors: string): boolean;
+    hasAttribute(name: string): boolean;
+    removeAttribute(name?: string): void;
+    setAttributeNS(namespaceURI: string, qualifiedName: string, value: string): void;
+    getAttributeNode(name: string): Attr;
+    fireEvent(eventName: string, eventObj?: any): boolean;
+    getElementsByTagName(name: "a"): NodeListOf<HTMLAnchorElement>;
+    getElementsByTagName(name: "abbr"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "address"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "area"): NodeListOf<HTMLAreaElement>;
+    getElementsByTagName(name: "article"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "aside"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "audio"): NodeListOf<HTMLAudioElement>;
+    getElementsByTagName(name: "b"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "base"): NodeListOf<HTMLBaseElement>;
+    getElementsByTagName(name: "bdi"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "bdo"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "blockquote"): NodeListOf<HTMLQuoteElement>;
+    getElementsByTagName(name: "body"): NodeListOf<HTMLBodyElement>;
+    getElementsByTagName(name: "br"): NodeListOf<HTMLBRElement>;
+    getElementsByTagName(name: "button"): NodeListOf<HTMLButtonElement>;
+    getElementsByTagName(name: "canvas"): NodeListOf<HTMLCanvasElement>;
+    getElementsByTagName(name: "caption"): NodeListOf<HTMLTableCaptionElement>;
+    getElementsByTagName(name: "cite"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "code"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "col"): NodeListOf<HTMLTableColElement>;
+    getElementsByTagName(name: "colgroup"): NodeListOf<HTMLTableColElement>;
+    getElementsByTagName(name: "datalist"): NodeListOf<HTMLDataListElement>;
+    getElementsByTagName(name: "dd"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "del"): NodeListOf<HTMLModElement>;
+    getElementsByTagName(name: "dfn"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "div"): NodeListOf<HTMLDivElement>;
+    getElementsByTagName(name: "dl"): NodeListOf<HTMLDListElement>;
+    getElementsByTagName(name: "dt"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "em"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "embed"): NodeListOf<HTMLEmbedElement>;
+    getElementsByTagName(name: "fieldset"): NodeListOf<HTMLFieldSetElement>;
+    getElementsByTagName(name: "figcaption"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "figure"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "footer"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "form"): NodeListOf<HTMLFormElement>;
+    getElementsByTagName(name: "h1"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h2"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h3"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h4"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h5"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h6"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "head"): NodeListOf<HTMLHeadElement>;
+    getElementsByTagName(name: "header"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "hgroup"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "hr"): NodeListOf<HTMLHRElement>;
+    getElementsByTagName(name: "html"): NodeListOf<HTMLHtmlElement>;
+    getElementsByTagName(name: "i"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "iframe"): NodeListOf<HTMLIFrameElement>;
+    getElementsByTagName(name: "img"): NodeListOf<HTMLImageElement>;
+    getElementsByTagName(name: "input"): NodeListOf<HTMLInputElement>;
+    getElementsByTagName(name: "ins"): NodeListOf<HTMLModElement>;
+    getElementsByTagName(name: "kbd"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "label"): NodeListOf<HTMLLabelElement>;
+    getElementsByTagName(name: "legend"): NodeListOf<HTMLLegendElement>;
+    getElementsByTagName(name: "li"): NodeListOf<HTMLLIElement>;
+    getElementsByTagName(name: "link"): NodeListOf<HTMLLinkElement>;
+    getElementsByTagName(name: "main"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "map"): NodeListOf<HTMLMapElement>;
+    getElementsByTagName(name: "mark"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "menu"): NodeListOf<HTMLMenuElement>;
+    getElementsByTagName(name: "meta"): NodeListOf<HTMLMetaElement>;
+    getElementsByTagName(name: "nav"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "noscript"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "object"): NodeListOf<HTMLObjectElement>;
+    getElementsByTagName(name: "ol"): NodeListOf<HTMLOListElement>;
+    getElementsByTagName(name: "optgroup"): NodeListOf<HTMLOptGroupElement>;
+    getElementsByTagName(name: "option"): NodeListOf<HTMLOptionElement>;
+    getElementsByTagName(name: "p"): NodeListOf<HTMLParagraphElement>;
+    getElementsByTagName(name: "param"): NodeListOf<HTMLParamElement>;
+    getElementsByTagName(name: "pre"): NodeListOf<HTMLPreElement>;
+    getElementsByTagName(name: "progress"): NodeListOf<HTMLProgressElement>;
+    getElementsByTagName(name: "q"): NodeListOf<HTMLQuoteElement>;
+    getElementsByTagName(name: "rp"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "rt"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "ruby"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "s"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "samp"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "script"): NodeListOf<HTMLScriptElement>;
+    getElementsByTagName(name: "section"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "select"): NodeListOf<HTMLSelectElement>;
+    getElementsByTagName(name: "small"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "source"): NodeListOf<HTMLSourceElement>;
+    getElementsByTagName(name: "span"): NodeListOf<HTMLSpanElement>;
+    getElementsByTagName(name: "strong"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "style"): NodeListOf<HTMLStyleElement>;
+    getElementsByTagName(name: "sub"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "summary"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "sup"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "table"): NodeListOf<HTMLTableElement>;
+    getElementsByTagName(name: "tbody"): NodeListOf<HTMLTableSectionElement>;
+    getElementsByTagName(name: "td"): NodeListOf<HTMLTableDataCellElement>;
+    getElementsByTagName(name: "textarea"): NodeListOf<HTMLTextAreaElement>;
+    getElementsByTagName(name: "tfoot"): NodeListOf<HTMLTableSectionElement>;
+    getElementsByTagName(name: "th"): NodeListOf<HTMLTableHeaderCellElement>;
+    getElementsByTagName(name: "thead"): NodeListOf<HTMLTableSectionElement>;
+    getElementsByTagName(name: "title"): NodeListOf<HTMLTitleElement>;
+    getElementsByTagName(name: "tr"): NodeListOf<HTMLTableRowElement>;
+    getElementsByTagName(name: "track"): NodeListOf<HTMLTrackElement>;
+    getElementsByTagName(name: "u"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "ul"): NodeListOf<HTMLUListElement>;
+    getElementsByTagName(name: "var"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "video"): NodeListOf<HTMLVideoElement>;
+    getElementsByTagName(name: "wbr"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: string): NodeList;
+    getClientRects(): ClientRectList;
+    setAttributeNode(newAttr: Attr): Attr;
+    removeAttributeNode(oldAttr: Attr): Attr;
+    setAttribute(name?: string, value?: string): void;
+    removeAttributeNS(namespaceURI: string, localName: string): void;
+}
+declare var Element: {
+    prototype: Element;
+    new (): Element;
+}
+
+interface HTMLNextIdElement extends HTMLElement {
+    n: string;
+}
+declare var HTMLNextIdElement: {
+    prototype: HTMLNextIdElement;
+    new (): HTMLNextIdElement;
+}
+
+interface SVGPathSegMovetoRel extends SVGPathSeg {
+    y: number;
+    x: number;
+}
+declare var SVGPathSegMovetoRel: {
+    prototype: SVGPathSegMovetoRel;
+    new (): SVGPathSegMovetoRel;
+}
+
+interface SVGLineElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired {
+    y1: SVGAnimatedLength;
+    x2: SVGAnimatedLength;
+    x1: SVGAnimatedLength;
+    y2: SVGAnimatedLength;
+}
+declare var SVGLineElement: {
+    prototype: SVGLineElement;
+    new (): SVGLineElement;
+}
+
+interface HTMLParagraphElement extends HTMLElement, DOML2DeprecatedTextFlowControl {
+    /**
+      * Sets or retrieves how the object is aligned with adjacent text. 
+      */
+    align: string;
+}
+declare var HTMLParagraphElement: {
+    prototype: HTMLParagraphElement;
+    new (): HTMLParagraphElement;
+}
+
+interface HTMLAreasCollection extends HTMLCollection {
+    /**
+      * Removes an element from the collection.
+      */
+    remove(index?: number): void;
+    /**
+      * Adds an element to the areas, controlRange, or options collection.
+      */
+    add(element: HTMLElement, before?: any): void;
+}
+declare var HTMLAreasCollection: {
+    prototype: HTMLAreasCollection;
+    new (): HTMLAreasCollection;
+}
+
+interface SVGDescElement extends SVGElement, SVGStylable, SVGLangSpace {
+}
+declare var SVGDescElement: {
+    prototype: SVGDescElement;
+    new (): SVGDescElement;
+}
+
+interface Node extends EventTarget {
+    nodeType: number;
+    previousSibling: Node;
+    localName: string;
+    namespaceURI: string;
+    textContent: string;
+    parentNode: Node;
+    nextSibling: Node;
+    nodeValue: string;
+    lastChild: Node;
+    childNodes: NodeList;
+    nodeName: string;
+    ownerDocument: Document;
+    attributes: NamedNodeMap;
+    firstChild: Node;
+    prefix: string;
+    removeChild(oldChild: Node): Node;
+    appendChild(newChild: Node): Node;
+    isSupported(feature: string, version: string): boolean;
+    isEqualNode(arg: Node): boolean;
+    lookupPrefix(namespaceURI: string): string;
+    isDefaultNamespace(namespaceURI: string): boolean;
+    compareDocumentPosition(other: Node): number;
+    normalize(): void;
+    isSameNode(other: Node): boolean;
+    hasAttributes(): boolean;
+    lookupNamespaceURI(prefix: string): string;
+    cloneNode(deep?: boolean): Node;
+    hasChildNodes(): boolean;
+    replaceChild(newChild: Node, oldChild: Node): Node;
+    insertBefore(newChild: Node, refChild?: Node): Node;
+    ENTITY_REFERENCE_NODE: number;
+    ATTRIBUTE_NODE: number;
+    DOCUMENT_FRAGMENT_NODE: number;
+    TEXT_NODE: number;
+    ELEMENT_NODE: number;
+    COMMENT_NODE: number;
+    DOCUMENT_POSITION_DISCONNECTED: number;
+    DOCUMENT_POSITION_CONTAINED_BY: number;
+    DOCUMENT_POSITION_CONTAINS: number;
+    DOCUMENT_TYPE_NODE: number;
+    DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
+    DOCUMENT_NODE: number;
+    ENTITY_NODE: number;
+    PROCESSING_INSTRUCTION_NODE: number;
+    CDATA_SECTION_NODE: number;
+    NOTATION_NODE: number;
+    DOCUMENT_POSITION_FOLLOWING: number;
+    DOCUMENT_POSITION_PRECEDING: number;
+}
+declare var Node: {
+    prototype: Node;
+    new (): Node;
+    ENTITY_REFERENCE_NODE: number;
+    ATTRIBUTE_NODE: number;
+    DOCUMENT_FRAGMENT_NODE: number;
+    TEXT_NODE: number;
+    ELEMENT_NODE: number;
+    COMMENT_NODE: number;
+    DOCUMENT_POSITION_DISCONNECTED: number;
+    DOCUMENT_POSITION_CONTAINED_BY: number;
+    DOCUMENT_POSITION_CONTAINS: number;
+    DOCUMENT_TYPE_NODE: number;
+    DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
+    DOCUMENT_NODE: number;
+    ENTITY_NODE: number;
+    PROCESSING_INSTRUCTION_NODE: number;
+    CDATA_SECTION_NODE: number;
+    NOTATION_NODE: number;
+    DOCUMENT_POSITION_FOLLOWING: number;
+    DOCUMENT_POSITION_PRECEDING: number;
+}
+
+interface SVGPathSegCurvetoQuadraticSmoothRel extends SVGPathSeg {
+    y: number;
+    x: number;
+}
+declare var SVGPathSegCurvetoQuadraticSmoothRel: {
+    prototype: SVGPathSegCurvetoQuadraticSmoothRel;
+    new (): SVGPathSegCurvetoQuadraticSmoothRel;
+}
+
+interface DOML2DeprecatedListSpaceReduction {
+    compact: boolean;
+}
+
+interface MSScriptHost {
+}
+declare var MSScriptHost: {
+    prototype: MSScriptHost;
+    new (): MSScriptHost;
+}
+
+interface SVGClipPathElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired {
+    clipPathUnits: SVGAnimatedEnumeration;
+}
+declare var SVGClipPathElement: {
+    prototype: SVGClipPathElement;
+    new (): SVGClipPathElement;
+}
+
+interface MouseEvent extends UIEvent {
+    toElement: Element;
+    layerY: number;
+    fromElement: Element;
+    which: number;
+    pageX: number;
+    offsetY: number;
+    x: number;
+    y: number;
+    metaKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    offsetX: number;
+    screenX: number;
+    clientY: number;
+    shiftKey: boolean;
+    layerX: number;
+    screenY: number;
+    relatedTarget: EventTarget;
+    button: number;
+    pageY: number;
+    buttons: number;
+    clientX: number;
+    initMouseEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget): void;
+    getModifierState(keyArg: string): boolean;
+}
+declare var MouseEvent: {
+    prototype: MouseEvent;
+    new (): MouseEvent;
+}
+
+interface RangeException {
+    code: number;
+    message: string;
+    toString(): string;
+    INVALID_NODE_TYPE_ERR: number;
+    BAD_BOUNDARYPOINTS_ERR: number;
+}
+declare var RangeException: {
+    prototype: RangeException;
+    new (): RangeException;
+    INVALID_NODE_TYPE_ERR: number;
+    BAD_BOUNDARYPOINTS_ERR: number;
+}
+
+interface SVGTextPositioningElement extends SVGTextContentElement {
+    y: SVGAnimatedLengthList;
+    rotate: SVGAnimatedNumberList;
+    dy: SVGAnimatedLengthList;
+    x: SVGAnimatedLengthList;
+    dx: SVGAnimatedLengthList;
+}
+declare var SVGTextPositioningElement: {
+    prototype: SVGTextPositioningElement;
+    new (): SVGTextPositioningElement;
+}
+
+interface HTMLAppletElement extends HTMLElement, DOML2DeprecatedMarginStyle, DOML2DeprecatedBorderStyle, DOML2DeprecatedAlignmentStyle, MSDataBindingExtensions, MSDataBindingRecordSetExtensions {
+    width: number;
+    /**
+      * Sets or retrieves the Internet media type for the code associated with the object.
+      */
+    codeType: string;
+    object: string;
+    form: HTMLFormElement;
+    code: string;
+    /**
+      * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
+      */
+    archive: string;
+    /**
+      * Sets or retrieves a text alternative to the graphic.
+      */
+    alt: string;
+    /**
+      * Sets or retrieves a message to be displayed while an object is loading.
+      */
+    standby: string;
+    /**
+      * Sets or retrieves the class identifier for the object.
+      */
+    classid: string;
+    /**
+      * Sets or retrieves the shape of the object.
+      */
+    name: string;
+    /**
+      * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
+      */
+    useMap: string;
+    /**
+      * Sets or retrieves the URL that references the data of the object.
+      */
+    data: string;
+    /**
+      * Sets or retrieves the height of the object.
+      */
+    height: string;
+    /**
+      * Gets or sets the optional alternative HTML script to execute if the object fails to load.
+      */
+    altHtml: string;
+    /**
+      * Address of a pointer to the document this page or frame contains. If there is no document, then null will be returned.
+      */
+    contentDocument: Document;
+    /**
+      * Sets or retrieves the URL of the component.
+      */
+    codeBase: string;
+    /**
+      * Sets or retrieves a character string that can be used to implement your own declare functionality for the object.
+      */
+    declare: boolean;
+    /**
+      * Returns the content type of the object.
+      */
+    type: string;
+    /**
+      * Retrieves a string of the URL where the object tag can be found. This is often the href of the document that the object is in, or the value set by a base element.
+      */
+    BaseHref: string;
+}
+declare var HTMLAppletElement: {
+    prototype: HTMLAppletElement;
+    new (): HTMLAppletElement;
+}
+
+interface TextMetrics {
+    width: number;
+}
+declare var TextMetrics: {
+    prototype: TextMetrics;
+    new (): TextMetrics;
+}
+
+interface DocumentEvent {
+    createEvent(eventInterface: string): Event;
+}
+
+interface HTMLOListElement extends HTMLElement, DOML2DeprecatedListSpaceReduction, DOML2DeprecatedListNumberingAndBulletStyle {
+    /**
+      * The starting number.
+      */
+    start: number;
+}
+declare var HTMLOListElement: {
+    prototype: HTMLOListElement;
+    new (): HTMLOListElement;
+}
+
+interface SVGPathSegLinetoVerticalRel extends SVGPathSeg {
+    y: number;
+}
+declare var SVGPathSegLinetoVerticalRel: {
+    prototype: SVGPathSegLinetoVerticalRel;
+    new (): SVGPathSegLinetoVerticalRel;
+}
+
+interface SVGAnimatedString {
+    animVal: string;
+    baseVal: string;
+}
+declare var SVGAnimatedString: {
+    prototype: SVGAnimatedString;
+    new (): SVGAnimatedString;
+}
+
+interface CDATASection extends Text {
+}
+declare var CDATASection: {
+    prototype: CDATASection;
+    new (): CDATASection;
+}
+
+interface StyleMedia {
+    type: string;
+    matchMedium(mediaquery: string): boolean;
+}
+declare var StyleMedia: {
+    prototype: StyleMedia;
+    new (): StyleMedia;
+}
+
+interface HTMLSelectElement extends HTMLElement, MSHTMLCollectionExtensions, MSDataBindingExtensions {
+    options: HTMLSelectElement;
+    /**
+      * Sets or retrieves the value which is returned to the server when the form control is submitted.
+      */
+    value: string;
+    /**
+      * Retrieves a reference to the form that the object is embedded in. 
+      */
+    form: HTMLFormElement;
+    /**
+      * Sets or retrieves the name of the object.
+      */
+    name: string;
+    /**
+      * Sets or retrieves the number of rows in the list box. 
+      */
+    size: number;
+    /**
+      * Sets or retrieves the number of objects in a collection.
+      */
+    length: number;
+    /**
+      * Sets or retrieves the index of the selected option in a select object.
+      */
+    selectedIndex: number;
+    /**
+      * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list.
+      */
+    multiple: boolean;
+    /**
+      * Retrieves the type of select control based on the value of the MULTIPLE attribute.
+      */
+    type: string;
+    /**
+      * Removes an element from the collection.
+      * @param index Number that specifies the zero-based index of the element to remove from the collection.
+      */
+    remove(index?: number): void;
+    /**
+      * Adds an element to the areas, controlRange, or options collection.
+      * @param element Variant of type Number that specifies the index position in the collection where the element is placed. If no value is given, the method places the element at the end of the collection.
+      * @param before Variant of type Object that specifies an element to insert before, or null to append the object to the collection. 
+      */
+    add(element: HTMLElement, before?: any): void;
+    /**
+      * Retrieves a select object or an object from an options collection.
+      * @param name Variant of type Number or String that specifies the object or collection to retrieve. If this parameter is an integer, it is the zero-based index of the object. If this parameter is a string, all objects with matching name or id properties are retrieved, and a collection is returned if more than one match is made.
+      * @param index Variant of type Number that specifies the zero-based index of the object to retrieve when a collection is returned.
+      */
+    item(name?: any, index?: any): any;
+    /**
+      * Retrieves a select object or an object from an options collection.
+      * @param namedItem A String that specifies the name or id property of the object to retrieve. A collection is returned if more than one match is made.
+      */
+    namedItem(name: string): any;
+    [name: string]: any;
+}
+declare var HTMLSelectElement: {
+    prototype: HTMLSelectElement;
+    new (): HTMLSelectElement;
+}
+
+interface TextRange {
+    boundingLeft: number;
+    htmlText: string;
+    offsetLeft: number;
+    boundingWidth: number;
+    boundingHeight: number;
+    boundingTop: number;
+    text: string;
+    offsetTop: number;
+    moveToPoint(x: number, y: number): void;
+    queryCommandValue(cmdID: string): any;
+    getBookmark(): string;
+    move(unit: string, count?: number): number;
+    queryCommandIndeterm(cmdID: string): boolean;
+    scrollIntoView(fStart?: boolean): void;
+    findText(string: string, count?: number, flags?: number): boolean;
+    execCommand(cmdID: string, showUI?: boolean, value?: any): boolean;
+    getBoundingClientRect(): ClientRect;
+    moveToBookmark(bookmark: string): boolean;
+    isEqual(range: TextRange): boolean;
+    duplicate(): TextRange;
+    collapse(start?: boolean): void;
+    queryCommandText(cmdID: string): string;
+    select(): void;
+    pasteHTML(html: string): void;
+    inRange(range: TextRange): boolean;
+    moveEnd(unit: string, count?: number): number;
+    getClientRects(): ClientRectList;
+    moveStart(unit: string, count?: number): number;
+    parentElement(): Element;
+    queryCommandState(cmdID: string): boolean;
+    compareEndPoints(how: string, sourceRange: TextRange): number;
+    execCommandShowHelp(cmdID: string): boolean;
+    moveToElementText(element: Element): void;
+    expand(Unit: string): boolean;
+    queryCommandSupported(cmdID: string): boolean;
+    setEndPoint(how: string, SourceRange: TextRange): void;
+    queryCommandEnabled(cmdID: string): boolean;
+}
+declare var TextRange: {
+    prototype: TextRange;
+    new (): TextRange;
+}
+
+interface SVGTests {
+    requiredFeatures: SVGStringList;
+    requiredExtensions: SVGStringList;
+    systemLanguage: SVGStringList;
+    hasExtension(extension: string): boolean;
+}
+
+interface HTMLBlockElement extends HTMLElement, DOML2DeprecatedTextFlowControl {
+    /**
+      * Sets or retrieves the width of the object.
+      */
+    width: number;
+    /**
+      * Sets or retrieves reference information about the object.
+      */
+    cite: string;
+}
+declare var HTMLBlockElement: {
+    prototype: HTMLBlockElement;
+    new (): HTMLBlockElement;
+}
+
+interface CSSStyleSheet extends StyleSheet {
+    owningElement: Element;
+    imports: StyleSheetList;
+    isAlternate: boolean;
+    rules: MSCSSRuleList;
+    isPrefAlternate: boolean;
+    readOnly: boolean;
+    cssText: string;
+    ownerRule: CSSRule;
+    href: string;
+    cssRules: CSSRuleList;
+    id: string;
+    pages: StyleSheetPageList;
+    addImport(bstrURL: string, lIndex?: number): number;
+    addPageRule(bstrSelector: string, bstrStyle: string, lIndex?: number): number;
+    insertRule(rule: string, index?: number): number;
+    removeRule(lIndex: number): void;
+    deleteRule(index?: number): void;
+    addRule(bstrSelector: string, bstrStyle?: string, lIndex?: number): number;
+    removeImport(lIndex: number): void;
+}
+declare var CSSStyleSheet: {
+    prototype: CSSStyleSheet;
+    new (): CSSStyleSheet;
+}
+
+interface MSSelection {
+    type: string;
+    typeDetail: string;
+    createRange(): TextRange;
+    clear(): void;
+    createRangeCollection(): TextRangeCollection;
+    empty(): void;
+}
+declare var MSSelection: {
+    prototype: MSSelection;
+    new (): MSSelection;
+}
+
+interface HTMLMetaElement extends HTMLElement {
+    /**
+      * Gets or sets information used to bind the value of a content attribute of a meta element to an HTTP response header.
+      */
+    httpEquiv: string;
+    /**
+      * Sets or retrieves the value specified in the content attribute of the meta object.
+      */
+    name: string;
+    /**
+      * Gets or sets meta-information to associate with httpEquiv or name.
+      */
+    content: string;
+    /**
+      * Sets or retrieves the URL property that will be loaded after the specified time has elapsed. 
+      */
+    url: string;
+    /**
+      * Sets or retrieves a scheme to be used in interpreting the value of a property specified for the object.
+      */
+    scheme: string;
+    /**
+      * Sets or retrieves the character set used to encode the object.
+      */
+    charset: string;
+}
+declare var HTMLMetaElement: {
+    prototype: HTMLMetaElement;
+    new (): HTMLMetaElement;
+}
+
+interface SVGPatternElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGLangSpace, SVGTests, SVGFitToViewBox, SVGExternalResourcesRequired, SVGURIReference {
+    patternUnits: SVGAnimatedEnumeration;
+    y: SVGAnimatedLength;
+    width: SVGAnimatedLength;
+    x: SVGAnimatedLength;
+    patternContentUnits: SVGAnimatedEnumeration;
+    patternTransform: SVGAnimatedTransformList;
+    height: SVGAnimatedLength;
+}
+declare var SVGPatternElement: {
+    prototype: SVGPatternElement;
+    new (): SVGPatternElement;
+}
+
+interface SVGAnimatedAngle {
+    animVal: SVGAngle;
+    baseVal: SVGAngle;
+}
+declare var SVGAnimatedAngle: {
+    prototype: SVGAnimatedAngle;
+    new (): SVGAnimatedAngle;
+}
+
+interface Selection {
+    isCollapsed: boolean;
+    anchorNode: Node;
+    focusNode: Node;
+    anchorOffset: number;
+    focusOffset: number;
+    rangeCount: number;
+    addRange(range: Range): void;
+    collapseToEnd(): void;
+    toString(): string;
+    selectAllChildren(parentNode: Node): void;
+    getRangeAt(index: number): Range;
+    collapse(parentNode: Node, offset: number): void;
+    removeAllRanges(): void;
+    collapseToStart(): void;
+    deleteFromDocument(): void;
+    removeRange(range: Range): void;
+}
+declare var Selection: {
+    prototype: Selection;
+    new (): Selection;
+}
+
+interface SVGScriptElement extends SVGElement, SVGExternalResourcesRequired, SVGURIReference {
+    type: string;
+}
+declare var SVGScriptElement: {
+    prototype: SVGScriptElement;
+    new (): SVGScriptElement;
+}
+
+interface HTMLDDElement extends HTMLElement {
+    /**
+      * Sets or retrieves whether the browser automatically performs wordwrap.
+      */
+    noWrap: boolean;
+}
+declare var HTMLDDElement: {
+    prototype: HTMLDDElement;
+    new (): HTMLDDElement;
+}
+
+interface MSDataBindingRecordSetReadonlyExtensions {
+    recordset: Object;
+    namedRecordset(dataMember: string, hierarchy?: any): Object;
+}
+
+interface CSSStyleRule extends CSSRule {
+    selectorText: string;
+    style: MSStyleCSSProperties;
+    readOnly: boolean;
+}
+declare var CSSStyleRule: {
+    prototype: CSSStyleRule;
+    new (): CSSStyleRule;
+}
+
+interface NodeIterator {
+    whatToShow: number;
+    filter: NodeFilter;
+    root: Node;
+    expandEntityReferences: boolean;
+    nextNode(): Node;
+    detach(): void;
+    previousNode(): Node;
+}
+declare var NodeIterator: {
+    prototype: NodeIterator;
+    new (): NodeIterator;
+}
+
+interface SVGViewElement extends SVGElement, SVGZoomAndPan, SVGFitToViewBox, SVGExternalResourcesRequired {
+    viewTarget: SVGStringList;
+}
+declare var SVGViewElement: {
+    prototype: SVGViewElement;
+    new (): SVGViewElement;
+}
+
+interface HTMLLinkElement extends HTMLElement, LinkStyle {
+    /**
+      * Sets or retrieves the relationship between the object and the destination of the link.
+      */
+    rel: string;
+    /**
+      * Sets or retrieves the window or frame at which to target content.
+      */
+    target: string;
+    /**
+      * Sets or retrieves a destination URL or an anchor point.
+      */
+    href: string;
+    /**
+      * Sets or retrieves the media type.
+      */
+    media: string;
+    /**
+      * Sets or retrieves the relationship between the object and the destination of the link.
+      */
+    rev: string;
+    /**
+      * Sets or retrieves the MIME type of the object.
+      */
+    type: string;
+    /**
+      * Sets or retrieves the character set used to encode the object.
+      */
+    charset: string;
+    /**
+      * Sets or retrieves the language code of the object.
+      */
+    hreflang: string;
+}
+declare var HTMLLinkElement: {
+    prototype: HTMLLinkElement;
+    new (): HTMLLinkElement;
+}
+
+interface SVGLocatable {
+    farthestViewportElement: SVGElement;
+    nearestViewportElement: SVGElement;
+    getBBox(): SVGRect;
+    getTransformToElement(element: SVGElement): SVGMatrix;
+    getCTM(): SVGMatrix;
+    getScreenCTM(): SVGMatrix;
+}
+
+interface HTMLFontElement extends HTMLElement, DOML2DeprecatedColorProperty, DOML2DeprecatedSizeProperty {
+    /**
+      * Sets or retrieves the current typeface family.
+      */
+    face: string;
+}
+declare var HTMLFontElement: {
+    prototype: HTMLFontElement;
+    new (): HTMLFontElement;
+}
+
+interface SVGTitleElement extends SVGElement, SVGStylable, SVGLangSpace {
+}
+declare var SVGTitleElement: {
+    prototype: SVGTitleElement;
+    new (): SVGTitleElement;
+}
+
+interface ControlRangeCollection {
+    length: number;
+    queryCommandValue(cmdID: string): any;
+    remove(index: number): void;
+    add(item: Element): void;
+    queryCommandIndeterm(cmdID: string): boolean;
+    scrollIntoView(varargStart?: any): void;
+    item(index: number): Element;
+    [index: number]: Element;
+    execCommand(cmdID: string, showUI?: boolean, value?: any): boolean;
+    addElement(item: Element): void;
+    queryCommandState(cmdID: string): boolean;
+    queryCommandSupported(cmdID: string): boolean;
+    queryCommandEnabled(cmdID: string): boolean;
+    queryCommandText(cmdID: string): string;
+    select(): void;
+}
+declare var ControlRangeCollection: {
+    prototype: ControlRangeCollection;
+    new (): ControlRangeCollection;
+}
+
+interface MSNamespaceInfo extends MSEventAttachmentTarget {
+    urn: string;
+    onreadystatechange: (ev: Event) => any;
+    name: string;
+    readyState: string;
+    doImport(implementationUrl: string): void;
+}
+declare var MSNamespaceInfo: {
+    prototype: MSNamespaceInfo;
+    new (): MSNamespaceInfo;
+}
+
+interface WindowSessionStorage {
+    sessionStorage: Storage;
+}
+
+interface SVGAnimatedTransformList {
+    animVal: SVGTransformList;
+    baseVal: SVGTransformList;
+}
+declare var SVGAnimatedTransformList: {
+    prototype: SVGAnimatedTransformList;
+    new (): SVGAnimatedTransformList;
+}
+
+interface HTMLTableCaptionElement extends HTMLElement {
+    /**
+      * Sets or retrieves the alignment of the caption or legend.
+      */
+    align: string;
+    /**
+      * Sets or retrieves whether the caption appears at the top or bottom of the table.
+      */
+    vAlign: string;
+}
+declare var HTMLTableCaptionElement: {
+    prototype: HTMLTableCaptionElement;
+    new (): HTMLTableCaptionElement;
+}
+
+interface HTMLOptionElement extends HTMLElement, MSDataBindingExtensions {
+    /**
+      * Sets or retrieves the ordinal position of an option in a list box.
+      */
+    index: number;
+    /**
+      * Sets or retrieves the status of an option.
+      */
+    defaultSelected: boolean;
+    /**
+      * Sets or retrieves the value which is returned to the server when the form control is submitted.
+      */
+    value: string;
+    /**
+      * Sets or retrieves the text string specified by the option tag.
+      */
+    text: string;
+    /**
+      * Retrieves a reference to the form that the object is embedded in.
+      */
+    form: HTMLFormElement;
+    /**
+      * Sets or retrieves a value that you can use to implement your own label functionality for the object.
+      */
+    label: string;
+    /**
+      * Sets or retrieves whether the option in the list box is the default item.
+      */
+    selected: boolean;
+    create(): HTMLOptionElement;
+}
+declare var HTMLOptionElement: {
+    prototype: HTMLOptionElement;
+    new (): HTMLOptionElement;
+}
+
+interface HTMLMapElement extends HTMLElement {
+    /**
+      * Sets or retrieves the name of the object.
+      */
+    name: string;
+    /**
+      * Retrieves a collection of the area objects defined for the given map object.
+      */
+    areas: HTMLAreasCollection;
+}
+declare var HTMLMapElement: {
+    prototype: HTMLMapElement;
+    new (): HTMLMapElement;
+}
+
+interface HTMLMenuElement extends HTMLElement, DOML2DeprecatedListSpaceReduction {
+    type: string;
+}
+declare var HTMLMenuElement: {
+    prototype: HTMLMenuElement;
+    new (): HTMLMenuElement;
+}
+
+interface MouseWheelEvent extends MouseEvent {
+    wheelDelta: number;
+    initMouseWheelEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, buttonArg: number, relatedTargetArg: EventTarget, modifiersListArg: string, wheelDeltaArg: number): void;
+}
+declare var MouseWheelEvent: {
+    prototype: MouseWheelEvent;
+    new (): MouseWheelEvent;
+}
+
+interface SVGFitToViewBox {
+    viewBox: SVGAnimatedRect;
+    preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
+}
+
+interface SVGPointList {
+    numberOfItems: number;
+    replaceItem(newItem: SVGPoint, index: number): SVGPoint;
+    getItem(index: number): SVGPoint;
+    clear(): void;
+    appendItem(newItem: SVGPoint): SVGPoint;
+    initialize(newItem: SVGPoint): SVGPoint;
+    removeItem(index: number): SVGPoint;
+    insertItemBefore(newItem: SVGPoint, index: number): SVGPoint;
+}
+declare var SVGPointList: {
+    prototype: SVGPointList;
+    new (): SVGPointList;
+}
+
+interface SVGAnimatedLengthList {
+    animVal: SVGLengthList;
+    baseVal: SVGLengthList;
+}
+declare var SVGAnimatedLengthList: {
+    prototype: SVGAnimatedLengthList;
+    new (): SVGAnimatedLengthList;
+}
+
+interface Window extends EventTarget, MSEventAttachmentTarget, WindowLocalStorage, MSWindowExtensions, WindowSessionStorage, WindowTimers {
+    ondragend: (ev: DragEvent) => any;
+    onkeydown: (ev: KeyboardEvent) => any;
+    ondragover: (ev: DragEvent) => any;
+    onkeyup: (ev: KeyboardEvent) => any;
+    onreset: (ev: Event) => any;
+    onmouseup: (ev: MouseEvent) => any;
+    ondragstart: (ev: DragEvent) => any;
+    ondrag: (ev: DragEvent) => any;
+    screenX: number;
+    onmouseover: (ev: MouseEvent) => any;
+    ondragleave: (ev: DragEvent) => any;
+    history: History;
+    pageXOffset: number;
+    name: string;
+    onafterprint: (ev: Event) => any;
+    onpause: (ev: Event) => any;
+    onbeforeprint: (ev: Event) => any;
+    top: Window;
+    onmousedown: (ev: MouseEvent) => any;
+    onseeked: (ev: Event) => any;
+    opener: Window;
+    onclick: (ev: MouseEvent) => any;
+    innerHeight: number;
+    onwaiting: (ev: Event) => any;
+    ononline: (ev: Event) => any;
+    ondurationchange: (ev: Event) => any;
+    frames: Window;
+    onblur: (ev: FocusEvent) => any;
+    onemptied: (ev: Event) => any;
+    onseeking: (ev: Event) => any;
+    oncanplay: (ev: Event) => any;
+    outerWidth: number;
+    onstalled: (ev: Event) => any;
+    onmousemove: (ev: MouseEvent) => any;
+    innerWidth: number;
+    onoffline: (ev: Event) => any;
+    length: number;
+    screen: Screen;
+    onbeforeunload: (ev: BeforeUnloadEvent) => any;
+    onratechange: (ev: Event) => any;
+    onstorage: (ev: StorageEvent) => any;
+    onloadstart: (ev: Event) => any;
+    ondragenter: (ev: DragEvent) => any;
+    onsubmit: (ev: Event) => any;
+    self: Window;
+    document: Document;
+    onprogress: (ev: any) => any;
+    ondblclick: (ev: MouseEvent) => any;
+    pageYOffset: number;
+    oncontextmenu: (ev: MouseEvent) => any;
+    onchange: (ev: Event) => any;
+    onloadedmetadata: (ev: Event) => any;
+    onplay: (ev: Event) => any;
+    onerror: ErrorEventHandler;
+    onplaying: (ev: Event) => any;
+    parent: Window;
+    location: Location;
+    oncanplaythrough: (ev: Event) => any;
+    onabort: (ev: UIEvent) => any;
+    onreadystatechange: (ev: Event) => any;
+    outerHeight: number;
+    onkeypress: (ev: KeyboardEvent) => any;
+    frameElement: Element;
+    onloadeddata: (ev: Event) => any;
+    onsuspend: (ev: Event) => any;
+    window: Window;
+    onfocus: (ev: FocusEvent) => any;
+    onmessage: (ev: MessageEvent) => any;
+    ontimeupdate: (ev: Event) => any;
+    onresize: (ev: UIEvent) => any;
+    onselect: (ev: UIEvent) => any;
+    navigator: Navigator;
+    styleMedia: StyleMedia;
+    ondrop: (ev: DragEvent) => any;
+    onmouseout: (ev: MouseEvent) => any;
+    onended: (ev: Event) => any;
+    onhashchange: (ev: Event) => any;
+    onunload: (ev: Event) => any;
+    onscroll: (ev: UIEvent) => any;
+    screenY: number;
+    onmousewheel: (ev: MouseWheelEvent) => any;
+    onload: (ev: Event) => any;
+    onvolumechange: (ev: Event) => any;
+    oninput: (ev: Event) => any;
+    performance: Performance;
+    alert(message?: any): void;
+    scroll(x?: number, y?: number): void;
+    focus(): void;
+    scrollTo(x?: number, y?: number): void;
+    print(): void;
+    prompt(message?: string, defaul?: string): string;
+    toString(): string;
+    open(url?: string, target?: string, features?: string, replace?: boolean): Window;
+    scrollBy(x?: number, y?: number): void;
+    confirm(message?: string): boolean;
+    close(): void;
+    postMessage(message: any, targetOrigin: string, ports?: any): void;
+    showModalDialog(url?: string, argument?: any, options?: any): any;
+    blur(): void;
+    getSelection(): Selection;
+    getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration;
+}
+declare var Window: {
+    prototype: Window;
+    new (): Window;
+}
+
+interface SVGAnimatedPreserveAspectRatio {
+    animVal: SVGPreserveAspectRatio;
+    baseVal: SVGPreserveAspectRatio;
+}
+declare var SVGAnimatedPreserveAspectRatio: {
+    prototype: SVGAnimatedPreserveAspectRatio;
+    new (): SVGAnimatedPreserveAspectRatio;
+}
+
+interface MSSiteModeEvent extends Event {
+    buttonID: number;
+    actionURL: string;
+}
+declare var MSSiteModeEvent: {
+    prototype: MSSiteModeEvent;
+    new (): MSSiteModeEvent;
+}
+
+interface DOML2DeprecatedTextFlowControl {
+    clear: string;
+}
+
+interface StyleSheetPageList {
+    length: number;
+    item(index: number): CSSPageRule;
+    [index: number]: CSSPageRule;
+}
+declare var StyleSheetPageList: {
+    prototype: StyleSheetPageList;
+    new (): StyleSheetPageList;
+}
+
+interface MSCSSProperties extends CSSStyleDeclaration {
+    scrollbarShadowColor: string;
+    scrollbarHighlightColor: string;
+    layoutGridChar: string;
+    layoutGridType: string;
+    textAutospace: string;
+    textKashidaSpace: string;
+    writingMode: string;
+    scrollbarFaceColor: string;
+    backgroundPositionY: string;
+    lineBreak: string;
+    imeMode: string;
+    msBlockProgression: string;
+    layoutGridLine: string;
+    scrollbarBaseColor: string;
+    layoutGrid: string;
+    layoutFlow: string;
+    textKashida: string;
+    filter: string;
+    zoom: string;
+    scrollbarArrowColor: string;
+    behavior: string;
+    backgroundPositionX: string;
+    accelerator: string;
+    layoutGridMode: string;
+    textJustifyTrim: string;
+    scrollbar3dLightColor: string;
+    msInterpolationMode: string;
+    scrollbarTrackColor: string;
+    scrollbarDarkShadowColor: string;
+    styleFloat: string;
+    getAttribute(attributeName: string, flags?: number): any;
+    setAttribute(attributeName: string, AttributeValue: any, flags?: number): void;
+    removeAttribute(attributeName: string, flags?: number): boolean;
+}
+declare var MSCSSProperties: {
+    prototype: MSCSSProperties;
+    new (): MSCSSProperties;
+}
+
+interface HTMLCollection extends MSHTMLCollectionExtensions {
+    /**
+      * Sets or retrieves the number of objects in a collection.
+      */
+    length: number;
+    /**
+      * Retrieves an object from various collections.
+      */
+    item(nameOrIndex?: any, optionalIndex?: any): Element;
+    /**
+      * Retrieves a select object or an object from an options collection.
+      */
+    namedItem(name: string): Element;
+    [name: number]: Element;
+}
+declare var HTMLCollection: {
+    prototype: HTMLCollection;
+    new (): HTMLCollection;
+}
+
+interface SVGExternalResourcesRequired {
+    externalResourcesRequired: SVGAnimatedBoolean;
+}
+
+interface HTMLImageElement extends HTMLElement, MSImageResourceExtensions, MSDataBindingExtensions, MSResourceMetadata {
+    /**
+      * Sets or retrieves the width of the object.
+      */
+    width: number;
+    /**
+      * Sets or retrieves the vertical margin for the object.
+      */
+    vspace: number;
+    /**
+      * The original height of the image resource before sizing.
+      */
+    naturalHeight: number;
+    /**
+      * Sets or retrieves a text alternative to the graphic.
+      */
+    alt: string;
+    /**
+      * Sets or retrieves how the object is aligned with adjacent text.
+      */
+    align: string;
+    /**
+      * The address or URL of the a media resource that is to be considered.
+      */
+    src: string;
+    /**
+      * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
+      */
+    useMap: string;
+    /**
+      * The original width of the image resource before sizing.
+      */
+    naturalWidth: number;
+    /**
+      * Sets or retrieves the name of the object.
+      */
+    name: string;
+    /**
+      * Sets or retrieves the height of the object.
+      */
+    height: number;
+    /**
+      * Specifies the properties of a border drawn around an object.
+      */
+    border: string;
+    /**
+      * Sets or retrieves the width of the border to draw around the object.
+      */
+    hspace: number;
+    /**
+      * Sets or retrieves a Uniform Resource Identifier (URI) to a long description of the object.
+      */
+    longDesc: string;
+    /**
+      * Contains the hypertext reference (HREF) of the URL.
+      */
+    href: string;
+    /**
+      * Sets or retrieves whether the image is a server-side image map.
+      */
+    isMap: boolean;
+    /**
+      * Retrieves whether the object is fully loaded.
+      */
+    complete: boolean;
+    create(): HTMLImageElement;
+}
+declare var HTMLImageElement: {
+    prototype: HTMLImageElement;
+    new (): HTMLImageElement;
+}
+
+interface HTMLAreaElement extends HTMLElement {
+    /**
+      * Sets or retrieves the protocol portion of a URL.
+      */
+    protocol: string;
+    /**
+      * Sets or retrieves the substring of the href property that follows the question mark.
+      */
+    search: string;
+    /**
+      * Sets or retrieves a text alternative to the graphic.
+      */
+    alt: string;
+    /**
+      * Sets or retrieves the coordinates of the object.
+      */
+    coords: string;
+    /**
+      * Sets or retrieves the host name part of the location or URL. 
+      */
+    hostname: string;
+    /**
+      * Sets or retrieves the port number associated with a URL.
+      */
+    port: string;
+    /**
+      * Sets or retrieves the file name or path specified by the object.
+      */
+    pathname: string;
+    /**
+      * Sets or retrieves the hostname and port number of the location or URL.
+      */
+    host: string;
+    /**
+      * Sets or retrieves the subsection of the href property that follows the number sign (#).
+      */
+    hash: string;
+    /**
+      * Sets or retrieves the window or frame at which to target content.
+      */
+    target: string;
+    /**
+      * Sets or retrieves a destination URL or an anchor point.
+      */
+    href: string;
+    /**
+      * Sets or gets whether clicks in this region cause action.
+      */
+    noHref: boolean;
+    /**
+      * Sets or retrieves the shape of the object.
+      */
+    shape: string;
+    /** 
+      * Returns a string representation of an object.
+      */
+    toString(): string;
+}
+declare var HTMLAreaElement: {
+    prototype: HTMLAreaElement;
+    new (): HTMLAreaElement;
+}
+
+interface EventTarget {
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+    removeEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+    dispatchEvent(evt: Event): boolean;
+}
+
+interface SVGAngle {
+    valueAsString: string;
+    valueInSpecifiedUnits: number;
+    value: number;
+    unitType: number;
+    newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
+    convertToSpecifiedUnits(unitType: number): void;
+    SVG_ANGLETYPE_RAD: number;
+    SVG_ANGLETYPE_UNKNOWN: number;
+    SVG_ANGLETYPE_UNSPECIFIED: number;
+    SVG_ANGLETYPE_DEG: number;
+    SVG_ANGLETYPE_GRAD: number;
+}
+declare var SVGAngle: {
+    prototype: SVGAngle;
+    new (): SVGAngle;
+    SVG_ANGLETYPE_RAD: number;
+    SVG_ANGLETYPE_UNKNOWN: number;
+    SVG_ANGLETYPE_UNSPECIFIED: number;
+    SVG_ANGLETYPE_DEG: number;
+    SVG_ANGLETYPE_GRAD: number;
+}
+
+interface HTMLButtonElement extends HTMLElement, MSDataBindingExtensions {
+    /** 
+      * Sets or retrieves the default or selected value of the control.
+      */
+    value: string;
+    status: any;
+    /**
+      * Retrieves a reference to the form that the object is embedded in.
+      */
+    form: HTMLFormElement;
+    /** 
+      * Sets or retrieves the name of the object.
+      */
+    name: string;
+    /**
+      * Gets the classification and default behavior of the button.
+      */
+    type: string;
+    /**
+      * Creates a TextRange object for the element.
+      */
+    createTextRange(): TextRange;
+}
+declare var HTMLButtonElement: {
+    prototype: HTMLButtonElement;
+    new (): HTMLButtonElement;
+}
+
+interface HTMLSourceElement extends HTMLElement {
+    /**
+      * The address or URL of the a media resource that is to be considered.
+      */
+    src: string;
+    /**
+      * Gets or sets the intended media type of the media source.
+     */
+    media: string;
+    /**
+     * Gets or sets the MIME type of a media resource.
+     */
+    type: string;
+}
+declare var HTMLSourceElement: {
+    prototype: HTMLSourceElement;
+    new (): HTMLSourceElement;
+}
+
+interface CanvasGradient {
+    addColorStop(offset: number, color: string): void;
+}
+declare var CanvasGradient: {
+    prototype: CanvasGradient;
+    new (): CanvasGradient;
+}
+
+interface KeyboardEvent extends UIEvent {
+    location: number;
+    keyCode: number;
+    shiftKey: boolean;
+    which: number;
+    locale: string;
+    key: string;
+    altKey: boolean;
+    metaKey: boolean;
+    char: string;
+    ctrlKey: boolean;
+    repeat: boolean;
+    charCode: number;
+    getModifierState(keyArg: string): boolean;
+    initKeyboardEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, keyArg: string, locationArg: number, modifiersListArg: string, repeat: boolean, locale: string): void;
+    DOM_KEY_LOCATION_RIGHT: number;
+    DOM_KEY_LOCATION_STANDARD: number;
+    DOM_KEY_LOCATION_LEFT: number;
+    DOM_KEY_LOCATION_NUMPAD: number;
+    DOM_KEY_LOCATION_JOYSTICK: number;
+    DOM_KEY_LOCATION_MOBILE: number;
+}
+declare var KeyboardEvent: {
+    prototype: KeyboardEvent;
+    new (): KeyboardEvent;
+    DOM_KEY_LOCATION_RIGHT: number;
+    DOM_KEY_LOCATION_STANDARD: number;
+    DOM_KEY_LOCATION_LEFT: number;
+    DOM_KEY_LOCATION_NUMPAD: number;
+    DOM_KEY_LOCATION_JOYSTICK: number;
+    DOM_KEY_LOCATION_MOBILE: number;
+}
+
+interface Document extends Node, NodeSelector, MSEventAttachmentTarget, DocumentEvent, MSResourceMetadata, MSNodeExtensions {
+    /**
+      * Retrieves the collection of user agents and versions declared in the X-UA-Compatible
+      */
+    compatible: MSCompatibleInfoCollection;
+    /**
+      * Fires when the user presses a key.
+      * @param ev The keyboard event
+      */
+    onkeydown: (ev: KeyboardEvent) => any;
+    /**
+      * Fires when the user releases a key.
+      * @param ev The keyboard event
+      */
+    onkeyup: (ev: KeyboardEvent) => any;
+
+    /**
+      * Gets the implementation object of the current document. 
+      */
+    implementation: DOMImplementation;
+    /**
+      * Fires when the user resets a form. 
+      * @param ev The event.
+      */
+    onreset: (ev: Event) => any;
+
+    /**
+      * Retrieves a collection of all script objects in the document.
+      */
+    scripts: HTMLCollection;
+
+    /**
+      * Fires when the user presses the F1 key while the browser is the active window. 
+      * @param ev The event.
+      */
+    onhelp: (ev: Event) => any;
+
+    /** 
+      * Fires on the target object when the user moves the mouse out of a valid drop target during a drag operation.
+      * @param ev The drag event.
+      */
+    ondragleave: (ev: DragEvent) => any;
+
+    /**
+      * Gets or sets the character set used to encode the object.
+      */
+    charset: string;
+
+    /**
+      * Fires for an element just prior to setting focus on that element.
+      * @param ev The focus event
+      */
+    onfocusin: (ev: FocusEvent) => any;
+
+
+    /** 
+      * Sets or gets the color of the links that the user has visited.
+      */
+    vlinkColor: string;
+
+    /**
+      * Occurs when the seek operation ends. 
+      * @param ev The event.
+      */
+    onseeked: (ev: Event) => any;
+
+    security: string;
+
+    /**
+      * Contains the title of the document.
+      */
+    title: string;
+
+    /**
+      * Retrieves a collection of namespace objects.
+      */
+    namespaces: MSNamespaceInfoCollection;
+
+    /**
+      * Gets the default character set from the current regional language settings.
+      */
+    defaultCharset: string;
+
+    /**
+      * Retrieves a collection of all embed objects in the document.
+      */
+    embeds: HTMLCollection;
+
+    /**
+      * Retrieves a collection of styleSheet objects representing the style sheets that correspond to each instance of a link or style object in the document.
+      */
+    styleSheets: StyleSheetList;
+
+    /**
+      * Retrieves a collection of all window objects defined by the given document or defined by the document associated with the given window.
+      */
+    frames: Window;
+
+    /**
+      * Occurs when the duration attribute is updated. 
+      * @param ev The event.
+      */
+    ondurationchange: (ev: Event) => any;
+
+
+    /**
+      * Returns a reference to the collection of elements contained by the object.
+      */
+    all: HTMLCollection;
+
+    /**
+      * Retrieves a collection, in source order, of all form objects in the document.
+      */
+    forms: HTMLCollection;
+
+    /** 
+      * Fires when the object loses the input focus. 
+      * @param ev The focus event.
+      */
+    onblur: (ev: FocusEvent) => any;
+
+
+    /**
+      * Sets or retrieves a value that indicates the reading order of the object. 
+      */
+    dir: string;
+
+    /**
+      * Occurs when the media element is reset to its initial state. 
+      * @param ev The event.
+      */
+    onemptied: (ev: Event) => any;
+
+
+    /**
+      * Sets or gets a value that indicates whether the document can be edited.
+      */
+    designMode: string;
+
+    /**
+      * Occurs when the current playback position is moved. 
+      * @param ev The event.
+      */
+    onseeking: (ev: Event) => any;
+
+
+    /**
+      * Fires when the activeElement is changed from the current object to another object in the parent document.
+      * @param ev The UI Event
+      */
+    ondeactivate: (ev: UIEvent) => any;
+
+
+    /**
+      * Occurs when playback is possible, but would require further buffering. 
+      * @param ev The event.
+      */
+    oncanplay: (ev: Event) => any;
+
+
+    /**
+      * Fires when the data set exposed by a data source object changes. 
+      * @param ev The event.
+      */
+    ondatasetchanged: (ev: MSEventObj) => any;
+
+
+    /**
+      * Fires when rows are about to be deleted from the recordset.
+      * @param ev The event 
+      */
+    onrowsdelete: (ev: MSEventObj) => any;
+
+    Script: MSScriptHost;
+
+    /**
+      * Occurs when Internet Explorer begins looking for media data. 
+      * @param ev The event.
+      */
+    onloadstart: (ev: Event) => any;
+
+
+    /**
+      * Gets the URL for the document, stripped of any character encoding.
+      */
+    URLUnencoded: string;
+
+    defaultView: Window;
+
+    /**
+      * Fires when the user is about to make a control selection of the object.
+      * @param ev The event.
+      */
+    oncontrolselect: (ev: MSEventObj) => any;
+
+
+    /** 
+      * Fires on the target element when the user drags the object to a valid drop target.
+      * @param ev The drag event.
+      */
+    ondragenter: (ev: DragEvent) => any;
+
+    onsubmit: (ev: Event) => any;
+
+    /**
+      * Returns the character encoding used to create the webpage that is loaded into the document object.
+      */
+    inputEncoding: string;
+
+    /**
+      * Gets the object that has the focus when the parent document has focus.
+      */
+    activeElement: Element;
+
+    /**
+      * Fires when the contents of the object or selection have changed. 
+      * @param ev The event.
+      */
+    onchange: (ev: Event) => any;
+
+
+    /**
+      * Retrieves a collection of all a objects that specify the href property and all area objects in the document.
+      */
+    links: HTMLCollection;
+
+    /**
+      * Retrieves an autogenerated, unique identifier for the object. 
+      */
+    uniqueID: string;
+
+    /**
+      * Sets or gets the URL for the current document. 
+      */
+    URL: string;
+
+    /**
+      * Fires immediately before the object is set as the active element.
+      * @param ev The event.
+      */
+    onbeforeactivate: (ev: UIEvent) => any;
+
+    head: HTMLHeadElement;
+    cookie: string;
+    xmlEncoding: string;
+    oncanplaythrough: (ev: Event) => any;
+
+    /** 
+      * Retrieves the document compatibility mode of the document.
+      */
+    documentMode: number;
+
+    characterSet: string;
+
+    /**
+      * Retrieves a collection of all a objects that have a name and/or id property. Objects in this collection are in HTML source order.
+      */
+    anchors: HTMLCollection;
+
+    onbeforeupdate: (ev: MSEventObj) => any;
+
+    /** 
+      * Fires to indicate that all data is available from the data source object. 
+      * @param ev The event.
+      */
+    ondatasetcomplete: (ev: MSEventObj) => any;
+
+    plugins: HTMLCollection;
+
+    /**
+      * Occurs if the load operation has been intentionally halted. 
+      * @param ev The event.
+      */
+    onsuspend: (ev: Event) => any;
+
+
+    /**
+      * Gets the root svg element in the document hierarchy.
+      */
+    rootElement: SVGSVGElement;
+
+    /**
+      * Retrieves a value that indicates the current state of the object.
+      */
+    readyState: string;
+
+    /**
+      * Gets the URL of the location that referred the user to the current page.
+      */
+    referrer: string;
+
+    /**
+      * Sets or gets the color of all active links in the document.
+      */
+    alinkColor: string;
+
+    /**
+      * Fires on a databound object when an error occurs while updating the associated data in the data source object. 
+      * @param ev The event.
+      */
+    onerrorupdate: (ev: MSEventObj) => any;
+
+
+    /**
+      * Gets a reference to the container object of the window.
+      */
+    parentWindow: Window;
+
+    /**
+      * Fires when the user moves the mouse pointer outside the boundaries of the object. 
+      * @param ev The mouse event.
+      */
+    onmouseout: (ev: MouseEvent) => any;
+
+
+    /**
+      * Occurs when a user clicks a button in a Thumbnail Toolbar of a webpage running in Site Mode.
+      * @param ev The event.
+      */
+    onmsthumbnailclick: (ev: MSSiteModeEvent) => any;
+
+
+    /**
+      * Fires when the wheel button is rotated. 
+      * @param ev The mouse event
+      */
+    onmousewheel: (ev: MouseWheelEvent) => any;
+
+
+    /**
+      * Occurs when the volume is changed, or playback is muted or unmuted.
+      * @param ev The event.
+      */
+    onvolumechange: (ev: Event) => any;
+
+
+    /** 
+      * Fires when data changes in the data provider.
+      * @param ev The event.
+      */
+    oncellchange: (ev: MSEventObj) => any;
+
+
+    /**
+      * Fires just before the data source control changes the current row in the object. 
+      * @param ev The event.
+      */
+    onrowexit: (ev: MSEventObj) => any;
+
+
+    /**
+      * Fires just after new rows are inserted in the current recordset.
+      * @param ev The event.
+      */
+    onrowsinserted: (ev: MSEventObj) => any;
+
+
+    /**
+      * Gets or sets the version attribute specified in the declaration of an XML document.
+      */
+    xmlVersion: string;
+
+    msCapsLockWarningOff: boolean;
+
+    /**
+      * Fires when a property changes on the object.
+      * @param ev The event.
+      */
+    onpropertychange: (ev: MSEventObj) => any;
+
+
+    /**
+      * Fires on the source object when the user releases the mouse at the close of a drag operation.
+      * @param ev The event.
+      */
+    ondragend: (ev: DragEvent) => any;
+
+
+    /**
+      * Gets an object representing the document type declaration associated with the current document. 
+      */
+    doctype: DocumentType;
+
+    /**
+      * Fires on the target element continuously while the user drags the object over a valid drop target.
+      * @param ev The event.
+      */
+    ondragover: (ev: DragEvent) => any;
+
+
+    /**
+      * Deprecated. Sets or retrieves a value that indicates the background color behind the object. 
+      */
+    bgColor: string;
+
+    /**
+      * Fires on the source object when the user starts to drag a text selection or selected object. 
+      * @param ev The event.
+      */
+    ondragstart: (ev: DragEvent) => any;
+
+
+    /**
+      * Fires when the user releases a mouse button while the mouse is over the object. 
+      * @param ev The mouse event.
+      */
+    onmouseup: (ev: MouseEvent) => any;
+
+
+    /**
+      * Fires on the source object continuously during a drag operation.
+      * @param ev The event.
+      */
+    ondrag: (ev: DragEvent) => any;
+
+
+    /**
+      * Fires when the user moves the mouse pointer into the object.
+      * @param ev The mouse event.
+      */
+    onmouseover: (ev: MouseEvent) => any;
+
+
+    /**
+      * Sets or gets the color of the document links. 
+      */
+    linkColor: string;
+
+    /**
+      * Occurs when playback is paused.
+      * @param ev The event.
+      */
+    onpause: (ev: Event) => any;
+
+
+    /**
+      * Fires when the user clicks the object with either mouse button. 
+      * @param ev The mouse event.
+      */
+    onmousedown: (ev: MouseEvent) => any;
+
+
+    /**
+      * Fires when the user clicks the left mouse button on the object
+      * @param ev The mouse event.
+      */
+    onclick: (ev: MouseEvent) => any;
+
+
+    /**
+      * Occurs when playback stops because the next frame of a video resource is not available. 
+      * @param ev The event.
+      */
+    onwaiting: (ev: Event) => any;
+
+
+    /**
+      * Fires when the user clicks the Stop button or leaves the Web page.
+      * @param ev The event.
+      */
+    onstop: (ev: Event) => any;
+
+    /**
+      * false (false)[rolls
+      */
+
+    /**
+      * Occurs when an item is removed from a Jump List of a webpage running in Site Mode. 
+      * @param ev The event.
+      */
+    onmssitemodejumplistitemremoved: (ev: MSSiteModeEvent) => any;
+
+
+    /**
+      * Retrieves a collection of all applet objects in the document.
+      */
+    applets: HTMLCollection;
+
+    /**
+      * Specifies the beginning and end of the document body.
+      */
+    body: HTMLElement;
+
+    /**
+      * Sets or gets the security domain of the document. 
+      */
+    domain: string;
+
+    xmlStandalone: boolean;
+
+    /**
+      * Represents the active selection, which is a highlighted block of text or other elements in the document that a user or a script can carry out some action on.
+      */
+    selection: MSSelection;
+
+    /**
+      * Occurs when the download has stopped. 
+      * @param ev The event.
+      */
+    onstalled: (ev: Event) => any;
+
+
+    /**
+      * Fires when the user moves the mouse over the object. 
+      * @param ev The mouse event.
+      */
+    onmousemove: (ev: MouseEvent) => any;
+
+
+    /**
+      * Gets a reference to the root node of the document. 
+      */
+    documentElement: HTMLElement;
+
+    /**
+      * Fires before an object contained in an editable element enters a UI-activated state or when an editable container object is control selected.
+      * @param ev The event.
+      */
+    onbeforeeditfocus: (ev: MSEventObj) => any;
+
+
+    /**
+      * Occurs when the playback rate is increased or decreased. 
+      * @param ev The event.
+      */
+    onratechange: (ev: Event) => any;
+
+
+    /**
+      * Occurs to indicate progress while downloading media data. 
+      * @param ev The event.
+      */
+    onprogress: (ev: any) => any;
+
+
+    /**
+      * Fires when the user double-clicks the object.
+      * @param ev The mouse event.
+      */
+    ondblclick: (ev: MouseEvent) => any;
+
+
+    /**
+      * Fires when the user clicks the right mouse button in the client area, opening the context menu. 
+      * @param ev The mouse event.
+      */
+    oncontextmenu: (ev: MouseEvent) => any;
+
+
+    /**
+      * Occurs when the duration and dimensions of the media have been determined.
+      * @param ev The event.
+      */
+    onloadedmetadata: (ev: Event) => any;
+
+    media: string;
+
+    /**
+      * Fires when an error occurs during object loading.
+      * @param ev The event.
+      */
+    onerror: (ev: Event) => any;
+
+
+    /**
+      * Occurs when the play method is requested. 
+      * @param ev The event.
+      */
+    onplay: (ev: Event) => any;
+
+    onafterupdate: (ev: MSEventObj) => any;
+
+    /**
+      * Occurs when the audio or video has started playing. 
+      * @param ev The event.
+      */
+    onplaying: (ev: Event) => any;
+
+
+    /**
+      * Retrieves a collection, in source order, of img objects in the document.
+      */
+    images: HTMLCollection;
+
+    /**
+      * Contains information about the current URL. 
+      */
+    location: Location;
+
+    /**
+      * Fires when the user aborts the download.
+      * @param ev The event.
+      */
+    onabort: (ev: UIEvent) => any;
+
+
+    /**
+      * Fires for the current element with focus immediately after moving focus to another element. 
+      * @param ev The event.
+      */
+    onfocusout: (ev: FocusEvent) => any;
+
+
+    /**
+      * Fires when the selection state of a document changes.
+      * @param ev The event.
+      */
+    onselectionchange: (ev: Event) => any;
+
+
+    /**
+      * Fires when a local DOM Storage area is written to disk.
+      * @param ev The event.
+      */
+    onstoragecommit: (ev: StorageEvent) => any;
+
+
+    /**
+      * Fires periodically as data arrives from data source objects that asynchronously transmit their data. 
+      * @param ev The event.
+      */
+    ondataavailable: (ev: MSEventObj) => any;
+
+
+    /**
+      * Fires when the state of the object has changed.
+      * @param ev The event
+      */
+    onreadystatechange: (ev: Event) => any;
+
+
+    /**
+      * Gets the date that the page was last modified, if the page supplies one. 
+      */
+    lastModified: string;
+
+    /**
+      * Fires when the user presses an alphanumeric key.
+      * @param ev The event.
+      */
+    onkeypress: (ev: KeyboardEvent) => any;
+
+
+    /**
+      * Occurs when media data is loaded at the current playback position. 
+      * @param ev The event.
+      */
+    onloadeddata: (ev: Event) => any;
+
+
+    /**
+      * Fires immediately before the activeElement is changed from the current object to another object in the parent document.
+      * @param ev The event.
+      */
+    onbeforedeactivate: (ev: UIEvent) => any;
+
+
+    /**
+      * Fires when the object is set as the active element.
+      * @param ev The event.
+      */
+    onactivate: (ev: UIEvent) => any;
+
+
+    onselectstart: (ev: Event) => any;
+
+    /**
+      * Fires when the object receives focus. 
+      * @param ev The event.
+      */
+    onfocus: (ev: FocusEvent) => any;
+
+
+    /**
+      * Sets or gets the foreground (text) color of the document.
+      */
+    fgColor: string;
+
+    /**
+      * Occurs to indicate the current playback position.
+      * @param ev The event.
+      */
+    ontimeupdate: (ev: Event) => any;
+
+
+    /**
+      * Fires when the current selection changes.
+      * @param ev The event.
+      */
+    onselect: (ev: UIEvent) => any;
+
+    ondrop: (ev: DragEvent) => any;
+
+    /**
+      * Occurs when the end of playback is reached. 
+      * @param ev The event
+      */
+    onended: (ev: Event) => any;
+
+
+    /**
+      * Gets a value that indicates whether standards-compliant mode is switched on for the object.
+      */
+    compatMode: string;
+
+    /**
+      * Fires when the user repositions the scroll box in the scroll bar on the object. 
+      * @param ev The event.
+      */
+    onscroll: (ev: UIEvent) => any;
+
+
+    /**
+      * Fires to indicate that the current row has changed in the data source and new data values are available on the object. 
+      * @param ev The event.
+      */
+    onrowenter: (ev: MSEventObj) => any;
+
+
+    /**
+      * Fires immediately after the browser loads the object. 
+      * @param ev The event.
+      */
+    onload: (ev: Event) => any;
+
+    oninput: (ev: Event) => any;
+
+    /**
+      * Returns the current value of the document, range, or current selection for the given command.
+      * @param commandId String that specifies a command identifier.
+      */
+    queryCommandValue(commandId: string): string;
+
+    adoptNode(source: Node): Node;
+
+    /**
+      * Returns a Boolean value that indicates whether the specified command is in the indeterminate state.
+      * @param commandId String that specifies a command identifier.
+      */
+    queryCommandIndeterm(commandId: string): boolean;
+
+    getElementsByTagNameNS(namespaceURI: string, localName: string): NodeList;
+    createProcessingInstruction(target: string, data: string): ProcessingInstruction;
+
+    /**
+      * Executes a command on the current document, current selection, or the given range.
+      * @param commandId String that specifies the command to execute. This command can be any of the command identifiers that can be executed in script.
+      * @param showUI Display the user interface, defaults to false.
+      * @param value Value to assign.
+      */
+    execCommand(commandId: string, showUI?: boolean, value?: any): boolean;
+
+    /**
+      * Returns the element for the specified x coordinate and the specified y coordinate. 
+      * @param x The x-offset
+      * @param y The y-offset
+      */
+    elementFromPoint(x: number, y: number): Element;
+    createCDATASection(data: string): CDATASection;
+
+    /**
+      * Retrieves the string associated with a command.
+      * @param commandId String that contains the identifier of a command. This can be any command identifier given in the list of Command Identifiers. 
+      */
+    queryCommandText(commandId: string): string;
+
+    /**
+      * Writes one or more HTML expressions to a document in the specified window. 
+      * @param content Specifies the text and HTML tags to write.
+      */
+    write(...content: string[]): void;
+
+    /**
+      * Allows updating the print settings for the page.
+      */
+    updateSettings(): void;
+
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "a"): HTMLAnchorElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "abbr"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "address"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "area"): HTMLAreaElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "article"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "aside"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "audio"): HTMLAudioElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "b"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "base"): HTMLBaseElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "bdi"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "bdo"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "blockquote"): HTMLQuoteElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "body"): HTMLBodyElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "br"): HTMLBRElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "button"): HTMLButtonElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "canvas"): HTMLCanvasElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "caption"): HTMLTableCaptionElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "cite"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "code"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "col"): HTMLTableColElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "colgroup"): HTMLTableColElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "datalist"): HTMLDataListElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "dd"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "del"): HTMLModElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "dfn"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "div"): HTMLDivElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "dl"): HTMLDListElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "dt"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "em"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "embed"): HTMLEmbedElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "fieldset"): HTMLFieldSetElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "figcaption"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "figure"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "footer"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "form"): HTMLFormElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "h1"): HTMLHeadingElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "h2"): HTMLHeadingElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "h3"): HTMLHeadingElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "h4"): HTMLHeadingElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "h5"): HTMLHeadingElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "h6"): HTMLHeadingElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "head"): HTMLHeadElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "header"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "hgroup"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "hr"): HTMLHRElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "html"): HTMLHtmlElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "i"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "iframe"): HTMLIFrameElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "img"): HTMLImageElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "input"): HTMLInputElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "ins"): HTMLModElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "kbd"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "label"): HTMLLabelElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "legend"): HTMLLegendElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "li"): HTMLLIElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "link"): HTMLLinkElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "main"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "map"): HTMLMapElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "mark"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "menu"): HTMLMenuElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "meta"): HTMLMetaElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "nav"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "noscript"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "object"): HTMLObjectElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "ol"): HTMLOListElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "optgroup"): HTMLOptGroupElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "option"): HTMLOptionElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "p"): HTMLParagraphElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "param"): HTMLParamElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "pre"): HTMLPreElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "progress"): HTMLProgressElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "q"): HTMLQuoteElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "rp"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "rt"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "ruby"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "s"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "samp"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "script"): HTMLScriptElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "section"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "select"): HTMLSelectElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "small"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "source"): HTMLSourceElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "span"): HTMLSpanElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "strong"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "style"): HTMLStyleElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "sub"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "summary"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "sup"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "table"): HTMLTableElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "tbody"): HTMLTableSectionElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "td"): HTMLTableDataCellElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "textarea"): HTMLTextAreaElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "tfoot"): HTMLTableSectionElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "th"): HTMLTableHeaderCellElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "thead"): HTMLTableSectionElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "title"): HTMLTitleElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "tr"): HTMLTableRowElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "track"): HTMLTrackElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "u"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "ul"): HTMLUListElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "var"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "video"): HTMLVideoElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: "wbr"): HTMLElement;
+    /**
+      * Creates an instance of the element for the specified tag.
+      * @param tagName The name of an element.
+      */
+    createElement(tagName: string): HTMLElement;
+
+    /**
+      * Removes mouse capture from the object in the current document.
+      */
+    releaseCapture(): void;
+
+    /**
+      * Writes one or more HTML expressions, followed by a carriage return, to a document in the specified window. 
+      * @param content The text and HTML tags to write.
+      */
+    writeln(...content: string[]): void;
+    createElementNS(namespaceURI: string, qualifiedName: string): Element;
+
+    /**
+      * Opens a new window and loads a document specified by a given URL. Also, opens a new window that uses the url parameter and the name parameter to collect the output of the write method and the writeln method.
+      * @param url Specifies a MIME type for the document.
+      * @param name Specifies the name of the window. This name is used as the value for the TARGET attribute on a form or an anchor element.
+      * @param features Contains a list of items separated by commas. Each item consists of an option and a value, separated by an equals sign (for example, "fullscreen=yes, toolbar=yes"). The following values are supported.
+      * @param replace Specifies whether the existing entry for the document is replaced in the history list.
+      */
+    open(url?: string, name?: string, features?: string, replace?: boolean): any;
+
+    /**
+      * Returns a Boolean value that indicates whether the current command is supported on the current range.
+      * @param commandId Specifies a command identifier.
+      */
+    queryCommandSupported(commandId: string): boolean;
+
+    /**
+      * Creates a TreeWalker object that you can use to traverse filtered lists of nodes or elements in a document.
+      * @param root The root element or node to start traversing on.
+      * @param whatToShow The type of nodes or elements to appear in the node list. For more information, see whatToShow.
+      * @param filter A custom NodeFilter function to use.
+      * @param entityReferenceExpansion A flag that specifies whether entity reference nodes are expanded.
+      */
+    createTreeWalker(root: Node, whatToShow: number, filter: NodeFilter, entityReferenceExpansion: boolean): TreeWalker;
+    createAttributeNS(namespaceURI: string, qualifiedName: string): Attr;
+
+    /** 
+      * Returns a Boolean value that indicates whether a specified command can be successfully executed using execCommand, given the current state of the document.
+      * @param commandId Specifies a command identifier.
+      */
+    queryCommandEnabled(commandId: string): boolean;
+
+    /**
+      * Causes the element to receive the focus and executes the code specified by the onfocus event.
+      */
+    focus(): void;
+
+    /**
+      * Closes an output stream and forces the sent data to display.
+      */
+    close(): void;
+
+    getElementsByClassName(classNames: string): NodeList;
+    importNode(importedNode: Node, deep: boolean): Node;
+
+    /**
+      *  Returns an empty range object that has both of its boundary points positioned at the beginning of the document. 
+      */
+    createRange(): Range;
+
+    /**
+      * Fires a specified event on the object.
+      * @param eventName Specifies the name of the event to fire.
+      * @param eventObj Object that specifies the event object from which to obtain event object properties.
+      */
+    fireEvent(eventName: string, eventObj?: any): boolean;
+
+    /**
+      * Creates a comment object with the specified data.
+      * @param data Sets the comment object's data.
+      */
+    createComment(data: string): Comment;
+
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "a"): NodeListOf<HTMLAnchorElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "abbr"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "address"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "area"): NodeListOf<HTMLAreaElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "article"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "aside"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "audio"): NodeListOf<HTMLAudioElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "b"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "base"): NodeListOf<HTMLBaseElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "bdi"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "bdo"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "blockquote"): NodeListOf<HTMLQuoteElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "body"): NodeListOf<HTMLBodyElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "br"): NodeListOf<HTMLBRElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "button"): NodeListOf<HTMLButtonElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "canvas"): NodeListOf<HTMLCanvasElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "caption"): NodeListOf<HTMLTableCaptionElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "cite"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "code"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "col"): NodeListOf<HTMLTableColElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "colgroup"): NodeListOf<HTMLTableColElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "datalist"): NodeListOf<HTMLDataListElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "dd"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "del"): NodeListOf<HTMLModElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "dfn"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "div"): NodeListOf<HTMLDivElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "dl"): NodeListOf<HTMLDListElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "dt"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "em"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "embed"): NodeListOf<HTMLEmbedElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "fieldset"): NodeListOf<HTMLFieldSetElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "figcaption"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "figure"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "footer"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "form"): NodeListOf<HTMLFormElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "h1"): NodeListOf<HTMLHeadingElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "h2"): NodeListOf<HTMLHeadingElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "h3"): NodeListOf<HTMLHeadingElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "h4"): NodeListOf<HTMLHeadingElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "h5"): NodeListOf<HTMLHeadingElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "h6"): NodeListOf<HTMLHeadingElement>;
+    /**
+     * Retrieves a collection of objects based on the specified element name.
+     * @param name Specifies the name of an element.
+     */
+    getElementsByTagName(name: "head"): NodeListOf<HTMLHeadElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "header"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "hgroup"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "hr"): NodeListOf<HTMLHRElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "html"): NodeListOf<HTMLHtmlElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "i"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "iframe"): NodeListOf<HTMLIFrameElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "img"): NodeListOf<HTMLImageElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "input"): NodeListOf<HTMLInputElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "ins"): NodeListOf<HTMLModElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "kbd"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "label"): NodeListOf<HTMLLabelElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "legend"): NodeListOf<HTMLLegendElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "li"): NodeListOf<HTMLLIElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "link"): NodeListOf<HTMLLinkElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "main"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "map"): NodeListOf<HTMLMapElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "mark"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "menu"): NodeListOf<HTMLMenuElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "meta"): NodeListOf<HTMLMetaElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "nav"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "noscript"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "object"): NodeListOf<HTMLObjectElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "ol"): NodeListOf<HTMLOListElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "optgroup"): NodeListOf<HTMLOptGroupElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "option"): NodeListOf<HTMLOptionElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "p"): NodeListOf<HTMLParagraphElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "param"): NodeListOf<HTMLParamElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "pre"): NodeListOf<HTMLPreElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "progress"): NodeListOf<HTMLProgressElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "q"): NodeListOf<HTMLQuoteElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "rp"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "rt"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "ruby"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "s"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "samp"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "script"): NodeListOf<HTMLScriptElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "section"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "select"): NodeListOf<HTMLSelectElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "small"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "source"): NodeListOf<HTMLSourceElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "span"): NodeListOf<HTMLSpanElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "strong"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "style"): NodeListOf<HTMLStyleElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "sub"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "summary"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "sup"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "table"): NodeListOf<HTMLTableElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "tbody"): NodeListOf<HTMLTableSectionElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "td"): NodeListOf<HTMLTableDataCellElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "textarea"): NodeListOf<HTMLTextAreaElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "tfoot"): NodeListOf<HTMLTableSectionElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "th"): NodeListOf<HTMLTableHeaderCellElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "thead"): NodeListOf<HTMLTableSectionElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "title"): NodeListOf<HTMLTitleElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "tr"): NodeListOf<HTMLTableRowElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "track"): NodeListOf<HTMLTrackElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "u"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "ul"): NodeListOf<HTMLUListElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "var"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "video"): NodeListOf<HTMLVideoElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: "wbr"): NodeListOf<HTMLElement>;
+    /**
+      * Retrieves a collection of objects based on the specified element name.
+      * @param name Specifies the name of an element.
+      */
+    getElementsByTagName(name: string): NodeList;
+
+    /**
+      * Creates a new document.
+      */
+    createDocumentFragment(): DocumentFragment;
+
+    /**
+      * Creates a style sheet for the document. 
+      * @param href Specifies how to add the style sheet to the document. If a file name is specified for the URL, the style information is added as a link object. If the URL contains style information, it is added to the style object.
+      * @param index Specifies the index that indicates where the new style sheet is inserted in the styleSheets collection. The default is to insert the new style sheet at the end of the collection.
+      */
+    createStyleSheet(href?: string, index?: number): CSSStyleSheet;
+
+    /**
+      * Gets a collection of objects based on the value of the NAME or ID attribute.
+      * @param elementName Gets a collection of objects based on the value of the NAME or ID attribute.
+      */
+    getElementsByName(elementName: string): NodeList;
+
+    /**
+      * Returns a Boolean value that indicates the current state of the command.
+      * @param commandId String that specifies a command identifier.
+      */
+    queryCommandState(commandId: string): boolean;
+
+    /**
+      * Gets a value indicating whether the object currently has focus.
+      */
+    hasFocus(): boolean;
+
+    /**
+      * Displays help information for the given command identifier.
+      * @param commandId Displays help information for the given command identifier.
+      */
+    execCommandShowHelp(commandId: string): boolean;
+
+    /**
+      * Creates an attribute object with a specified name.
+      * @param name String that sets the attribute object's name.
+      */
+    createAttribute(name: string): Attr;
+
+    /**
+      * Creates a text string from the specified value. 
+      * @param data String that specifies the nodeValue property of the text node.
+      */
+    createTextNode(data: string): Text;
+
+    /**
+      * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document. 
+      * @param root The root element or node to start traversing on.
+      * @param whatToShow The type of nodes or elements to appear in the node list
+      * @param filter A custom NodeFilter function to use. For more information, see filter. Use null for no filter.
+      * @param entityReferenceExpansion A flag that specifies whether entity reference nodes are expanded.
+      */
+    createNodeIterator(root: Node, whatToShow: number, filter: NodeFilter, entityReferenceExpansion: boolean): NodeIterator;
+
+    /**
+      * Generates an event object to pass event context information when you use the fireEvent method.
+      * @param eventObj An object that specifies an existing event object on which to base the new object.
+      */
+    createEventObject(eventObj?: any): MSEventObj;
+
+    /**
+      * Returns an object representing the current selection of the document that is loaded into the object displaying a webpage.
+      */
+    getSelection(): Selection;
+
+    /**
+      * Returns a reference to the first object with the specified value of the ID or NAME attribute.
+      * @param elementId String that specifies the ID value. Case-insensitive.
+      */
+    getElementById(elementId: string): HTMLElement;
+}
+
+declare var Document: {
+    prototype: Document;
+    new (): Document;
+}
+
+interface MessageEvent extends Event {
+    source: Window;
+    origin: string;
+    data: any;
+    initMessageEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, dataArg: any, originArg: string, lastEventIdArg: string, sourceArg: Window): void;
+}
+declare var MessageEvent: {
+    prototype: MessageEvent;
+    new (): MessageEvent;
+}
+
+interface SVGElement extends Element {
+    onmouseover: (ev: MouseEvent) => any;
+    viewportElement: SVGElement;
+    onmousemove: (ev: MouseEvent) => any;
+    onmouseout: (ev: MouseEvent) => any;
+    ondblclick: (ev: MouseEvent) => any;
+    onfocusout: (ev: FocusEvent) => any;
+    onfocusin: (ev: FocusEvent) => any;
+    xmlbase: string;
+    onmousedown: (ev: MouseEvent) => any;
+    onload: (ev: Event) => any;
+    onmouseup: (ev: MouseEvent) => any;
+    onclick: (ev: MouseEvent) => any;
+    ownerSVGElement: SVGSVGElement;
+    id: string;
+}
+declare var SVGElement: {
+    prototype: SVGElement;
+    new (): SVGElement;
+}
+
+interface HTMLScriptElement extends HTMLElement {
+    /**
+      * Sets or retrieves the status of the script.
+      */
+    defer: boolean;
+    /**
+      * Retrieves or sets the text of the object as a string. 
+      */
+    text: string;
+    /**
+      * Retrieves the URL to an external file that contains the source code or data.
+      */
+    src: string;
+    /** 
+      * Sets or retrieves the object that is bound to the event script.
+      */
+    htmlFor: string;
+    /**
+      * Sets or retrieves the character set used to encode the object.
+      */
+    charset: string;
+    /**
+      * Sets or retrieves the MIME type for the associated scripting engine.
+      */
+    type: string;
+    /**
+      * Sets or retrieves the event for which the script is written. 
+      */
+    event: string;
+}
+declare var HTMLScriptElement: {
+    prototype: HTMLScriptElement;
+    new (): HTMLScriptElement;
+}
+
+interface HTMLTableRowElement extends HTMLElement, HTMLTableAlignment, DOML2DeprecatedBackgroundColorStyle {
+    /**
+      * Retrieves the position of the object in the rows collection for the table.
+      */
+    rowIndex: number;
+    /**
+      * Retrieves a collection of all cells in the table row.
+      */
+    cells: HTMLCollection;
+    /**
+      * Sets or retrieves how the object is aligned with adjacent text.
+      */
+    align: string;
+    /**
+      * Sets or retrieves the color for one of the two colors used to draw the 3-D border of the object.
+      */
+    borderColorLight: any;
+    /**
+      * Retrieves the position of the object in the collection.
+      */
+    sectionRowIndex: number;
+    /**
+      * Sets or retrieves the border color of the object.
+      */
+    borderColor: any;
+    /**
+      * Sets or retrieves the height of the object.
+      */
+    height: any;
+    /**
+      * Sets or retrieves the color for one of the two colors used to draw the 3-D border of the object.
+      */
+    borderColorDark: any;
+    /**
+      * Removes the specified cell from the table row, as well as from the cells collection.
+      * @param index Number that specifies the zero-based position of the cell to remove from the table row. If no value is provided, the last cell in the cells collection is deleted.
+      */
+    deleteCell(index?: number): void;
+    /**
+      * Creates a new cell in the table row, and adds the cell to the cells collection.
+      * @param index Number that specifies where to insert the cell in the tr. The default value is -1, which appends the new cell to the end of the cells collection.
+      */
+    insertCell(index?: number): HTMLElement;
+}
+declare var HTMLTableRowElement: {
+    prototype: HTMLTableRowElement;
+    new (): HTMLTableRowElement;
+}
+
+interface CanvasRenderingContext2D {
+    miterLimit: number;
+    font: string;
+    globalCompositeOperation: string;
+    msFillRule: string;
+    lineCap: string;
+    msImageSmoothingEnabled: boolean;
+    lineDashOffset: number;
+    shadowColor: string;
+    lineJoin: string;
+    shadowOffsetX: number;
+    lineWidth: number;
+    canvas: HTMLCanvasElement;
+    strokeStyle: any;
+    globalAlpha: number;
+    shadowOffsetY: number;
+    fillStyle: any;
+    shadowBlur: number;
+    textAlign: string;
+    textBaseline: string;
+    restore(): void;
+    setTransform(m11: number, m12: number, m21: number, m22: number, dx: number, dy: number): void;
+    save(): void;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
+    measureText(text: string): TextMetrics;
+    isPointInPath(x: number, y: number, fillRule?: string): boolean;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX?: number, dirtyY?: number, dirtyWidth?: number, dirtyHeight?: number): void;
+    rotate(angle: number): void;
+    fillText(text: string, x: number, y: number, maxWidth?: number): void;
+    translate(x: number, y: number): void;
+    scale(x: number, y: number): void;
+    createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
+    lineTo(x: number, y: number): void;
+    getLineDash(): Array<number>;
+    fill(fillRule?: string): void;
+    createImageData(imageDataOrSw: any, sh?: number): ImageData;
+    createPattern(image: HTMLElement, repetition: string): CanvasPattern;
+    closePath(): void;
+    rect(x: number, y: number, w: number, h: number): void;
+    clip(fillRule?: string): void;
+    clearRect(x: number, y: number, w: number, h: number): void;
+    moveTo(x: number, y: number): void;
+    getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
+    fillRect(x: number, y: number, w: number, h: number): void;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    drawImage(image: HTMLElement, offsetX: number, offsetY: number, width?: number, height?: number, canvasOffsetX?: number, canvasOffsetY?: number, canvasImageWidth?: number, canvasImageHeight?: number): void;
+    transform(m11: number, m12: number, m21: number, m22: number, dx: number, dy: number): void;
+    stroke(): void;
+    strokeRect(x: number, y: number, w: number, h: number): void;
+    setLineDash(segments: Array<number>): void;
+    strokeText(text: string, x: number, y: number, maxWidth?: number): void;
+    beginPath(): void;
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+    createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
+}
+declare var CanvasRenderingContext2D: {
+    prototype: CanvasRenderingContext2D;
+    new (): CanvasRenderingContext2D;
+}
+
+interface MSCSSRuleList {
+    length: number;
+    item(index?: number): CSSStyleRule;
+    [index: number]: CSSStyleRule;
+}
+declare var MSCSSRuleList: {
+    prototype: MSCSSRuleList;
+    new (): MSCSSRuleList;
+}
+
+interface SVGPathSegLinetoHorizontalAbs extends SVGPathSeg {
+    x: number;
+}
+declare var SVGPathSegLinetoHorizontalAbs: {
+    prototype: SVGPathSegLinetoHorizontalAbs;
+    new (): SVGPathSegLinetoHorizontalAbs;
+}
+
+interface SVGPathSegArcAbs extends SVGPathSeg {
+    y: number;
+    sweepFlag: boolean;
+    r2: number;
+    x: number;
+    angle: number;
+    r1: number;
+    largeArcFlag: boolean;
+}
+declare var SVGPathSegArcAbs: {
+    prototype: SVGPathSegArcAbs;
+    new (): SVGPathSegArcAbs;
+}
+
+interface SVGTransformList {
+    numberOfItems: number;
+    getItem(index: number): SVGTransform;
+    consolidate(): SVGTransform;
+    clear(): void;
+    appendItem(newItem: SVGTransform): SVGTransform;
+    initialize(newItem: SVGTransform): SVGTransform;
+    removeItem(index: number): SVGTransform;
+    insertItemBefore(newItem: SVGTransform, index: number): SVGTransform;
+    replaceItem(newItem: SVGTransform, index: number): SVGTransform;
+    createSVGTransformFromMatrix(matrix: SVGMatrix): SVGTransform;
+}
+declare var SVGTransformList: {
+    prototype: SVGTransformList;
+    new (): SVGTransformList;
+}
+
+interface HTMLHtmlElement extends HTMLElement {
+    /**
+      * Sets or retrieves the DTD version that governs the current document.
+      */
+    version: string;
+}
+declare var HTMLHtmlElement: {
+    prototype: HTMLHtmlElement;
+    new (): HTMLHtmlElement;
+}
+
+interface SVGPathSegClosePath extends SVGPathSeg {
+}
+declare var SVGPathSegClosePath: {
+    prototype: SVGPathSegClosePath;
+    new (): SVGPathSegClosePath;
+}
+
+interface HTMLFrameElement extends HTMLElement, GetSVGDocument, MSDataBindingExtensions {
+    /**
+      * Sets or retrieves the width of the object.
+      */
+    width: any;
+    /**
+      * Sets or retrieves whether the frame can be scrolled.
+      */
+    scrolling: string;
+    /**
+      * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
+      */
+    marginHeight: string;
+    /**
+      * Sets or retrieves the left and right margin widths before displaying the text in a frame.
+      */
+    marginWidth: string;
+    /**
+      * Sets or retrieves the border color of the object.
+      */
+    borderColor: any;
+    /**
+      * Sets or retrieves the amount of additional space between the frames.
+      */
+    frameSpacing: any;
+    /**
+      * Sets or retrieves whether to display a border for the frame.
+      */
+    frameBorder: string;
+    /**
+      * Sets or retrieves whether the user can resize the frame.
+      */
+    noResize: boolean;
+    /**
+      * Retrieves the object of the specified.
+      */
+    contentWindow: Window;
+    /**
+      * Sets or retrieves a URL to be loaded by the object.
+      */
+    src: string;
+    /**
+      * Sets or retrieves the frame name.
+      */
+    name: string;
+    /**
+      * Sets or retrieves the height of the object.
+      */
+    height: any;
+    /**
+      * Retrieves the document object of the page or frame.
+      */
+    contentDocument: Document;
+    /**
+      * Specifies the properties of a border drawn around an object.
+      */
+    border: string;
+    /**
+      * Sets or retrieves a URI to a long description of the object.
+      */
+    longDesc: string;
+    /**
+      * Raised when the object has been completely received from the server.
+      */
+    onload: (ev: Event) => any;
+    /**
+      * Sets the value indicating whether the source file of a frame or iframe has specific security restrictions applied.
+      */
+    security: any;
+}
+declare var HTMLFrameElement: {
+    prototype: HTMLFrameElement;
+    new (): HTMLFrameElement;
+}
+
+interface SVGAnimatedLength {
+    animVal: SVGLength;
+    baseVal: SVGLength;
+}
+declare var SVGAnimatedLength: {
+    prototype: SVGAnimatedLength;
+    new (): SVGAnimatedLength;
+}
+
+interface SVGAnimatedPoints {
+    points: SVGPointList;
+    animatedPoints: SVGPointList;
+}
+
+interface SVGDefsElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired {
+}
+declare var SVGDefsElement: {
+    prototype: SVGDefsElement;
+    new (): SVGDefsElement;
+}
+
+interface HTMLQuoteElement extends HTMLElement {
+    /**
+      * Sets or retrieves the date and time of a modification to the object.
+      */
+    dateTime: string;
+    /**
+      * Sets or retrieves reference information about the object.
+      */
+    cite: string;
+}
+declare var HTMLQuoteElement: {
+    prototype: HTMLQuoteElement;
+    new (): HTMLQuoteElement;
+}
+
+interface CSSMediaRule extends CSSRule {
+    media: MediaList;
+    cssRules: CSSRuleList;
+    insertRule(rule: string, index?: number): number;
+    deleteRule(index?: number): void;
+}
+declare var CSSMediaRule: {
+    prototype: CSSMediaRule;
+    new (): CSSMediaRule;
+}
+
+interface WindowModal {
+    dialogArguments: any;
+    returnValue: any;
+}
+
+interface XMLHttpRequest extends EventTarget {
+    responseBody: any;
+    status: number;
+    readyState: number;
+    responseText: string;
+    responseXML: Document;
+    ontimeout: (ev: Event) => any;
+    statusText: string;
+    onreadystatechange: (ev: Event) => any;
+    timeout: number;
+    onload: (ev: Event) => any;
+    open(method: string, url: string, async?: boolean, user?: string, password?: string): void;
+    create(): XMLHttpRequest;
+    send(data?: any): void;
+    abort(): void;
+    getAllResponseHeaders(): string;
+    setRequestHeader(header: string, value: string): void;
+    getResponseHeader(header: string): string;
+    LOADING: number;
+    DONE: number;
+    UNSENT: number;
+    OPENED: number;
+    HEADERS_RECEIVED: number;
+}
+declare var XMLHttpRequest: {
+    prototype: XMLHttpRequest;
+    new (): XMLHttpRequest;
+    LOADING: number;
+    DONE: number;
+    UNSENT: number;
+    OPENED: number;
+    HEADERS_RECEIVED: number;
+}
+
+interface HTMLTableHeaderCellElement extends HTMLTableCellElement {
+    /**
+      * Sets or retrieves the group of cells in a table to which the object's information applies.
+      */
+    scope: string;
+}
+declare var HTMLTableHeaderCellElement: {
+    prototype: HTMLTableHeaderCellElement;
+    new (): HTMLTableHeaderCellElement;
+}
+
+interface HTMLDListElement extends HTMLElement, DOML2DeprecatedListSpaceReduction {
+}
+declare var HTMLDListElement: {
+    prototype: HTMLDListElement;
+    new (): HTMLDListElement;
+}
+
+interface MSDataBindingExtensions {
+    dataSrc: string;
+    dataFormatAs: string;
+    dataFld: string;
+}
+
+interface SVGPathSegLinetoHorizontalRel extends SVGPathSeg {
+    x: number;
+}
+declare var SVGPathSegLinetoHorizontalRel: {
+    prototype: SVGPathSegLinetoHorizontalRel;
+    new (): SVGPathSegLinetoHorizontalRel;
+}
+
+interface SVGEllipseElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired {
+    ry: SVGAnimatedLength;
+    cx: SVGAnimatedLength;
+    rx: SVGAnimatedLength;
+    cy: SVGAnimatedLength;
+}
+declare var SVGEllipseElement: {
+    prototype: SVGEllipseElement;
+    new (): SVGEllipseElement;
+}
+
+interface SVGAElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired, SVGURIReference {
+    target: SVGAnimatedString;
+}
+declare var SVGAElement: {
+    prototype: SVGAElement;
+    new (): SVGAElement;
+}
+
+interface SVGStylable {
+    className: SVGAnimatedString;
+    style: CSSStyleDeclaration;
+}
+
+interface SVGTransformable extends SVGLocatable {
+    transform: SVGAnimatedTransformList;
+}
+
+interface HTMLFrameSetElement extends HTMLElement {
+    ononline: (ev: Event) => any;
+    /**
+      * Sets or retrieves the border color of the object.
+      */
+    borderColor: any;
+    /**
+      * Sets or retrieves the frame heights of the object.
+      */
+    rows: string;
+    /**
+      * Sets or retrieves the frame widths of the object.
+      */
+    cols: string;
+    /**
+      * Fires when the object loses the input focus.
+      */
+    onblur: (ev: FocusEvent) => any;
+    /**
+      * Sets or retrieves the amount of additional space between the frames.
+      */
+    frameSpacing: any;
+    /**
+      * Fires when the object receives focus.
+      */
+    onfocus: (ev: FocusEvent) => any;
+    onmessage: (ev: MessageEvent) => any;
+    onerror: (ev: Event) => any;
+    /**
+      * Sets or retrieves whether to display a border for the frame.
+      */
+    frameBorder: string;
+    onresize: (ev: UIEvent) => any;
+    name: string;
+    onafterprint: (ev: Event) => any;
+    onbeforeprint: (ev: Event) => any;
+    onoffline: (ev: Event) => any;
+    border: string;
+    onunload: (ev: Event) => any;
+    onhashchange: (ev: Event) => any;
+    onload: (ev: Event) => any;
+    onbeforeunload: (ev: BeforeUnloadEvent) => any;
+    onstorage: (ev: StorageEvent) => any;
+}
+declare var HTMLFrameSetElement: {
+    prototype: HTMLFrameSetElement;
+    new (): HTMLFrameSetElement;
+}
+
+interface Screen {
+    width: number;
+    deviceXDPI: number;
+    fontSmoothingEnabled: boolean;
+    bufferDepth: number;
+    logicalXDPI: number;
+    systemXDPI: number;
+    availHeight: number;
+    height: number;
+    logicalYDPI: number;
+    systemYDPI: number;
+    updateInterval: number;
+    colorDepth: number;
+    availWidth: number;
+    deviceYDPI: number;
+    pixelDepth: number;
+}
+declare var Screen: {
+    prototype: Screen;
+    new (): Screen;
+}
+
+interface Coordinates {
+    altitudeAccuracy: number;
+    longitude: number;
+    latitude: number;
+    speed: number;
+    heading: number;
+    altitude: number;
+    accuracy: number;
+}
+declare var Coordinates: {
+    prototype: Coordinates;
+    new (): Coordinates;
+}
+
+interface NavigatorGeolocation {
+    geolocation: Geolocation;
+}
+
+interface NavigatorContentUtils {
+}
+
+interface EventListener {
+    (evt: Event): void;
+}
+
+interface SVGLangSpace {
+    xmllang: string;
+    xmlspace: string;
+}
+
+interface DataTransfer {
+    effectAllowed: string;
+    dropEffect: string;
+    clearData(format?: string): boolean;
+    setData(format: string, data: string): boolean;
+    getData(format: string): string;
+}
+declare var DataTransfer: {
+    prototype: DataTransfer;
+    new (): DataTransfer;
+}
+
+interface FocusEvent extends UIEvent {
+    relatedTarget: EventTarget;
+    initFocusEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, relatedTargetArg: EventTarget): void;
+}
+declare var FocusEvent: {
+    prototype: FocusEvent;
+    new (): FocusEvent;
+}
+
+interface Range {
+    startOffset: number;
+    collapsed: boolean;
+    endOffset: number;
+    startContainer: Node;
+    endContainer: Node;
+    commonAncestorContainer: Node;
+    setStart(refNode: Node, offset: number): void;
+    setEndBefore(refNode: Node): void;
+    setStartBefore(refNode: Node): void;
+    selectNode(refNode: Node): void;
+    detach(): void;
+    getBoundingClientRect(): ClientRect;
+    toString(): string;
+    compareBoundaryPoints(how: number, sourceRange: Range): number;
+    insertNode(newNode: Node): void;
+    collapse(toStart: boolean): void;
+    selectNodeContents(refNode: Node): void;
+    cloneContents(): DocumentFragment;
+    setEnd(refNode: Node, offset: number): void;
+    cloneRange(): Range;
+    getClientRects(): ClientRectList;
+    surroundContents(newParent: Node): void;
+    deleteContents(): void;
+    setStartAfter(refNode: Node): void;
+    extractContents(): DocumentFragment;
+    setEndAfter(refNode: Node): void;
+    END_TO_END: number;
+    START_TO_START: number;
+    START_TO_END: number;
+    END_TO_START: number;
+}
+declare var Range: {
+    prototype: Range;
+    new (): Range;
+    END_TO_END: number;
+    START_TO_START: number;
+    START_TO_END: number;
+    END_TO_START: number;
+}
+
+interface SVGPoint {
+    y: number;
+    x: number;
+    matrixTransform(matrix: SVGMatrix): SVGPoint;
+}
+declare var SVGPoint: {
+    prototype: SVGPoint;
+    new (): SVGPoint;
+}
+
+interface MSPluginsCollection {
+    length: number;
+    refresh(reload?: boolean): void;
+}
+declare var MSPluginsCollection: {
+    prototype: MSPluginsCollection;
+    new (): MSPluginsCollection;
+}
+
+interface SVGAnimatedNumberList {
+    animVal: SVGNumberList;
+    baseVal: SVGNumberList;
+}
+declare var SVGAnimatedNumberList: {
+    prototype: SVGAnimatedNumberList;
+    new (): SVGAnimatedNumberList;
+}
+
+interface SVGSVGElement extends SVGElement, SVGStylable, SVGZoomAndPan, DocumentEvent, SVGLangSpace, SVGLocatable, SVGTests, SVGFitToViewBox, SVGExternalResourcesRequired {
+    width: SVGAnimatedLength;
+    x: SVGAnimatedLength;
+    contentStyleType: string;
+    onzoom: (ev: any) => any;
+    y: SVGAnimatedLength;
+    viewport: SVGRect;
+    onerror: (ev: Event) => any;
+    pixelUnitToMillimeterY: number;
+    onresize: (ev: UIEvent) => any;
+    screenPixelToMillimeterY: number;
+    height: SVGAnimatedLength;
+    onabort: (ev: UIEvent) => any;
+    contentScriptType: string;
+    pixelUnitToMillimeterX: number;
+    currentTranslate: SVGPoint;
+    onunload: (ev: Event) => any;
+    currentScale: number;
+    onscroll: (ev: UIEvent) => any;
+    screenPixelToMillimeterX: number;
+    setCurrentTime(seconds: number): void;
+    createSVGLength(): SVGLength;
+    getIntersectionList(rect: SVGRect, referenceElement: SVGElement): NodeList;
+    unpauseAnimations(): void;
+    createSVGRect(): SVGRect;
+    checkIntersection(element: SVGElement, rect: SVGRect): boolean;
+    unsuspendRedrawAll(): void;
+    pauseAnimations(): void;
+    suspendRedraw(maxWaitMilliseconds: number): number;
+    deselectAll(): void;
+    createSVGAngle(): SVGAngle;
+    getEnclosureList(rect: SVGRect, referenceElement: SVGElement): NodeList;
+    createSVGTransform(): SVGTransform;
+    unsuspendRedraw(suspendHandleID: number): void;
+    forceRedraw(): void;
+    getCurrentTime(): number;
+    checkEnclosure(element: SVGElement, rect: SVGRect): boolean;
+    createSVGMatrix(): SVGMatrix;
+    createSVGPoint(): SVGPoint;
+    createSVGNumber(): SVGNumber;
+    createSVGTransformFromMatrix(matrix: SVGMatrix): SVGTransform;
+    getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration;
+    getElementById(elementId: string): Element;
+}
+declare var SVGSVGElement: {
+    prototype: SVGSVGElement;
+    new (): SVGSVGElement;
+}
+
+interface HTMLLabelElement extends HTMLElement, MSDataBindingExtensions {
+    /**
+      * Sets or retrieves the object to which the given label object is assigned.
+      */
+    htmlFor: string;
+    /**
+      * Retrieves a reference to the form that the object is embedded in.
+      */
+    form: HTMLFormElement;
+}
+declare var HTMLLabelElement: {
+    prototype: HTMLLabelElement;
+    new (): HTMLLabelElement;
+}
+
+interface MSResourceMetadata {
+    protocol: string;
+    fileSize: string;
+    fileUpdatedDate: string;
+    nameProp: string;
+    fileCreatedDate: string;
+    fileModifiedDate: string;
+    mimeType: string;
+}
+
+interface HTMLLegendElement extends HTMLElement, MSDataBindingExtensions {
+    /**
+      * Retrieves a reference to the form that the object is embedded in.
+      */
+    align: string;
+    /**
+      * Retrieves a reference to the form that the object is embedded in.
+      */
+    form: HTMLFormElement;
+}
+declare var HTMLLegendElement: {
+    prototype: HTMLLegendElement;
+    new (): HTMLLegendElement;
+}
+
+interface HTMLDirectoryElement extends HTMLElement, DOML2DeprecatedListSpaceReduction, DOML2DeprecatedListNumberingAndBulletStyle {
+}
+declare var HTMLDirectoryElement: {
+    prototype: HTMLDirectoryElement;
+    new (): HTMLDirectoryElement;
+}
+
+interface SVGAnimatedInteger {
+    animVal: number;
+    baseVal: number;
+}
+declare var SVGAnimatedInteger: {
+    prototype: SVGAnimatedInteger;
+    new (): SVGAnimatedInteger;
+}
+
+interface SVGTextElement extends SVGTextPositioningElement, SVGTransformable {
+}
+declare var SVGTextElement: {
+    prototype: SVGTextElement;
+    new (): SVGTextElement;
+}
+
+interface SVGTSpanElement extends SVGTextPositioningElement {
+}
+declare var SVGTSpanElement: {
+    prototype: SVGTSpanElement;
+    new (): SVGTSpanElement;
+}
+
+interface HTMLLIElement extends HTMLElement, DOML2DeprecatedListNumberingAndBulletStyle {
+    /**
+      * Sets or retrieves the value of a list item.
+      */
+    value: number;
+}
+declare var HTMLLIElement: {
+    prototype: HTMLLIElement;
+    new (): HTMLLIElement;
+}
+
+interface SVGPathSegLinetoVerticalAbs extends SVGPathSeg {
+    y: number;
+}
+declare var SVGPathSegLinetoVerticalAbs: {
+    prototype: SVGPathSegLinetoVerticalAbs;
+    new (): SVGPathSegLinetoVerticalAbs;
+}
+
+interface MSStorageExtensions {
+    remainingSpace: number;
+}
+
+interface SVGStyleElement extends SVGElement, SVGLangSpace {
+    media: string;
+    type: string;
+    title: string;
+}
+declare var SVGStyleElement: {
+    prototype: SVGStyleElement;
+    new (): SVGStyleElement;
+}
+
+interface MSCurrentStyleCSSProperties extends MSCSSProperties {
+    blockDirection: string;
+    clipBottom: string;
+    clipLeft: string;
+    clipRight: string;
+    clipTop: string;
+    hasLayout: string;
+}
+declare var MSCurrentStyleCSSProperties: {
+    prototype: MSCurrentStyleCSSProperties;
+    new (): MSCurrentStyleCSSProperties;
+}
+
+interface MSHTMLCollectionExtensions {
+    urns(urn: any): Object;
+    tags(tagName: any): Object;
+}
+
+interface Storage extends MSStorageExtensions {
+    length: number;
+    getItem(key: string): any;
+    [key: string]: any;
+    setItem(key: string, data: string): void;
+    clear(): void;
+    removeItem(key: string): void;
+    key(index: number): string;
+    [index: number]: any;
+}
+declare var Storage: {
+    prototype: Storage;
+    new (): Storage;
+}
+
+interface HTMLIFrameElement extends HTMLElement, GetSVGDocument, MSDataBindingExtensions {
+    /**
+      * Sets or retrieves the width of the object.
+      */
+    width: string;
+    /**
+      * Sets or retrieves whether the frame can be scrolled.
+      */
+    scrolling: string;
+    /**
+      * Sets or retrieves the top and bottom margin heights before displaying the text in a frame.
+      */
+    marginHeight: string;
+    /**
+      * Sets or retrieves the left and right margin widths before displaying the text in a frame.
+      */
+    marginWidth: string;
+    /**
+      * Sets or retrieves the amount of additional space between the frames.
+      */
+    frameSpacing: any;
+    /**
+      * Sets or retrieves whether to display a border for the frame.
+      */
+    frameBorder: string;
+    /**
+      * Sets or retrieves whether the user can resize the frame.
+      */
+    noResize: boolean;
+    /**
+      * Sets or retrieves the vertical margin for the object.
+      */
+    vspace: number;
+    /**
+      * Retrieves the object of the specified.
+      */
+    contentWindow: Window;
+    /**
+      * Sets or retrieves how the object is aligned with adjacent text.
+      */
+    align: string;
+    /**
+      * Sets or retrieves a URL to be loaded by the object.
+      */
+    src: string;
+    /**
+      * Sets or retrieves the frame name.
+      */
+    name: string;
+    /**
+      * Sets or retrieves the height of the object.
+      */
+    height: string;
+    /**
+      * Specifies the properties of a border drawn around an object.
+      */
+    border: string;
+    /**
+      * Retrieves the document object of the page or frame.
+      */
+    contentDocument: Document;
+    /**
+      * Sets or retrieves the horizontal margin for the object.
+      */
+    hspace: number;
+    /**
+      * Sets or retrieves a URI to a long description of the object.
+      */
+    longDesc: string;
+    /**
+      * Sets the value indicating whether the source file of a frame or iframe has specific security restrictions applied.
+      */
+    security: any;
+    /**
+      * Raised when the object has been completely received from the server.
+      */
+    onload: (ev: Event) => any;
+}
+declare var HTMLIFrameElement: {
+    prototype: HTMLIFrameElement;
+    new (): HTMLIFrameElement;
+}
+
+interface TextRangeCollection {
+    length: number;
+    item(index: number): TextRange;
+    [index: number]: TextRange;
+}
+declare var TextRangeCollection: {
+    prototype: TextRangeCollection;
+    new (): TextRangeCollection;
+}
+
+interface HTMLBodyElement extends HTMLElement, DOML2DeprecatedBackgroundStyle, DOML2DeprecatedBackgroundColorStyle {
+    scroll: string;
+    ononline: (ev: Event) => any;
+    onblur: (ev: FocusEvent) => any;
+    noWrap: boolean;
+    onfocus: (ev: FocusEvent) => any;
+    onmessage: (ev: MessageEvent) => any;
+    text: any;
+    onerror: (ev: Event) => any;
+    bgProperties: string;
+    onresize: (ev: UIEvent) => any;
+    link: any;
+    aLink: any;
+    bottomMargin: any;
+    topMargin: any;
+    onafterprint: (ev: Event) => any;
+    vLink: any;
+    onbeforeprint: (ev: Event) => any;
+    onoffline: (ev: Event) => any;
+    onunload: (ev: Event) => any;
+    onhashchange: (ev: Event) => any;
+    onload: (ev: Event) => any;
+    rightMargin: any;
+    onbeforeunload: (ev: BeforeUnloadEvent) => any;
+    leftMargin: any;
+    onstorage: (ev: StorageEvent) => any;
+    createTextRange(): TextRange;
+}
+declare var HTMLBodyElement: {
+    prototype: HTMLBodyElement;
+    new (): HTMLBodyElement;
+}
+
+interface DocumentType extends Node {
+    name: string;
+    notations: NamedNodeMap;
+    systemId: string;
+    internalSubset: string;
+    entities: NamedNodeMap;
+    publicId: string;
+}
+declare var DocumentType: {
+    prototype: DocumentType;
+    new (): DocumentType;
+}
+
+interface SVGRadialGradientElement extends SVGGradientElement {
+    cx: SVGAnimatedLength;
+    r: SVGAnimatedLength;
+    cy: SVGAnimatedLength;
+    fx: SVGAnimatedLength;
+    fy: SVGAnimatedLength;
+}
+declare var SVGRadialGradientElement: {
+    prototype: SVGRadialGradientElement;
+    new (): SVGRadialGradientElement;
+}
+
+interface MutationEvent extends Event {
+    newValue: string;
+    attrChange: number;
+    attrName: string;
+    prevValue: string;
+    relatedNode: Node;
+    initMutationEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, relatedNodeArg: Node, prevValueArg: string, newValueArg: string, attrNameArg: string, attrChangeArg: number): void;
+    MODIFICATION: number;
+    REMOVAL: number;
+    ADDITION: number;
+}
+declare var MutationEvent: {
+    prototype: MutationEvent;
+    new (): MutationEvent;
+    MODIFICATION: number;
+    REMOVAL: number;
+    ADDITION: number;
+}
+
+interface DragEvent extends MouseEvent {
+    dataTransfer: DataTransfer;
+    initDragEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget, dataTransferArg: DataTransfer): void;
+}
+declare var DragEvent: {
+    prototype: DragEvent;
+    new (): DragEvent;
+}
+
+interface HTMLTableSectionElement extends HTMLElement, HTMLTableAlignment, DOML2DeprecatedBackgroundColorStyle {
+    /**
+      * Sets or retrieves a value that indicates the table alignment.
+      */
+    align: string;
+    /**
+      * Sets or retrieves the number of horizontal rows contained in the object.
+      */
+    rows: HTMLCollection;
+    /**
+      * Removes the specified row (tr) from the element and from the rows collection.
+      * @param index Number that specifies the zero-based position in the rows collection of the row to remove.
+      */
+    deleteRow(index?: number): void;
+    /**
+      * Moves a table row to a new position.
+      * @param indexFrom Number that specifies the index in the rows collection of the table row that is moved.
+      * @param indexTo Number that specifies where the row is moved within the rows collection.
+      */
+    moveRow(indexFrom?: number, indexTo?: number): Object;
+    /**
+      * Creates a new row (tr) in the table, and adds the row to the rows collection.
+      * @param index Number that specifies where to insert the row in the rows collection. The default value is -1, which appends the new row to the end of the rows collection.
+      */
+    insertRow(index?: number): HTMLElement;
+}
+declare var HTMLTableSectionElement: {
+    prototype: HTMLTableSectionElement;
+    new (): HTMLTableSectionElement;
+}
+
+interface DOML2DeprecatedListNumberingAndBulletStyle {
+    type: string;
+}
+
+interface HTMLInputElement extends HTMLElement, MSDataBindingExtensions {
+    /**
+      * Sets or retrieves the width of the object.
+      */
+    width: string;
+    status: boolean;
+    /**
+      * Retrieves a reference to the form that the object is embedded in. 
+      */
+    form: HTMLFormElement;
+    /**
+      * Gets or sets the starting position or offset of a text selection.
+      */
+    selectionStart: number;
+    indeterminate: boolean;
+    readOnly: boolean;
+    size: number;
+    loop: number;
+    /**
+      * Gets or sets the end position or offset of a text selection.
+      */
+    selectionEnd: number;
+    /**
+      * Sets or retrieves the URL of the virtual reality modeling language (VRML) world to be displayed in the window.
+      */
+    vrml: string;
+    /**
+      * Sets or retrieves a lower resolution image to display.
+      */
+    lowsrc: string;
+    /**
+      * Sets or retrieves the vertical margin for the object.
+      */
+    vspace: number;
+    /**
+      * Sets or retrieves a comma-separated list of content types.
+      */
+    accept: string;
+    /**
+      * Sets or retrieves a text alternative to the graphic.
+      */
+    alt: string;
+    /**
+      * Sets or retrieves the state of the check box or radio button.
+      */
+    defaultChecked: boolean;
+    /**
+      * Sets or retrieves how the object is aligned with adjacent text.
+      */
+    align: string;
+    /**
+      * Returns the value of the data at the cursor's current position.
+      */
+    value: string;
+    /**
+      * The address or URL of the a media resource that is to be considered.
+      */
+    src: string;
+    /**
+      * Sets or retrieves the name of the object.
+      */
+    name: string;
+    /**
+      * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
+      */
+    useMap: string;
+    /**
+      * Sets or retrieves the height of the object.
+      */
+    height: string;
+    /**
+      * Sets or retrieves the width of the border to draw around the object.
+      */
+    border: string;
+    dynsrc: string;
+    /**
+      * Sets or retrieves the state of the check box or radio button.
+      */
+    checked: boolean;
+    /**
+      * Sets or retrieves the width of the border to draw around the object.
+      */
+    hspace: number;
+    /**
+      * Sets or retrieves the maximum number of characters that the user can enter in a text control.
+      */
+    maxLength: number;
+    /**
+      * Returns the content type of the object.
+      */
+    type: string;
+    /**
+      * Sets or retrieves the initial contents of the object.
+      */
+    defaultValue: string;
+    /**
+      * Retrieves whether the object is fully loaded.
+      */
+    complete: boolean;
+    start: string;
+    /**
+      * Creates a TextRange object for the element.
+      */
+    createTextRange(): TextRange;
+    /**
+      * Sets the start and end positions of a selection in a text field.
+      * @param start The offset into the text field for the start of the selection.
+      * @param end The offset into the text field for the end of the selection.
+      */
+    setSelectionRange(start: number, end: number): void;
+    /**
+      * Makes the selection equal to the current object.
+      */
+    select(): void;
+}
+declare var HTMLInputElement: {
+    prototype: HTMLInputElement;
+    new (): HTMLInputElement;
+}
+
+interface HTMLAnchorElement extends HTMLElement, MSDataBindingExtensions {
+    /**
+      * Sets or retrieves the relationship between the object and the destination of the link.
+      */
+    rel: string;
+    /**
+      * Contains the protocol of the URL.
+      */
+    protocol: string;
+    /**
+      * Sets or retrieves the substring of the href property that follows the question mark.
+      */
+    search: string;
+    /**
+      * Sets or retrieves the coordinates of the object.
+      */
+    coords: string;
+    /**
+      * Contains the hostname of a URL.
+      */
+    hostname: string;
+    /**
+      * Contains the pathname of the URL.
+      */
+    pathname: string;
+    Methods: string;
+    /**
+      * Sets or retrieves the window or frame at which to target content.
+      */
+    target: string;
+    protocolLong: string;
+    /**
+      * Sets or retrieves a destination URL or an anchor point.
+      */
+    href: string;
+    /**
+      * Sets or retrieves the shape of the object.
+      */
+    name: string;
+    /**
+      * Sets or retrieves the character set used to encode the object.
+      */
+    charset: string;
+    /**
+      * Sets or retrieves the language code of the object.
+      */
+    hreflang: string;
+    /**
+      * Sets or retrieves the port number associated with a URL.
+      */
+    port: string;
+    /**
+      * Contains the hostname and port values of the URL.
+      */
+    host: string;
+    /**
+      * Contains the anchor portion of the URL including the hash sign (#).
+      */
+    hash: string;
+    nameProp: string;
+    urn: string;
+    /**
+      * Sets or retrieves the relationship between the object and the destination of the link.
+      */
+    rev: string;
+    /**
+      * Sets or retrieves the shape of the object.
+      */
+    shape: string;
+    type: string;
+    mimeType: string;
+    /** 
+      * Returns a string representation of an object.
+      */
+    toString(): string;
+}
+declare var HTMLAnchorElement: {
+    prototype: HTMLAnchorElement;
+    new (): HTMLAnchorElement;
+}
+
+interface HTMLParamElement extends HTMLElement {
+    /**
+      * Sets or retrieves the value of an input parameter for an element.
+      */
+    value: string;
+    /**
+      * Sets or retrieves the name of an input parameter for an element.
+      */
+    name: string;
+    /**
+      * Sets or retrieves the content type of the resource designated by the value attribute.
+      */
+    type: string;
+    /**
+      * Sets or retrieves the data type of the value attribute.
+      */
+    valueType: string;
+}
+declare var HTMLParamElement: {
+    prototype: HTMLParamElement;
+    new (): HTMLParamElement;
+}
+
+interface SVGImageElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired, SVGURIReference {
+    y: SVGAnimatedLength;
+    width: SVGAnimatedLength;
+    preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
+    x: SVGAnimatedLength;
+    height: SVGAnimatedLength;
+}
+declare var SVGImageElement: {
+    prototype: SVGImageElement;
+    new (): SVGImageElement;
+}
+
+interface SVGAnimatedNumber {
+    animVal: number;
+    baseVal: number;
+}
+declare var SVGAnimatedNumber: {
+    prototype: SVGAnimatedNumber;
+    new (): SVGAnimatedNumber;
+}
+
+interface PerformanceTiming {
+    redirectStart: number;
+    domainLookupEnd: number;
+    responseStart: number;
+    domComplete: number;
+    domainLookupStart: number;
+    loadEventStart: number;
+    msFirstPaint: number;
+    unloadEventEnd: number;
+    fetchStart: number;
+    requestStart: number;
+    domInteractive: number;
+    navigationStart: number;
+    connectEnd: number;
+    loadEventEnd: number;
+    connectStart: number;
+    responseEnd: number;
+    domLoading: number;
+    redirectEnd: number;
+    unloadEventStart: number;
+    domContentLoadedEventStart: number;
+    domContentLoadedEventEnd: number;
+    toJSON(): any;
+}
+declare var PerformanceTiming: {
+    prototype: PerformanceTiming;
+    new (): PerformanceTiming;
+}
+
+interface HTMLPreElement extends HTMLElement, DOML2DeprecatedTextFlowControl {
+    /**
+      * Sets or gets a value that you can use to implement your own width functionality for the object.
+      */
+    width: number;
+    /**
+      * Indicates a citation by rendering text in italic type.
+      */
+    cite: string;
+}
+declare var HTMLPreElement: {
+    prototype: HTMLPreElement;
+    new (): HTMLPreElement;
+}
+
+interface EventException {
+    code: number;
+    message: string;
+    toString(): string;
+    DISPATCH_REQUEST_ERR: number;
+    UNSPECIFIED_EVENT_TYPE_ERR: number;
+}
+declare var EventException: {
+    prototype: EventException;
+    new (): EventException;
+    DISPATCH_REQUEST_ERR: number;
+    UNSPECIFIED_EVENT_TYPE_ERR: number;
+}
+
+interface MSNavigatorDoNotTrack {
+    msDoNotTrack: string;
+}
+
+interface NavigatorOnLine {
+    onLine: boolean;
+}
+
+interface WindowLocalStorage {
+    localStorage: Storage;
+}
+
+interface SVGMetadataElement extends SVGElement {
+}
+declare var SVGMetadataElement: {
+    prototype: SVGMetadataElement;
+    new (): SVGMetadataElement;
+}
+
+interface SVGPathSegArcRel extends SVGPathSeg {
+    y: number;
+    sweepFlag: boolean;
+    r2: number;
+    x: number;
+    angle: number;
+    r1: number;
+    largeArcFlag: boolean;
+}
+declare var SVGPathSegArcRel: {
+    prototype: SVGPathSegArcRel;
+    new (): SVGPathSegArcRel;
+}
+
+interface SVGPathSegMovetoAbs extends SVGPathSeg {
+    y: number;
+    x: number;
+}
+declare var SVGPathSegMovetoAbs: {
+    prototype: SVGPathSegMovetoAbs;
+    new (): SVGPathSegMovetoAbs;
+}
+
+interface SVGStringList {
+    numberOfItems: number;
+    replaceItem(newItem: string, index: number): string;
+    getItem(index: number): string;
+    clear(): void;
+    appendItem(newItem: string): string;
+    initialize(newItem: string): string;
+    removeItem(index: number): string;
+    insertItemBefore(newItem: string, index: number): string;
+}
+declare var SVGStringList: {
+    prototype: SVGStringList;
+    new (): SVGStringList;
+}
+
+interface XDomainRequest {
+    timeout: number;
+    onerror: (ev: Event) => any;
+    onload: (ev: Event) => any;
+    onprogress: (ev: any) => any;
+    ontimeout: (ev: Event) => any;
+    responseText: string;
+    contentType: string;
+    open(method: string, url: string): void;
+    create(): XDomainRequest;
+    abort(): void;
+    send(data?: any): void;
+}
+declare var XDomainRequest: {
+    prototype: XDomainRequest;
+    new (): XDomainRequest;
+}
+
+interface DOML2DeprecatedBackgroundColorStyle {
+    bgColor: any;
+}
+
+interface ElementTraversal {
+    childElementCount: number;
+    previousElementSibling: Element;
+    lastElementChild: Element;
+    nextElementSibling: Element;
+    firstElementChild: Element;
+}
+
+interface SVGLength {
+    valueAsString: string;
+    valueInSpecifiedUnits: number;
+    value: number;
+    unitType: number;
+    newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
+    convertToSpecifiedUnits(unitType: number): void;
+    SVG_LENGTHTYPE_NUMBER: number;
+    SVG_LENGTHTYPE_CM: number;
+    SVG_LENGTHTYPE_PC: number;
+    SVG_LENGTHTYPE_PERCENTAGE: number;
+    SVG_LENGTHTYPE_MM: number;
+    SVG_LENGTHTYPE_PT: number;
+    SVG_LENGTHTYPE_IN: number;
+    SVG_LENGTHTYPE_EMS: number;
+    SVG_LENGTHTYPE_PX: number;
+    SVG_LENGTHTYPE_UNKNOWN: number;
+    SVG_LENGTHTYPE_EXS: number;
+}
+declare var SVGLength: {
+    prototype: SVGLength;
+    new (): SVGLength;
+    SVG_LENGTHTYPE_NUMBER: number;
+    SVG_LENGTHTYPE_CM: number;
+    SVG_LENGTHTYPE_PC: number;
+    SVG_LENGTHTYPE_PERCENTAGE: number;
+    SVG_LENGTHTYPE_MM: number;
+    SVG_LENGTHTYPE_PT: number;
+    SVG_LENGTHTYPE_IN: number;
+    SVG_LENGTHTYPE_EMS: number;
+    SVG_LENGTHTYPE_PX: number;
+    SVG_LENGTHTYPE_UNKNOWN: number;
+    SVG_LENGTHTYPE_EXS: number;
+}
+
+interface SVGPolygonElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGAnimatedPoints, SVGTests, SVGExternalResourcesRequired {
+}
+declare var SVGPolygonElement: {
+    prototype: SVGPolygonElement;
+    new (): SVGPolygonElement;
+}
+
+interface HTMLPhraseElement extends HTMLElement {
+    /**
+      * Sets or retrieves the date and time of a modification to the object.
+      */
+    dateTime: string;
+    /**
+      * Sets or retrieves reference information about the object.
+      */
+    cite: string;
+}
+declare var HTMLPhraseElement: {
+    prototype: HTMLPhraseElement;
+    new (): HTMLPhraseElement;
+}
+
+interface NavigatorStorageUtils {
+}
+
+interface SVGPathSegCurvetoCubicRel extends SVGPathSeg {
+    y: number;
+    y1: number;
+    x2: number;
+    x: number;
+    x1: number;
+    y2: number;
+}
+declare var SVGPathSegCurvetoCubicRel: {
+    prototype: SVGPathSegCurvetoCubicRel;
+    new (): SVGPathSegCurvetoCubicRel;
+}
+
+interface MSEventObj extends Event {
+    nextPage: string;
+    keyCode: number;
+    toElement: Element;
+    returnValue: any;
+    dataFld: string;
+    y: number;
+    dataTransfer: DataTransfer;
+    propertyName: string;
+    url: string;
+    offsetX: number;
+    recordset: Object;
+    screenX: number;
+    buttonID: number;
+    wheelDelta: number;
+    reason: number;
+    origin: string;
+    data: string;
+    srcFilter: Object;
+    boundElements: HTMLCollection;
+    cancelBubble: boolean;
+    altLeft: boolean;
+    behaviorCookie: number;
+    bookmarks: BookmarkCollection;
+    type: string;
+    repeat: boolean;
+    srcElement: Element;
+    source: Window;
+    fromElement: Element;
+    offsetY: number;
+    x: number;
+    behaviorPart: number;
+    qualifier: string;
+    altKey: boolean;
+    ctrlKey: boolean;
+    clientY: number;
+    shiftKey: boolean;
+    shiftLeft: boolean;
+    contentOverflow: boolean;
+    screenY: number;
+    ctrlLeft: boolean;
+    button: number;
+    srcUrn: string;
+    clientX: number;
+    actionURL: string;
+    getAttribute(strAttributeName: string, lFlags?: number): any;
+    setAttribute(strAttributeName: string, AttributeValue: any, lFlags?: number): void;
+    removeAttribute(strAttributeName: string, lFlags?: number): boolean;
+}
+declare var MSEventObj: {
+    prototype: MSEventObj;
+    new (): MSEventObj;
+}
+
+interface SVGTextContentElement extends SVGElement, SVGStylable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired {
+    textLength: SVGAnimatedLength;
+    lengthAdjust: SVGAnimatedEnumeration;
+    getCharNumAtPosition(point: SVGPoint): number;
+    getStartPositionOfChar(charnum: number): SVGPoint;
+    getExtentOfChar(charnum: number): SVGRect;
+    getComputedTextLength(): number;
+    getSubStringLength(charnum: number, nchars: number): number;
+    selectSubString(charnum: number, nchars: number): void;
+    getNumberOfChars(): number;
+    getRotationOfChar(charnum: number): number;
+    getEndPositionOfChar(charnum: number): SVGPoint;
+    LENGTHADJUST_SPACING: number;
+    LENGTHADJUST_SPACINGANDGLYPHS: number;
+    LENGTHADJUST_UNKNOWN: number;
+}
+declare var SVGTextContentElement: {
+    prototype: SVGTextContentElement;
+    new (): SVGTextContentElement;
+    LENGTHADJUST_SPACING: number;
+    LENGTHADJUST_SPACINGANDGLYPHS: number;
+    LENGTHADJUST_UNKNOWN: number;
+}
+
+interface DOML2DeprecatedColorProperty {
+    color: string;
+}
+
+interface HTMLCanvasElement extends HTMLElement {
+    /**
+      * Gets or sets the width of a canvas element on a document.
+      */
+    width: number;
+    /**
+      * Gets or sets the height of a canvas element on a document.
+      */
+    height: number;
+    /**
+      * Returns the content of the current canvas as an image that you can use as a source for another canvas or an HTML element.
+      * @param type The standard MIME type for the image format to return. If you do not specify this parameter, the default value is a PNG format image.
+      */
+    toDataURL(type?: string, ...args: any[]): string;
+    /**
+      * Returns an object that provides methods and properties for drawing and manipulating images and graphics on a canvas element in a document. A context object includes information about colors, line widths, fonts, and other graphic parameters that can be drawn on a canvas.
+      * @param contextId The identifier (ID) of the type of canvas to create. Internet Explorer 9 and Internet Explorer 10 support only a 2-D context using canvas.getContext("2d"); IE11 Preview also supports 3-D or WebGL context using canvas.getContext("experimental-webgl");
+      */
+    getContext(contextId: "2d"): CanvasRenderingContext2D;
+    getContext(contextId: "experimental-webgl"): WebGLRenderingContext;
+    getContext(contextId: string, ...args: any[]): any;
+}
+declare var HTMLCanvasElement: {
+    prototype: HTMLCanvasElement;
+    new (): HTMLCanvasElement;
+}
+
+interface Location {
+    hash: string;
+    protocol: string;
+    search: string;
+    href: string;
+    hostname: string;
+    port: string;
+    pathname: string;
+    host: string;
+    reload(flag?: boolean): void;
+    replace(url: string): void;
+    assign(url: string): void;
+    toString(): string;
+}
+declare var Location: {
+    prototype: Location;
+    new (): Location;
+}
+
+interface HTMLTitleElement extends HTMLElement {
+    /**
+      * Retrieves or sets the text of the object as a string. 
+      */
+    text: string;
+}
+declare var HTMLTitleElement: {
+    prototype: HTMLTitleElement;
+    new (): HTMLTitleElement;
+}
+
+interface HTMLStyleElement extends HTMLElement, LinkStyle {
+    /**
+      * Sets or retrieves the media type.
+      */
+    media: string;
+    /**
+      * Retrieves the CSS language in which the style sheet is written.
+      */
+    type: string;
+}
+declare var HTMLStyleElement: {
+    prototype: HTMLStyleElement;
+    new (): HTMLStyleElement;
+}
+
+interface PerformanceEntry {
+    name: string;
+    startTime: number;
+    duration: number;
+    entryType: string;
+}
+declare var PerformanceEntry: {
+    prototype: PerformanceEntry;
+    new (): PerformanceEntry;
+}
+
+interface SVGTransform {
+    type: number;
+    angle: number;
+    matrix: SVGMatrix;
+    setTranslate(tx: number, ty: number): void;
+    setScale(sx: number, sy: number): void;
+    setMatrix(matrix: SVGMatrix): void;
+    setSkewY(angle: number): void;
+    setRotate(angle: number, cx: number, cy: number): void;
+    setSkewX(angle: number): void;
+    SVG_TRANSFORM_SKEWX: number;
+    SVG_TRANSFORM_UNKNOWN: number;
+    SVG_TRANSFORM_SCALE: number;
+    SVG_TRANSFORM_TRANSLATE: number;
+    SVG_TRANSFORM_MATRIX: number;
+    SVG_TRANSFORM_ROTATE: number;
+    SVG_TRANSFORM_SKEWY: number;
+}
+declare var SVGTransform: {
+    prototype: SVGTransform;
+    new (): SVGTransform;
+    SVG_TRANSFORM_SKEWX: number;
+    SVG_TRANSFORM_UNKNOWN: number;
+    SVG_TRANSFORM_SCALE: number;
+    SVG_TRANSFORM_TRANSLATE: number;
+    SVG_TRANSFORM_MATRIX: number;
+    SVG_TRANSFORM_ROTATE: number;
+    SVG_TRANSFORM_SKEWY: number;
+}
+
+interface UIEvent extends Event {
+    detail: number;
+    view: Window;
+    initUIEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number): void;
+}
+declare var UIEvent: {
+    prototype: UIEvent;
+    new (): UIEvent;
+}
+
+interface SVGURIReference {
+    href: SVGAnimatedString;
+}
+
+interface SVGPathSeg {
+    pathSegType: number;
+    pathSegTypeAsLetter: string;
+    PATHSEG_MOVETO_REL: number;
+    PATHSEG_LINETO_VERTICAL_REL: number;
+    PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: number;
+    PATHSEG_CURVETO_QUADRATIC_REL: number;
+    PATHSEG_CURVETO_CUBIC_ABS: number;
+    PATHSEG_LINETO_HORIZONTAL_ABS: number;
+    PATHSEG_CURVETO_QUADRATIC_ABS: number;
+    PATHSEG_LINETO_ABS: number;
+    PATHSEG_CLOSEPATH: number;
+    PATHSEG_LINETO_HORIZONTAL_REL: number;
+    PATHSEG_CURVETO_CUBIC_SMOOTH_REL: number;
+    PATHSEG_LINETO_REL: number;
+    PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: number;
+    PATHSEG_ARC_REL: number;
+    PATHSEG_CURVETO_CUBIC_REL: number;
+    PATHSEG_UNKNOWN: number;
+    PATHSEG_LINETO_VERTICAL_ABS: number;
+    PATHSEG_ARC_ABS: number;
+    PATHSEG_MOVETO_ABS: number;
+    PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: number;
+}
+declare var SVGPathSeg: {
+    prototype: SVGPathSeg;
+    new (): SVGPathSeg;
+    PATHSEG_MOVETO_REL: number;
+    PATHSEG_LINETO_VERTICAL_REL: number;
+    PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: number;
+    PATHSEG_CURVETO_QUADRATIC_REL: number;
+    PATHSEG_CURVETO_CUBIC_ABS: number;
+    PATHSEG_LINETO_HORIZONTAL_ABS: number;
+    PATHSEG_CURVETO_QUADRATIC_ABS: number;
+    PATHSEG_LINETO_ABS: number;
+    PATHSEG_CLOSEPATH: number;
+    PATHSEG_LINETO_HORIZONTAL_REL: number;
+    PATHSEG_CURVETO_CUBIC_SMOOTH_REL: number;
+    PATHSEG_LINETO_REL: number;
+    PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: number;
+    PATHSEG_ARC_REL: number;
+    PATHSEG_CURVETO_CUBIC_REL: number;
+    PATHSEG_UNKNOWN: number;
+    PATHSEG_LINETO_VERTICAL_ABS: number;
+    PATHSEG_ARC_ABS: number;
+    PATHSEG_MOVETO_ABS: number;
+    PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: number;
+}
+
+interface WheelEvent extends MouseEvent {
+    deltaZ: number;
+    deltaX: number;
+    deltaMode: number;
+    deltaY: number;
+    initWheelEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, buttonArg: number, relatedTargetArg: EventTarget, modifiersListArg: string, deltaXArg: number, deltaYArg: number, deltaZArg: number, deltaMode: number): void;
+    DOM_DELTA_PIXEL: number;
+    DOM_DELTA_LINE: number;
+    DOM_DELTA_PAGE: number;
+}
+declare var WheelEvent: {
+    prototype: WheelEvent;
+    new (): WheelEvent;
+    DOM_DELTA_PIXEL: number;
+    DOM_DELTA_LINE: number;
+    DOM_DELTA_PAGE: number;
+}
+
+interface MSEventAttachmentTarget {
+    attachEvent(event: string, listener: EventListener): boolean;
+    detachEvent(event: string, listener: EventListener): void;
+}
+
+interface SVGNumber {
+    value: number;
+}
+declare var SVGNumber: {
+    prototype: SVGNumber;
+    new (): SVGNumber;
+}
+
+interface SVGPathElement extends SVGElement, SVGStylable, SVGAnimatedPathData, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired {
+    getPathSegAtLength(distance: number): number;
+    getPointAtLength(distance: number): SVGPoint;
+    createSVGPathSegCurvetoQuadraticAbs(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticAbs;
+    createSVGPathSegLinetoRel(x: number, y: number): SVGPathSegLinetoRel;
+    createSVGPathSegCurvetoQuadraticRel(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticRel;
+    createSVGPathSegCurvetoCubicAbs(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicAbs;
+    createSVGPathSegLinetoAbs(x: number, y: number): SVGPathSegLinetoAbs;
+    createSVGPathSegClosePath(): SVGPathSegClosePath;
+    createSVGPathSegCurvetoCubicRel(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicRel;
+    createSVGPathSegCurvetoQuadraticSmoothRel(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothRel;
+    createSVGPathSegMovetoRel(x: number, y: number): SVGPathSegMovetoRel;
+    createSVGPathSegCurvetoCubicSmoothAbs(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothAbs;
+    createSVGPathSegMovetoAbs(x: number, y: number): SVGPathSegMovetoAbs;
+    createSVGPathSegLinetoVerticalRel(y: number): SVGPathSegLinetoVerticalRel;
+    createSVGPathSegArcRel(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcRel;
+    createSVGPathSegCurvetoQuadraticSmoothAbs(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothAbs;
+    createSVGPathSegLinetoHorizontalRel(x: number): SVGPathSegLinetoHorizontalRel;
+    getTotalLength(): number;
+    createSVGPathSegCurvetoCubicSmoothRel(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothRel;
+    createSVGPathSegLinetoHorizontalAbs(x: number): SVGPathSegLinetoHorizontalAbs;
+    createSVGPathSegLinetoVerticalAbs(y: number): SVGPathSegLinetoVerticalAbs;
+    createSVGPathSegArcAbs(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcAbs;
+}
+declare var SVGPathElement: {
+    prototype: SVGPathElement;
+    new (): SVGPathElement;
+}
+
+interface MSCompatibleInfo {
+    version: string;
+    userAgent: string;
+}
+declare var MSCompatibleInfo: {
+    prototype: MSCompatibleInfo;
+    new (): MSCompatibleInfo;
+}
+
+interface Text extends CharacterData, MSNodeExtensions {
+    wholeText: string;
+    splitText(offset: number): Text;
+    replaceWholeText(content: string): Text;
+}
+declare var Text: {
+    prototype: Text;
+    new (): Text;
+}
+
+interface SVGAnimatedRect {
+    animVal: SVGRect;
+    baseVal: SVGRect;
+}
+declare var SVGAnimatedRect: {
+    prototype: SVGAnimatedRect;
+    new (): SVGAnimatedRect;
+}
+
+interface CSSNamespaceRule extends CSSRule {
+    namespaceURI: string;
+    prefix: string;
+}
+declare var CSSNamespaceRule: {
+    prototype: CSSNamespaceRule;
+    new (): CSSNamespaceRule;
+}
+
+interface SVGPathSegList {
+    numberOfItems: number;
+    replaceItem(newItem: SVGPathSeg, index: number): SVGPathSeg;
+    getItem(index: number): SVGPathSeg;
+    clear(): void;
+    appendItem(newItem: SVGPathSeg): SVGPathSeg;
+    initialize(newItem: SVGPathSeg): SVGPathSeg;
+    removeItem(index: number): SVGPathSeg;
+    insertItemBefore(newItem: SVGPathSeg, index: number): SVGPathSeg;
+}
+declare var SVGPathSegList: {
+    prototype: SVGPathSegList;
+    new (): SVGPathSegList;
+}
+
+interface HTMLUnknownElement extends HTMLElement, MSDataBindingRecordSetReadonlyExtensions {
+}
+declare var HTMLUnknownElement: {
+    prototype: HTMLUnknownElement;
+    new (): HTMLUnknownElement;
+}
+
+interface HTMLAudioElement extends HTMLMediaElement {
+}
+declare var HTMLAudioElement: {
+    prototype: HTMLAudioElement;
+    new (): HTMLAudioElement;
+}
+
+interface MSImageResourceExtensions {
+    dynsrc: string;
+    vrml: string;
+    lowsrc: string;
+    start: string;
+    loop: number;
+}
+
+interface PositionError {
+    code: number;
+    message: string;
+    toString(): string;
+    POSITION_UNAVAILABLE: number;
+    PERMISSION_DENIED: number;
+    TIMEOUT: number;
+}
+declare var PositionError: {
+    prototype: PositionError;
+    new (): PositionError;
+    POSITION_UNAVAILABLE: number;
+    PERMISSION_DENIED: number;
+    TIMEOUT: number;
+}
+
+interface HTMLTableCellElement extends HTMLElement, HTMLTableAlignment, DOML2DeprecatedBackgroundStyle, DOML2DeprecatedBackgroundColorStyle {
+    /**
+      * Sets or retrieves the width of the object.
+      */
+    width: number;
+    /**
+      * Sets or retrieves a list of header cells that provide information for the object.
+      */
+    headers: string;
+    /**
+      * Retrieves the position of the object in the cells collection of a row.
+      */
+    cellIndex: number;
+    /**
+      * Sets or retrieves how the object is aligned with adjacent text.
+      */
+    align: string;
+    /**
+      * Sets or retrieves the color for one of the two colors used to draw the 3-D border of the object.
+      */
+    borderColorLight: any;
+    /**
+      * Sets or retrieves the number columns in the table that the object should span.
+      */
+    colSpan: number;
+    /**
+      * Sets or retrieves the border color of the object. 
+      */
+    borderColor: any;
+    /**
+      * Sets or retrieves a comma-delimited list of conceptual categories associated with the object.
+      */
+    axis: string;
+    /**
+      * Sets or retrieves the height of the object.
+      */
+    height: any;
+    /**
+      * Sets or retrieves whether the browser automatically performs wordwrap.
+      */
+    noWrap: boolean;
+    /**
+      * Sets or retrieves abbreviated text for the object.
+      */
+    abbr: string;
+    /**
+      * Sets or retrieves how many rows in a table the cell should span.
+      */
+    rowSpan: number;
+    /**
+      * Sets or retrieves the group of cells in a table to which the object's information applies.
+      */
+    scope: string;
+    /**
+      * Sets or retrieves the color for one of the two colors used to draw the 3-D border of the object.
+      */
+    borderColorDark: any;
+}
+declare var HTMLTableCellElement: {
+    prototype: HTMLTableCellElement;
+    new (): HTMLTableCellElement;
+}
+
+interface SVGElementInstance extends EventTarget {
+    previousSibling: SVGElementInstance;
+    parentNode: SVGElementInstance;
+    lastChild: SVGElementInstance;
+    nextSibling: SVGElementInstance;
+    childNodes: SVGElementInstanceList;
+    correspondingUseElement: SVGUseElement;
+    correspondingElement: SVGElement;
+    firstChild: SVGElementInstance;
+}
+declare var SVGElementInstance: {
+    prototype: SVGElementInstance;
+    new (): SVGElementInstance;
+}
+
+interface MSNamespaceInfoCollection {
+    length: number;
+    add(namespace?: string, urn?: string, implementationUrl?: any): Object;
+    item(index: any): Object;
+    [index: string]: Object;
+}
+declare var MSNamespaceInfoCollection: {
+    prototype: MSNamespaceInfoCollection;
+    new (): MSNamespaceInfoCollection;
+}
+
+interface SVGCircleElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired {
+    cx: SVGAnimatedLength;
+    r: SVGAnimatedLength;
+    cy: SVGAnimatedLength;
+}
+declare var SVGCircleElement: {
+    prototype: SVGCircleElement;
+    new (): SVGCircleElement;
+}
+
+interface StyleSheetList {
+    length: number;
+    item(index?: number): StyleSheet;
+    [index: number]: StyleSheet;
+}
+declare var StyleSheetList: {
+    prototype: StyleSheetList;
+    new (): StyleSheetList;
+}
+
+interface CSSImportRule extends CSSRule {
+    styleSheet: CSSStyleSheet;
+    href: string;
+    media: MediaList;
+}
+declare var CSSImportRule: {
+    prototype: CSSImportRule;
+    new (): CSSImportRule;
+}
+
+interface CustomEvent extends Event {
+    detail: any;
+    initCustomEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: any): void;
+}
+declare var CustomEvent: {
+    prototype: CustomEvent;
+    new (): CustomEvent;
+}
+
+interface HTMLBaseFontElement extends HTMLElement, DOML2DeprecatedColorProperty {
+    /**
+      * Sets or retrieves the current typeface family.
+      */
+    face: string;
+    /**
+      * Sets or retrieves the font size of the object.
+      */
+    size: number;
+}
+declare var HTMLBaseFontElement: {
+    prototype: HTMLBaseFontElement;
+    new (): HTMLBaseFontElement;
+}
+
+interface HTMLTextAreaElement extends HTMLElement, MSDataBindingExtensions {
+    /**
+      * Retrieves or sets the text in the entry field of the textArea element.
+      */
+    value: string;
+    /**
+      * Sets or retrieves the value indicating whether the control is selected.
+      */
+    status: any;
+    /**
+      * Retrieves a reference to the form that the object is embedded in.
+      */
+    form: HTMLFormElement;
+    /**
+      * Sets or retrieves the name of the object.
+      */
+    name: string;
+    /**
+      * Gets or sets the starting position or offset of a text selection.
+      */
+    selectionStart: number;
+    /**
+      * Sets or retrieves the number of horizontal rows contained in the object.
+      */
+    rows: number;
+    /**
+      * Sets or retrieves the width of the object.
+      */
+    cols: number;
+    /**
+      * Sets or retrieves the value indicated whether the content of the object is read-only.
+      */
+    readOnly: boolean;
+    /**
+      * Sets or retrieves how to handle wordwrapping in the object.
+      */
+    wrap: string;
+    /**
+      * Gets or sets the end position or offset of a text selection.
+      */
+    selectionEnd: number;
+    /**
+      * Retrieves the type of control.
+      */
+    type: string;
+    /**
+      * Sets or retrieves the initial contents of the object.
+      */
+    defaultValue: string;
+    /**
+      * Creates a TextRange object for the element.
+      */
+    createTextRange(): TextRange;
+    /**
+      * Sets the start and end positions of a selection in a text field.
+      * @param start The offset into the text field for the start of the selection.
+      * @param end The offset into the text field for the end of the selection.
+      */
+    setSelectionRange(start: number, end: number): void;
+    /**
+      * Highlights the input area of a form element.
+      */
+    select(): void;
+}
+declare var HTMLTextAreaElement: {
+    prototype: HTMLTextAreaElement;
+    new (): HTMLTextAreaElement;
+}
+
+interface Geolocation {
+    clearWatch(watchId: number): void;
+    getCurrentPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): void;
+    watchPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): number;
+}
+declare var Geolocation: {
+    prototype: Geolocation;
+    new (): Geolocation;
+}
+
+interface DOML2DeprecatedMarginStyle {
+    vspace: number;
+    hspace: number;
+}
+
+interface MSWindowModeless {
+    dialogTop: any;
+    dialogLeft: any;
+    dialogWidth: any;
+    dialogHeight: any;
+    menuArguments: any;
+}
+
+interface DOML2DeprecatedAlignmentStyle {
+    align: string;
+}
+
+interface HTMLMarqueeElement extends HTMLElement, MSDataBindingExtensions, DOML2DeprecatedBackgroundColorStyle {
+    width: string;
+    onbounce: (ev: Event) => any;
+    vspace: number;
+    trueSpeed: boolean;
+    scrollAmount: number;
+    scrollDelay: number;
+    behavior: string;
+    height: string;
+    loop: number;
+    direction: string;
+    hspace: number;
+    onstart: (ev: Event) => any;
+    onfinish: (ev: Event) => any;
+    stop(): void;
+    start(): void;
+}
+declare var HTMLMarqueeElement: {
+    prototype: HTMLMarqueeElement;
+    new (): HTMLMarqueeElement;
+}
+
+interface SVGRect {
+    y: number;
+    width: number;
+    x: number;
+    height: number;
+}
+declare var SVGRect: {
+    prototype: SVGRect;
+    new (): SVGRect;
+}
+
+interface MSNodeExtensions {
+    swapNode(otherNode: Node): Node;
+    removeNode(deep?: boolean): Node;
+    replaceNode(replacement: Node): Node;
+}
+
+interface History {
+    length: number;
+    back(distance?: any): void;
+    forward(distance?: any): void;
+    go(delta?: any): void;
+}
+declare var History: {
+    prototype: History;
+    new (): History;
+}
+
+interface SVGPathSegCurvetoCubicAbs extends SVGPathSeg {
+    y: number;
+    y1: number;
+    x2: number;
+    x: number;
+    x1: number;
+    y2: number;
+}
+declare var SVGPathSegCurvetoCubicAbs: {
+    prototype: SVGPathSegCurvetoCubicAbs;
+    new (): SVGPathSegCurvetoCubicAbs;
+}
+
+interface SVGPathSegCurvetoQuadraticAbs extends SVGPathSeg {
+    y: number;
+    y1: number;
+    x: number;
+    x1: number;
+}
+declare var SVGPathSegCurvetoQuadraticAbs: {
+    prototype: SVGPathSegCurvetoQuadraticAbs;
+    new (): SVGPathSegCurvetoQuadraticAbs;
+}
+
+interface TimeRanges {
+    length: number;
+    start(index: number): number;
+    end(index: number): number;
+}
+declare var TimeRanges: {
+    prototype: TimeRanges;
+    new (): TimeRanges;
+}
+
+interface CSSRule {
+    cssText: string;
+    parentStyleSheet: CSSStyleSheet;
+    parentRule: CSSRule;
+    type: number;
+    IMPORT_RULE: number;
+    MEDIA_RULE: number;
+    STYLE_RULE: number;
+    NAMESPACE_RULE: number;
+    PAGE_RULE: number;
+    UNKNOWN_RULE: number;
+    FONT_FACE_RULE: number;
+    CHARSET_RULE: number;
+}
+declare var CSSRule: {
+    prototype: CSSRule;
+    new (): CSSRule;
+    IMPORT_RULE: number;
+    MEDIA_RULE: number;
+    STYLE_RULE: number;
+    NAMESPACE_RULE: number;
+    PAGE_RULE: number;
+    UNKNOWN_RULE: number;
+    FONT_FACE_RULE: number;
+    CHARSET_RULE: number;
+}
+
+interface SVGPathSegLinetoAbs extends SVGPathSeg {
+    y: number;
+    x: number;
+}
+declare var SVGPathSegLinetoAbs: {
+    prototype: SVGPathSegLinetoAbs;
+    new (): SVGPathSegLinetoAbs;
+}
+
+interface HTMLModElement extends HTMLElement {
+    /**
+      * Sets or retrieves the date and time of a modification to the object.
+      */
+    dateTime: string;
+    /**
+      * Sets or retrieves reference information about the object.
+      */
+    cite: string;
+}
+declare var HTMLModElement: {
+    prototype: HTMLModElement;
+    new (): HTMLModElement;
+}
+
+interface SVGMatrix {
+    e: number;
+    c: number;
+    a: number;
+    b: number;
+    d: number;
+    f: number;
+    multiply(secondMatrix: SVGMatrix): SVGMatrix;
+    flipY(): SVGMatrix;
+    skewY(angle: number): SVGMatrix;
+    inverse(): SVGMatrix;
+    scaleNonUniform(scaleFactorX: number, scaleFactorY: number): SVGMatrix;
+    rotate(angle: number): SVGMatrix;
+    flipX(): SVGMatrix;
+    translate(x: number, y: number): SVGMatrix;
+    scale(scaleFactor: number): SVGMatrix;
+    rotateFromVector(x: number, y: number): SVGMatrix;
+    skewX(angle: number): SVGMatrix;
+}
+declare var SVGMatrix: {
+    prototype: SVGMatrix;
+    new (): SVGMatrix;
+}
+
+interface MSPopupWindow {
+    document: Document;
+    isOpen: boolean;
+    show(x: number, y: number, w: number, h: number, element?: any): void;
+    hide(): void;
+}
+declare var MSPopupWindow: {
+    prototype: MSPopupWindow;
+    new (): MSPopupWindow;
+}
+
+interface BeforeUnloadEvent extends Event {
+    returnValue: string;
+}
+declare var BeforeUnloadEvent: {
+    prototype: BeforeUnloadEvent;
+    new (): BeforeUnloadEvent;
+}
+
+interface SVGUseElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired, SVGURIReference {
+    y: SVGAnimatedLength;
+    width: SVGAnimatedLength;
+    animatedInstanceRoot: SVGElementInstance;
+    instanceRoot: SVGElementInstance;
+    x: SVGAnimatedLength;
+    height: SVGAnimatedLength;
+}
+declare var SVGUseElement: {
+    prototype: SVGUseElement;
+    new (): SVGUseElement;
+}
+
+interface Event {
+    timeStamp: number;
+    defaultPrevented: boolean;
+    isTrusted: boolean;
+    currentTarget: EventTarget;
+    cancelBubble: boolean;
+    target: EventTarget;
+    eventPhase: number;
+    cancelable: boolean;
+    type: string;
+    srcElement: Element;
+    bubbles: boolean;
+    initEvent(eventTypeArg: string, canBubbleArg: boolean, cancelableArg: boolean): void;
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+    preventDefault(): void;
+    CAPTURING_PHASE: number;
+    AT_TARGET: number;
+    BUBBLING_PHASE: number;
+}
+declare var Event: {
+    prototype: Event;
+    new (): Event;
+    CAPTURING_PHASE: number;
+    AT_TARGET: number;
+    BUBBLING_PHASE: number;
+}
+
+interface ImageData {
+    width: number;
+    data: Uint8Array;
+    height: number;
+}
+declare var ImageData: {
+    prototype: ImageData;
+    new (): ImageData;
+}
+
+interface HTMLTableColElement extends HTMLElement, HTMLTableAlignment {
+    /**
+      * Sets or retrieves the width of the object.
+      */
+    width: any;
+    /**
+      * Sets or retrieves the alignment of the object relative to the display or table.
+      */
+    align: string;
+    /**
+      * Sets or retrieves the number of columns in the group.
+      */
+    span: number;
+}
+declare var HTMLTableColElement: {
+    prototype: HTMLTableColElement;
+    new (): HTMLTableColElement;
+}
+
+interface SVGException {
+    code: number;
+    message: string;
+    toString(): string;
+    SVG_MATRIX_NOT_INVERTABLE: number;
+    SVG_WRONG_TYPE_ERR: number;
+    SVG_INVALID_VALUE_ERR: number;
+}
+declare var SVGException: {
+    prototype: SVGException;
+    new (): SVGException;
+    SVG_MATRIX_NOT_INVERTABLE: number;
+    SVG_WRONG_TYPE_ERR: number;
+    SVG_INVALID_VALUE_ERR: number;
+}
+
+interface SVGLinearGradientElement extends SVGGradientElement {
+    y1: SVGAnimatedLength;
+    x2: SVGAnimatedLength;
+    x1: SVGAnimatedLength;
+    y2: SVGAnimatedLength;
+}
+declare var SVGLinearGradientElement: {
+    prototype: SVGLinearGradientElement;
+    new (): SVGLinearGradientElement;
+}
+
+interface HTMLTableAlignment {
+    /**
+      * Sets or retrieves a value that you can use to implement your own ch functionality for the object.
+      */
+    ch: string;
+    /**
+      * Sets or retrieves how text and other content are vertically aligned within the object that contains them.
+      */
+    vAlign: string;
+    /**
+      * Sets or retrieves a value that you can use to implement your own chOff functionality for the object.
+      */
+    chOff: string;
+}
+
+interface SVGAnimatedEnumeration {
+    animVal: number;
+    baseVal: number;
+}
+declare var SVGAnimatedEnumeration: {
+    prototype: SVGAnimatedEnumeration;
+    new (): SVGAnimatedEnumeration;
+}
+
+interface DOML2DeprecatedSizeProperty {
+    size: number;
+}
+
+interface HTMLUListElement extends HTMLElement, DOML2DeprecatedListSpaceReduction, DOML2DeprecatedListNumberingAndBulletStyle {
+}
+declare var HTMLUListElement: {
+    prototype: HTMLUListElement;
+    new (): HTMLUListElement;
+}
+
+interface SVGRectElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired {
+    y: SVGAnimatedLength;
+    width: SVGAnimatedLength;
+    ry: SVGAnimatedLength;
+    rx: SVGAnimatedLength;
+    x: SVGAnimatedLength;
+    height: SVGAnimatedLength;
+}
+declare var SVGRectElement: {
+    prototype: SVGRectElement;
+    new (): SVGRectElement;
+}
+
+interface ErrorEventHandler {
+    (event: Event, source: string, fileno: number, columnNumber: number): void;
+    (message: any, uri: string, lineNumber: number, columnNumber?: number): void;
+}
+
+interface HTMLDivElement extends HTMLElement, MSDataBindingExtensions {
+    /**
+      * Sets or retrieves how the object is aligned with adjacent text. 
+      */
+    align: string;
+    /**
+      * Sets or retrieves whether the browser automatically performs wordwrap.
+      */
+    noWrap: boolean;
+}
+declare var HTMLDivElement: {
+    prototype: HTMLDivElement;
+    new (): HTMLDivElement;
+}
+
+interface DOML2DeprecatedBorderStyle {
+    border: string;
+}
+
+interface NamedNodeMap {
+    length: number;
+    removeNamedItemNS(namespaceURI: string, localName: string): Attr;
+    item(index: number): Attr;
+    [index: number]: Attr;
+    removeNamedItem(name: string): Attr;
+    getNamedItem(name: string): Attr;
+    setNamedItem(arg: Attr): Attr;
+    getNamedItemNS(namespaceURI: string, localName: string): Attr;
+    setNamedItemNS(arg: Attr): Attr;
+}
+declare var NamedNodeMap: {
+    prototype: NamedNodeMap;
+    new (): NamedNodeMap;
+}
+
+interface MediaList {
+    length: number;
+    mediaText: string;
+    deleteMedium(oldMedium: string): void;
+    appendMedium(newMedium: string): void;
+    item(index: number): string;
+    [index: number]: string;
+    toString(): string;
+}
+declare var MediaList: {
+    prototype: MediaList;
+    new (): MediaList;
+}
+
+interface SVGPathSegCurvetoQuadraticSmoothAbs extends SVGPathSeg {
+    y: number;
+    x: number;
+}
+declare var SVGPathSegCurvetoQuadraticSmoothAbs: {
+    prototype: SVGPathSegCurvetoQuadraticSmoothAbs;
+    new (): SVGPathSegCurvetoQuadraticSmoothAbs;
+}
+
+interface SVGPathSegCurvetoCubicSmoothRel extends SVGPathSeg {
+    y: number;
+    x2: number;
+    x: number;
+    y2: number;
+}
+declare var SVGPathSegCurvetoCubicSmoothRel: {
+    prototype: SVGPathSegCurvetoCubicSmoothRel;
+    new (): SVGPathSegCurvetoCubicSmoothRel;
+}
+
+interface SVGLengthList {
+    numberOfItems: number;
+    replaceItem(newItem: SVGLength, index: number): SVGLength;
+    getItem(index: number): SVGLength;
+    clear(): void;
+    appendItem(newItem: SVGLength): SVGLength;
+    initialize(newItem: SVGLength): SVGLength;
+    removeItem(index: number): SVGLength;
+    insertItemBefore(newItem: SVGLength, index: number): SVGLength;
+}
+declare var SVGLengthList: {
+    prototype: SVGLengthList;
+    new (): SVGLengthList;
+}
+
+interface ProcessingInstruction extends Node {
+    target: string;
+    data: string;
+}
+declare var ProcessingInstruction: {
+    prototype: ProcessingInstruction;
+    new (): ProcessingInstruction;
+}
+
+interface MSWindowExtensions {
+    status: string;
+    onmouseleave: (ev: MouseEvent) => any;
+    screenLeft: number;
+    offscreenBuffering: any;
+    maxConnectionsPerServer: number;
+    onmouseenter: (ev: MouseEvent) => any;
+    clipboardData: DataTransfer;
+    defaultStatus: string;
+    clientInformation: Navigator;
+    closed: boolean;
+    onhelp: (ev: Event) => any;
+    external: External;
+    event: MSEventObj;
+    onfocusout: (ev: FocusEvent) => any;
+    screenTop: number;
+    onfocusin: (ev: FocusEvent) => any;
+    showModelessDialog(url?: string, argument?: any, options?: any): Window;
+    navigate(url: string): void;
+    resizeBy(x?: number, y?: number): void;
+    item(index: any): any;
+    resizeTo(x?: number, y?: number): void;
+    createPopup(arguments?: any): MSPopupWindow;
+    toStaticHTML(html: string): string;
+    execScript(code: string, language?: string): any;
+    msWriteProfilerMark(profilerMarkName: string): void;
+    moveTo(x?: number, y?: number): void;
+    moveBy(x?: number, y?: number): void;
+    showHelp(url: string, helpArg?: any, features?: string): void;
+}
+
+interface MSBehaviorUrnsCollection {
+    length: number;
+    item(index: number): string;
+}
+declare var MSBehaviorUrnsCollection: {
+    prototype: MSBehaviorUrnsCollection;
+    new (): MSBehaviorUrnsCollection;
+}
+
+interface CSSFontFaceRule extends CSSRule {
+    style: CSSStyleDeclaration;
+}
+declare var CSSFontFaceRule: {
+    prototype: CSSFontFaceRule;
+    new (): CSSFontFaceRule;
+}
+
+interface DOML2DeprecatedBackgroundStyle {
+    background: string;
+}
+
+interface TextEvent extends UIEvent {
+    inputMethod: number;
+    data: string;
+    locale: string;
+    initTextEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, dataArg: string, inputMethod: number, locale: string): void;
+    DOM_INPUT_METHOD_KEYBOARD: number;
+    DOM_INPUT_METHOD_DROP: number;
+    DOM_INPUT_METHOD_IME: number;
+    DOM_INPUT_METHOD_SCRIPT: number;
+    DOM_INPUT_METHOD_VOICE: number;
+    DOM_INPUT_METHOD_UNKNOWN: number;
+    DOM_INPUT_METHOD_PASTE: number;
+    DOM_INPUT_METHOD_HANDWRITING: number;
+    DOM_INPUT_METHOD_OPTION: number;
+    DOM_INPUT_METHOD_MULTIMODAL: number;
+}
+declare var TextEvent: {
+    prototype: TextEvent;
+    new (): TextEvent;
+    DOM_INPUT_METHOD_KEYBOARD: number;
+    DOM_INPUT_METHOD_DROP: number;
+    DOM_INPUT_METHOD_IME: number;
+    DOM_INPUT_METHOD_SCRIPT: number;
+    DOM_INPUT_METHOD_VOICE: number;
+    DOM_INPUT_METHOD_UNKNOWN: number;
+    DOM_INPUT_METHOD_PASTE: number;
+    DOM_INPUT_METHOD_HANDWRITING: number;
+    DOM_INPUT_METHOD_OPTION: number;
+    DOM_INPUT_METHOD_MULTIMODAL: number;
+}
+
+interface DocumentFragment extends Node, NodeSelector, MSEventAttachmentTarget, MSNodeExtensions {
+}
+declare var DocumentFragment: {
+    prototype: DocumentFragment;
+    new (): DocumentFragment;
+}
+
+interface SVGPolylineElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGAnimatedPoints, SVGTests, SVGExternalResourcesRequired {
+}
+declare var SVGPolylineElement: {
+    prototype: SVGPolylineElement;
+    new (): SVGPolylineElement;
+}
+
+interface SVGAnimatedPathData {
+    pathSegList: SVGPathSegList;
+}
+
+interface Position {
+    timestamp: number;
+    coords: Coordinates;
+}
+declare var Position: {
+    prototype: Position;
+    new (): Position;
+}
+
+interface BookmarkCollection {
+    length: number;
+    item(index: number): any;
+    [index: number]: any;
+}
+declare var BookmarkCollection: {
+    prototype: BookmarkCollection;
+    new (): BookmarkCollection;
+}
+
+interface PerformanceMark extends PerformanceEntry {
+}
+declare var PerformanceMark: {
+    prototype: PerformanceMark;
+    new (): PerformanceMark;
+}
+
+interface CSSPageRule extends CSSRule {
+    pseudoClass: string;
+    selectorText: string;
+    selector: string;
+    style: CSSStyleDeclaration;
+}
+declare var CSSPageRule: {
+    prototype: CSSPageRule;
+    new (): CSSPageRule;
+}
+
+interface HTMLBRElement extends HTMLElement {
+    /**
+      * Sets or retrieves the side on which floating objects are not to be positioned when any IHTMLBlockElement is inserted into the document.
+      */
+    clear: string;
+}
+declare var HTMLBRElement: {
+    prototype: HTMLBRElement;
+    new (): HTMLBRElement;
+}
+
+interface MSNavigatorExtensions {
+    userLanguage: string;
+    plugins: MSPluginsCollection;
+    cookieEnabled: boolean;
+    appCodeName: string;
+    cpuClass: string;
+    appMinorVersion: string;
+    connectionSpeed: number;
+    browserLanguage: string;
+    mimeTypes: MSMimeTypesCollection;
+    systemLanguage: string;
+    javaEnabled(): boolean;
+    taintEnabled(): boolean;
+}
+
+interface HTMLSpanElement extends HTMLElement, MSDataBindingExtensions {
+}
+declare var HTMLSpanElement: {
+    prototype: HTMLSpanElement;
+    new (): HTMLSpanElement;
+}
+
+interface HTMLHeadElement extends HTMLElement {
+    profile: string;
+}
+declare var HTMLHeadElement: {
+    prototype: HTMLHeadElement;
+    new (): HTMLHeadElement;
+}
+
+interface HTMLHeadingElement extends HTMLElement, DOML2DeprecatedTextFlowControl {
+    /**
+      * Sets or retrieves a value that indicates the table alignment.
+      */
+    align: string;
+}
+declare var HTMLHeadingElement: {
+    prototype: HTMLHeadingElement;
+    new (): HTMLHeadingElement;
+}
+
+interface HTMLFormElement extends HTMLElement, MSHTMLCollectionExtensions {
+    /**
+      * Sets or retrieves the number of objects in a collection.
+      */
+    length: number;
+    /**
+      * Sets or retrieves the window or frame at which to target content.
+      */
+    target: string;
+    /**
+      * Sets or retrieves a list of character encodings for input data that must be accepted by the server processing the form.
+      */
+    acceptCharset: string;
+    /**
+      * Sets or retrieves the encoding type for the form.
+      */
+    enctype: string;
+    /**
+      * Retrieves a collection, in source order, of all controls in a given form.
+      */
+    elements: HTMLCollection;
+    /**
+      * Sets or retrieves the URL to which the form content is sent for processing.
+      */
+    action: string;
+    /**
+      * Sets or retrieves the name of the object.
+      */
+    name: string;
+    /**
+      * Sets or retrieves how to send the form data to the server.
+      */
+    method: string;
+    /**
+      * Sets or retrieves the MIME encoding for the form.
+      */
+    encoding: string;
+    /**
+      * Fires when the user resets a form.
+      */
+    reset(): void;
+    /**
+      * Retrieves a form object or an object from an elements collection.
+      * @param name Variant of type Number or String that specifies the object or collection to retrieve. If this parameter is a Number, it is the zero-based index of the object. If this parameter is a string, all objects with matching name or id properties are retrieved, and a collection is returned if more than one match is made.
+      * @param index Variant of type Number that specifies the zero-based index of the object to retrieve when a collection is returned.
+      */
+    item(name?: any, index?: any): any;
+    /**
+      * Fires when a FORM is about to be submitted.
+      */
+    submit(): void;
+    /**
+      * Retrieves a form object or an object from an elements collection.
+      */
+    namedItem(name: string): any;
+    [name: string]: any;
+}
+declare var HTMLFormElement: {
+    prototype: HTMLFormElement;
+    new (): HTMLFormElement;
+}
+
+interface SVGZoomAndPan {
+    zoomAndPan: number;
+    SVG_ZOOMANDPAN_MAGNIFY: number;
+    SVG_ZOOMANDPAN_UNKNOWN: number;
+    SVG_ZOOMANDPAN_DISABLE: number;
+}
+declare var SVGZoomAndPan: {
+    prototype: SVGZoomAndPan;
+    new (): SVGZoomAndPan;
+    SVG_ZOOMANDPAN_MAGNIFY: number;
+    SVG_ZOOMANDPAN_UNKNOWN: number;
+    SVG_ZOOMANDPAN_DISABLE: number;
+}
+
+interface HTMLMediaElement extends HTMLElement {
+    /**
+      * Gets the earliest possible position, in seconds, that the playback can begin.
+      */
+    initialTime: number;
+    /**
+      * Gets TimeRanges for the current media resource that has been played.
+      */
+    played: TimeRanges;
+    /**
+      * Gets the address or URL of the current media resource that is selected by IHTMLMediaElement.
+      */
+    currentSrc: string;
+    readyState: any;
+    /**
+      * The autobuffer element is not supported by Internet Explorer 9. Use the preload element instead.
+      */
+    autobuffer: boolean;
+    /**
+      * Gets or sets a flag to specify whether playback should restart after it completes.
+      */
+    loop: boolean;
+    /**
+      * Gets information about whether the playback has ended or not.
+      */
+    ended: boolean;
+    /**
+      * Gets a collection of buffered time ranges.
+      */
+    buffered: TimeRanges;
+    /**
+      * Returns an object representing the current error state of the audio or video element.
+      */
+    error: MediaError;
+    /**
+      * Returns a TimeRanges object that represents the ranges of the current media resource that can be seeked.
+      */
+    seekable: TimeRanges;
+    /**
+      * Gets or sets a value that indicates whether to start playing the media automatically.
+      */
+    autoplay: boolean;
+    /**
+      * Gets or sets a flag that indicates whether the client provides a set of controls for the media (in case the developer does not include controls for the player).
+      */
+    controls: boolean;
+    /**
+      * Gets or sets the volume level for audio portions of the media element.
+      */
+    volume: number;
+    /**
+      * The address or URL of the a media resource that is to be considered.
+      */
+    src: string;
+    /**
+      * Gets or sets the current rate of speed for the media resource to play. This speed is expressed as a multiple of the normal speed of the media resource.
+      */
+    playbackRate: number;
+    /**
+      * Returns the duration in seconds of the current media resource. A NaN value is returned if duration is not available, or Infinity if the media resource is streaming.
+      */
+    duration: number;
+    /**
+      * Gets or sets a flag that indicates whether the audio (either audio or the audio track on video media) is muted.
+      */
+    muted: boolean;
+    /**
+      * Gets or sets the default playback rate when the user is not using fast forward or reverse for a video or audio resource.
+      */
+    defaultPlaybackRate: number;
+    /**
+      * Gets a flag that specifies whether playback is paused.
+      */
+    paused: boolean;
+    /**
+      * Gets a flag that indicates whether the the client is currently moving to a new playback position in the media resource.
+      */
+    seeking: boolean;
+    /**
+      * Gets or sets the current playback position, in seconds.
+      */
+    currentTime: number;
+    /**
+      * Gets or sets the current playback position, in seconds.
+      */
+    preload: string;
+    /**
+      * Gets the current network activity for the element.
+      */
+    networkState: number;
+    /**
+      * Pauses the current playback and sets paused to TRUE. This can be used to test whether the media is playing or paused. You can also use the pause or play events to tell whether the media is playing or not.
+      */
+    pause(): void;
+    /**
+      * Loads and starts playback of a media resource.
+      */
+    play(): void;
+    /**
+      * Fires immediately after the client loads the object.
+      */
+    load(): void;
+    /**
+      * Returns a string that specifies whether the client can play a given media resource type.
+      */
+    canPlayType(type: string): string;
+    HAVE_METADATA: number;
+    HAVE_CURRENT_DATA: number;
+    HAVE_NOTHING: number;
+    NETWORK_NO_SOURCE: number;
+    HAVE_ENOUGH_DATA: number;
+    NETWORK_EMPTY: number;
+    NETWORK_LOADING: number;
+    NETWORK_IDLE: number;
+    HAVE_FUTURE_DATA: number;
+}
+declare var HTMLMediaElement: {
+    prototype: HTMLMediaElement;
+    new (): HTMLMediaElement;
+    HAVE_METADATA: number;
+    HAVE_CURRENT_DATA: number;
+    HAVE_NOTHING: number;
+    NETWORK_NO_SOURCE: number;
+    HAVE_ENOUGH_DATA: number;
+    NETWORK_EMPTY: number;
+    NETWORK_LOADING: number;
+    NETWORK_IDLE: number;
+    HAVE_FUTURE_DATA: number;
+}
+
+interface ElementCSSInlineStyle {
+    runtimeStyle: MSStyleCSSProperties;
+    currentStyle: MSCurrentStyleCSSProperties;
+    doScroll(component?: any): void;
+    componentFromPoint(x: number, y: number): string;
+}
+
+interface DOMParser {
+    parseFromString(source: string, mimeType: string): Document;
+}
+declare var DOMParser: {
+    prototype: DOMParser;
+    new (): DOMParser;
+}
+
+interface MSMimeTypesCollection {
+    length: number;
+}
+declare var MSMimeTypesCollection: {
+    prototype: MSMimeTypesCollection;
+    new (): MSMimeTypesCollection;
+}
+
+interface StyleSheet {
+    disabled: boolean;
+    ownerNode: Node;
+    parentStyleSheet: StyleSheet;
+    href: string;
+    media: MediaList;
+    type: string;
+    title: string;
+}
+declare var StyleSheet: {
+    prototype: StyleSheet;
+    new (): StyleSheet;
+}
+
+interface SVGTextPathElement extends SVGTextContentElement, SVGURIReference {
+    startOffset: SVGAnimatedLength;
+    method: SVGAnimatedEnumeration;
+    spacing: SVGAnimatedEnumeration;
+    TEXTPATH_SPACINGTYPE_EXACT: number;
+    TEXTPATH_METHODTYPE_STRETCH: number;
+    TEXTPATH_SPACINGTYPE_AUTO: number;
+    TEXTPATH_SPACINGTYPE_UNKNOWN: number;
+    TEXTPATH_METHODTYPE_UNKNOWN: number;
+    TEXTPATH_METHODTYPE_ALIGN: number;
+}
+declare var SVGTextPathElement: {
+    prototype: SVGTextPathElement;
+    new (): SVGTextPathElement;
+    TEXTPATH_SPACINGTYPE_EXACT: number;
+    TEXTPATH_METHODTYPE_STRETCH: number;
+    TEXTPATH_SPACINGTYPE_AUTO: number;
+    TEXTPATH_SPACINGTYPE_UNKNOWN: number;
+    TEXTPATH_METHODTYPE_UNKNOWN: number;
+    TEXTPATH_METHODTYPE_ALIGN: number;
+}
+
+interface HTMLDTElement extends HTMLElement {
+    /**
+      * Sets or retrieves whether the browser automatically performs wordwrap.
+      */
+    noWrap: boolean;
+}
+declare var HTMLDTElement: {
+    prototype: HTMLDTElement;
+    new (): HTMLDTElement;
+}
+
+interface NodeList {
+    length: number;
+    item(index: number): Node;
+    [index: number]: Node;
+}
+declare var NodeList: {
+    prototype: NodeList;
+    new (): NodeList;
+}
+
+interface NodeListOf<TNode extends Node> extends NodeList {
+    length: number;
+    item(index: number): TNode;
+    [index: number]: TNode;
+}
+
+interface XMLSerializer {
+    serializeToString(target: Node): string;
+}
+declare var XMLSerializer: {
+    prototype: XMLSerializer;
+    new (): XMLSerializer;
+}
+
+interface PerformanceMeasure extends PerformanceEntry {
+}
+declare var PerformanceMeasure: {
+    prototype: PerformanceMeasure;
+    new (): PerformanceMeasure;
+}
+
+interface SVGGradientElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGExternalResourcesRequired, SVGURIReference {
+    spreadMethod: SVGAnimatedEnumeration;
+    gradientTransform: SVGAnimatedTransformList;
+    gradientUnits: SVGAnimatedEnumeration;
+    SVG_SPREADMETHOD_REFLECT: number;
+    SVG_SPREADMETHOD_PAD: number;
+    SVG_SPREADMETHOD_UNKNOWN: number;
+    SVG_SPREADMETHOD_REPEAT: number;
+}
+declare var SVGGradientElement: {
+    prototype: SVGGradientElement;
+    new (): SVGGradientElement;
+    SVG_SPREADMETHOD_REFLECT: number;
+    SVG_SPREADMETHOD_PAD: number;
+    SVG_SPREADMETHOD_UNKNOWN: number;
+    SVG_SPREADMETHOD_REPEAT: number;
+}
+
+interface NodeFilter {
+    acceptNode(n: Node): number;
+    SHOW_ENTITY_REFERENCE: number;
+    SHOW_NOTATION: number;
+    SHOW_ENTITY: number;
+    SHOW_DOCUMENT: number;
+    SHOW_PROCESSING_INSTRUCTION: number;
+    FILTER_REJECT: number;
+    SHOW_CDATA_SECTION: number;
+    FILTER_ACCEPT: number;
+    SHOW_ALL: number;
+    SHOW_DOCUMENT_TYPE: number;
+    SHOW_TEXT: number;
+    SHOW_ELEMENT: number;
+    SHOW_COMMENT: number;
+    FILTER_SKIP: number;
+    SHOW_ATTRIBUTE: number;
+    SHOW_DOCUMENT_FRAGMENT: number;
+}
+declare var NodeFilter: {
+    prototype: NodeFilter;
+    new (): NodeFilter;
+    SHOW_ENTITY_REFERENCE: number;
+    SHOW_NOTATION: number;
+    SHOW_ENTITY: number;
+    SHOW_DOCUMENT: number;
+    SHOW_PROCESSING_INSTRUCTION: number;
+    FILTER_REJECT: number;
+    SHOW_CDATA_SECTION: number;
+    FILTER_ACCEPT: number;
+    SHOW_ALL: number;
+    SHOW_DOCUMENT_TYPE: number;
+    SHOW_TEXT: number;
+    SHOW_ELEMENT: number;
+    SHOW_COMMENT: number;
+    FILTER_SKIP: number;
+    SHOW_ATTRIBUTE: number;
+    SHOW_DOCUMENT_FRAGMENT: number;
+}
+
+interface SVGNumberList {
+    numberOfItems: number;
+    replaceItem(newItem: SVGNumber, index: number): SVGNumber;
+    getItem(index: number): SVGNumber;
+    clear(): void;
+    appendItem(newItem: SVGNumber): SVGNumber;
+    initialize(newItem: SVGNumber): SVGNumber;
+    removeItem(index: number): SVGNumber;
+    insertItemBefore(newItem: SVGNumber, index: number): SVGNumber;
+}
+declare var SVGNumberList: {
+    prototype: SVGNumberList;
+    new (): SVGNumberList;
+}
+
+interface MediaError {
+    code: number;
+    MEDIA_ERR_ABORTED: number;
+    MEDIA_ERR_NETWORK: number;
+    MEDIA_ERR_SRC_NOT_SUPPORTED: number;
+    MEDIA_ERR_DECODE: number;
+}
+declare var MediaError: {
+    prototype: MediaError;
+    new (): MediaError;
+    MEDIA_ERR_ABORTED: number;
+    MEDIA_ERR_NETWORK: number;
+    MEDIA_ERR_SRC_NOT_SUPPORTED: number;
+    MEDIA_ERR_DECODE: number;
+}
+
+interface HTMLFieldSetElement extends HTMLElement {
+    /**
+      * Sets or retrieves how the object is aligned with adjacent text.
+      */
+    align: string;
+    /**
+      * Retrieves a reference to the form that the object is embedded in.
+      */
+    form: HTMLFormElement;
+}
+declare var HTMLFieldSetElement: {
+    prototype: HTMLFieldSetElement;
+    new (): HTMLFieldSetElement;
+}
+
+interface HTMLBGSoundElement extends HTMLElement {
+    /**
+      * Sets or gets the value indicating how the volume of the background sound is divided between the left speaker and the right speaker.
+      */
+    balance: any;
+    /**
+      * Sets or gets the volume setting for the sound. 
+      */
+    volume: any;
+    /**
+      * Sets or gets the URL of a sound to play.
+      */
+    src: string;
+    /**
+      * Sets or retrieves the number of times a sound or video clip will loop when activated.
+      */
+    loop: number;
+}
+declare var HTMLBGSoundElement: {
+    prototype: HTMLBGSoundElement;
+    new (): HTMLBGSoundElement;
+}
+
+interface HTMLElement extends Element, ElementCSSInlineStyle, MSEventAttachmentTarget, MSNodeExtensions {
+    onmouseleave: (ev: MouseEvent) => any;
+    onbeforecut: (ev: DragEvent) => any;
+    onkeydown: (ev: KeyboardEvent) => any;
+    onmove: (ev: MSEventObj) => any;
+    onkeyup: (ev: KeyboardEvent) => any;
+    onreset: (ev: Event) => any;
+    onhelp: (ev: Event) => any;
+    ondragleave: (ev: DragEvent) => any;
+    className: string;
+    onfocusin: (ev: FocusEvent) => any;
+    onseeked: (ev: Event) => any;
+    recordNumber: any;
+    title: string;
+    parentTextEdit: Element;
+    outerHTML: string;
+    ondurationchange: (ev: Event) => any;
+    offsetHeight: number;
+    all: HTMLCollection;
+    onblur: (ev: FocusEvent) => any;
+    dir: string;
+    onemptied: (ev: Event) => any;
+    onseeking: (ev: Event) => any;
+    oncanplay: (ev: Event) => any;
+    ondeactivate: (ev: UIEvent) => any;
+    ondatasetchanged: (ev: MSEventObj) => any;
+    onrowsdelete: (ev: MSEventObj) => any;
+    sourceIndex: number;
+    onloadstart: (ev: Event) => any;
+    onlosecapture: (ev: MSEventObj) => any;
+    ondragenter: (ev: DragEvent) => any;
+    oncontrolselect: (ev: MSEventObj) => any;
+    onsubmit: (ev: Event) => any;
+    behaviorUrns: MSBehaviorUrnsCollection;
+    scopeName: string;
+    onchange: (ev: Event) => any;
+    id: string;
+    onlayoutcomplete: (ev: MSEventObj) => any;
+    uniqueID: string;
+    onbeforeactivate: (ev: UIEvent) => any;
+    oncanplaythrough: (ev: Event) => any;
+    onbeforeupdate: (ev: MSEventObj) => any;
+    onfilterchange: (ev: MSEventObj) => any;
+    offsetParent: Element;
+    ondatasetcomplete: (ev: MSEventObj) => any;
+    onsuspend: (ev: Event) => any;
+    readyState: any;
+    onmouseenter: (ev: MouseEvent) => any;
+    innerText: string;
+    onerrorupdate: (ev: MSEventObj) => any;
+    onmouseout: (ev: MouseEvent) => any;
+    parentElement: HTMLElement;
+    onmousewheel: (ev: MouseWheelEvent) => any;
+    onvolumechange: (ev: Event) => any;
+    oncellchange: (ev: MSEventObj) => any;
+    onrowexit: (ev: MSEventObj) => any;
+    onrowsinserted: (ev: MSEventObj) => any;
+    onpropertychange: (ev: MSEventObj) => any;
+    filters: Object;
+    children: HTMLCollection;
+    ondragend: (ev: DragEvent) => any;
+    onbeforepaste: (ev: DragEvent) => any;
+    ondragover: (ev: DragEvent) => any;
+    offsetTop: number;
+    onmouseup: (ev: MouseEvent) => any;
+    ondragstart: (ev: DragEvent) => any;
+    onbeforecopy: (ev: DragEvent) => any;
+    ondrag: (ev: DragEvent) => any;
+    innerHTML: string;
+    onmouseover: (ev: MouseEvent) => any;
+    lang: string;
+    uniqueNumber: number;
+    onpause: (ev: Event) => any;
+    tagUrn: string;
+    onmousedown: (ev: MouseEvent) => any;
+    onclick: (ev: MouseEvent) => any;
+    onwaiting: (ev: Event) => any;
+    onresizestart: (ev: MSEventObj) => any;
+    offsetLeft: number;
+    isTextEdit: boolean;
+    isDisabled: boolean;
+    onpaste: (ev: DragEvent) => any;
+    canHaveHTML: boolean;
+    onmoveend: (ev: MSEventObj) => any;
+    language: string;
+    onstalled: (ev: Event) => any;
+    onmousemove: (ev: MouseEvent) => any;
+    style: MSStyleCSSProperties;
+    isContentEditable: boolean;
+    onbeforeeditfocus: (ev: MSEventObj) => any;
+    onratechange: (ev: Event) => any;
+    contentEditable: string;
+    tabIndex: number;
+    document: Document;
+    onprogress: (ev: any) => any;
+    ondblclick: (ev: MouseEvent) => any;
+    oncontextmenu: (ev: MouseEvent) => any;
+    onloadedmetadata: (ev: Event) => any;
+    onafterupdate: (ev: MSEventObj) => any;
+    onerror: (ev: Event) => any;
+    onplay: (ev: Event) => any;
+    onresizeend: (ev: MSEventObj) => any;
+    onplaying: (ev: Event) => any;
+    isMultiLine: boolean;
+    onfocusout: (ev: FocusEvent) => any;
+    onabort: (ev: UIEvent) => any;
+    ondataavailable: (ev: MSEventObj) => any;
+    hideFocus: boolean;
+    onreadystatechange: (ev: Event) => any;
+    onkeypress: (ev: KeyboardEvent) => any;
+    onloadeddata: (ev: Event) => any;
+    onbeforedeactivate: (ev: UIEvent) => any;
+    outerText: string;
+    disabled: boolean;
+    onactivate: (ev: UIEvent) => any;
+    accessKey: string;
+    onmovestart: (ev: MSEventObj) => any;
+    onselectstart: (ev: Event) => any;
+    onfocus: (ev: FocusEvent) => any;
+    ontimeupdate: (ev: Event) => any;
+    onresize: (ev: UIEvent) => any;
+    oncut: (ev: DragEvent) => any;
+    onselect: (ev: UIEvent) => any;
+    ondrop: (ev: DragEvent) => any;
+    offsetWidth: number;
+    oncopy: (ev: DragEvent) => any;
+    onended: (ev: Event) => any;
+    onscroll: (ev: UIEvent) => any;
+    onrowenter: (ev: MSEventObj) => any;
+    onload: (ev: Event) => any;
+    canHaveChildren: boolean;
+    oninput: (ev: Event) => any;
+    dragDrop(): boolean;
+    scrollIntoView(top?: boolean): void;
+    addFilter(filter: Object): void;
+    setCapture(containerCapture?: boolean): void;
+    focus(): void;
+    getAdjacentText(where: string): string;
+    insertAdjacentText(where: string, text: string): void;
+    getElementsByClassName(classNames: string): NodeList;
+    setActive(): void;
+    removeFilter(filter: Object): void;
+    blur(): void;
+    clearAttributes(): void;
+    releaseCapture(): void;
+    createControlRange(): ControlRangeCollection;
+    removeBehavior(cookie: number): boolean;
+    contains(child: HTMLElement): boolean;
+    click(): void;
+    insertAdjacentElement(position: string, insertedElement: Element): Element;
+    mergeAttributes(source: HTMLElement, preserveIdentity?: boolean): void;
+    replaceAdjacentText(where: string, newText: string): string;
+    applyElement(apply: Element, where?: string): Element;
+    addBehavior(bstrUrl: string, factory?: any): number;
+    insertAdjacentHTML(where: string, html: string): void;
+}
+declare var HTMLElement: {
+    prototype: HTMLElement;
+    new (): HTMLElement;
+}
+
+interface Comment extends CharacterData {
+    text: string;
+}
+declare var Comment: {
+    prototype: Comment;
+    new (): Comment;
+}
+
+interface PerformanceResourceTiming extends PerformanceEntry {
+    redirectStart: number;
+    redirectEnd: number;
+    domainLookupEnd: number;
+    responseStart: number;
+    domainLookupStart: number;
+    fetchStart: number;
+    requestStart: number;
+    connectEnd: number;
+    connectStart: number;
+    initiatorType: string;
+    responseEnd: number;
+}
+declare var PerformanceResourceTiming: {
+    prototype: PerformanceResourceTiming;
+    new (): PerformanceResourceTiming;
+}
+
+interface CanvasPattern {
+}
+declare var CanvasPattern: {
+    prototype: CanvasPattern;
+    new (): CanvasPattern;
+}
+
+interface HTMLHRElement extends HTMLElement, DOML2DeprecatedColorProperty, DOML2DeprecatedSizeProperty {
+    /**
+      * Sets or retrieves the width of the object.
+      */
+    width: number;
+    /**
+      * Sets or retrieves how the object is aligned with adjacent text.
+      */
+    align: string;
+    /**
+      * Sets or retrieves whether the horizontal rule is drawn with 3-D shading.
+      */
+    noShade: boolean;
+}
+declare var HTMLHRElement: {
+    prototype: HTMLHRElement;
+    new (): HTMLHRElement;
+}
+
+interface HTMLObjectElement extends HTMLElement, GetSVGDocument, DOML2DeprecatedMarginStyle, DOML2DeprecatedBorderStyle, DOML2DeprecatedAlignmentStyle, MSDataBindingExtensions, MSDataBindingRecordSetExtensions {
+    /**
+      * Sets or retrieves the width of the object.
+      */
+    width: string;
+    /**
+      * Sets or retrieves the Internet media type for the code associated with the object.
+      */
+    codeType: string;
+    /**
+      * Retrieves the contained object.
+      */
+    object: Object;
+    /**
+      * Retrieves a reference to the form that the object is embedded in.
+      */
+    form: HTMLFormElement;
+    /**
+      * Sets or retrieves the URL of the file containing the compiled Java class.
+      */
+    code: string;
+    /**
+      * Sets or retrieves a character string that can be used to implement your own archive functionality for the object.
+      */
+    archive: string;
+    /**
+      * Sets or retrieves a message to be displayed while an object is loading.
+      */
+    standby: string;
+    /**
+      * Sets or retrieves a text alternative to the graphic.
+      */
+    alt: string;
+    /**
+      * Sets or retrieves the class identifier for the object.
+      */
+    classid: string;
+    /**
+      * Sets or retrieves the name of the object.
+      */
+    name: string;
+    /**
+      * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map.
+      */
+    useMap: string;
+    /**
+      * Sets or retrieves the URL that references the data of the object.
+      */
+    data: string;
+    /**
+      * Sets or retrieves the height of the object.
+      */
+    height: string;
+    /**
+      * Retrieves the document object of the page or frame.
+      */
+    contentDocument: Document;
+    /**
+      * Gets or sets the optional alternative HTML script to execute if the object fails to load.
+      */
+    altHtml: string;
+    /**
+      * Sets or retrieves the URL of the component.
+      */
+    codeBase: string;
+    declare: boolean;
+    /**
+      * Sets or retrieves the MIME type of the object.
+      */
+    type: string;
+    /**
+      * Retrieves a string of the URL where the object tag can be found. This is often the href of the document that the object is in, or the value set by a base element.
+      */
+    BaseHref: string;
+}
+declare var HTMLObjectElement: {
+    prototype: HTMLObjectElement;
+    new (): HTMLObjectElement;
+}
+
+interface HTMLEmbedElement extends HTMLElement, GetSVGDocument {
+    /**
+      * Sets or retrieves the width of the object.
+      */
+    width: string;
+    /**
+      * Retrieves the palette used for the embedded document.
+      */
+    palette: string;
+    /**
+      * Sets or retrieves a URL to be loaded by the object.
+      */
+    src: string;
+    /**
+      * Sets or retrieves the name of the object.
+      */
+    name: string;
+    /**
+      * Retrieves the URL of the plug-in used to view an embedded document.
+      */
+    pluginspage: string;
+    /**
+      * Sets or retrieves the height of the object.
+      */
+    height: string;
+    /**
+      * Sets or retrieves the height and width units of the embed object.
+      */
+    units: string;
+}
+declare var HTMLEmbedElement: {
+    prototype: HTMLEmbedElement;
+    new (): HTMLEmbedElement;
+}
+
+interface StorageEvent extends Event {
+    oldValue: any;
+    newValue: any;
+    url: string;
+    storageArea: Storage;
+    key: string;
+    initStorageEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, keyArg: string, oldValueArg: any, newValueArg: any, urlArg: string, storageAreaArg: Storage): void;
+}
+declare var StorageEvent: {
+    prototype: StorageEvent;
+    new (): StorageEvent;
+}
+
+interface CharacterData extends Node {
+    length: number;
+    data: string;
+    deleteData(offset: number, count: number): void;
+    replaceData(offset: number, count: number, arg: string): void;
+    appendData(arg: string): void;
+    insertData(offset: number, arg: string): void;
+    substringData(offset: number, count: number): string;
+}
+declare var CharacterData: {
+    prototype: CharacterData;
+    new (): CharacterData;
+}
+
+interface HTMLOptGroupElement extends HTMLElement, MSDataBindingExtensions {
+    /**
+      * Sets or retrieves the ordinal position of an option in a list box.
+      */
+    index: number;
+    /**
+      * Sets or retrieves the status of an option.
+      */
+    defaultSelected: boolean;
+    /**
+      * Sets or retrieves the text string specified by the option tag.
+      */
+    text: string;
+    /**
+      * Sets or retrieves the value which is returned to the server when the form control is submitted.
+      */
+    value: string;
+    /**
+      * Retrieves a reference to the form that the object is embedded in.
+      */
+    form: HTMLFormElement;
+    /**
+      * Sets or retrieves a value that you can use to implement your own label functionality for the object.
+      */
+    label: string;
+    /**
+      * Sets or retrieves whether the option in the list box is the default item.
+      */
+    selected: boolean;
+}
+declare var HTMLOptGroupElement: {
+    prototype: HTMLOptGroupElement;
+    new (): HTMLOptGroupElement;
+}
+
+interface HTMLIsIndexElement extends HTMLElement {
+    /**
+      * Retrieves a reference to the form that the object is embedded in. 
+      */
+    form: HTMLFormElement;
+    /**
+      * Sets or retrieves the URL to which the form content is sent for processing.
+      */
+    action: string;
+    prompt: string;
+}
+declare var HTMLIsIndexElement: {
+    prototype: HTMLIsIndexElement;
+    new (): HTMLIsIndexElement;
+}
+
+interface SVGPathSegLinetoRel extends SVGPathSeg {
+    y: number;
+    x: number;
+}
+declare var SVGPathSegLinetoRel: {
+    prototype: SVGPathSegLinetoRel;
+    new (): SVGPathSegLinetoRel;
+}
+
+interface DOMException {
+    code: number;
+    message: string;
+    toString(): string;
+    HIERARCHY_REQUEST_ERR: number;
+    NO_MODIFICATION_ALLOWED_ERR: number;
+    INVALID_MODIFICATION_ERR: number;
+    NAMESPACE_ERR: number;
+    INVALID_CHARACTER_ERR: number;
+    TYPE_MISMATCH_ERR: number;
+    ABORT_ERR: number;
+    INVALID_STATE_ERR: number;
+    SECURITY_ERR: number;
+    NETWORK_ERR: number;
+    WRONG_DOCUMENT_ERR: number;
+    QUOTA_EXCEEDED_ERR: number;
+    INDEX_SIZE_ERR: number;
+    DOMSTRING_SIZE_ERR: number;
+    SYNTAX_ERR: number;
+    SERIALIZE_ERR: number;
+    VALIDATION_ERR: number;
+    NOT_FOUND_ERR: number;
+    URL_MISMATCH_ERR: number;
+    PARSE_ERR: number;
+    NO_DATA_ALLOWED_ERR: number;
+    NOT_SUPPORTED_ERR: number;
+    INVALID_ACCESS_ERR: number;
+    INUSE_ATTRIBUTE_ERR: number;
+}
+declare var DOMException: {
+    prototype: DOMException;
+    new (): DOMException;
+    HIERARCHY_REQUEST_ERR: number;
+    NO_MODIFICATION_ALLOWED_ERR: number;
+    INVALID_MODIFICATION_ERR: number;
+    NAMESPACE_ERR: number;
+    INVALID_CHARACTER_ERR: number;
+    TYPE_MISMATCH_ERR: number;
+    ABORT_ERR: number;
+    INVALID_STATE_ERR: number;
+    SECURITY_ERR: number;
+    NETWORK_ERR: number;
+    WRONG_DOCUMENT_ERR: number;
+    QUOTA_EXCEEDED_ERR: number;
+    INDEX_SIZE_ERR: number;
+    DOMSTRING_SIZE_ERR: number;
+    SYNTAX_ERR: number;
+    SERIALIZE_ERR: number;
+    VALIDATION_ERR: number;
+    NOT_FOUND_ERR: number;
+    URL_MISMATCH_ERR: number;
+    PARSE_ERR: number;
+    NO_DATA_ALLOWED_ERR: number;
+    NOT_SUPPORTED_ERR: number;
+    INVALID_ACCESS_ERR: number;
+    INUSE_ATTRIBUTE_ERR: number;
+}
+
+interface SVGAnimatedBoolean {
+    animVal: boolean;
+    baseVal: boolean;
+}
+declare var SVGAnimatedBoolean: {
+    prototype: SVGAnimatedBoolean;
+    new (): SVGAnimatedBoolean;
+}
+
+interface MSCompatibleInfoCollection {
+    length: number;
+    item(index: number): MSCompatibleInfo;
+}
+declare var MSCompatibleInfoCollection: {
+    prototype: MSCompatibleInfoCollection;
+    new (): MSCompatibleInfoCollection;
+}
+
+interface SVGSwitchElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired {
+}
+declare var SVGSwitchElement: {
+    prototype: SVGSwitchElement;
+    new (): SVGSwitchElement;
+}
+
+interface SVGPreserveAspectRatio {
+    align: number;
+    meetOrSlice: number;
+    SVG_PRESERVEASPECTRATIO_NONE: number;
+    SVG_PRESERVEASPECTRATIO_XMINYMID: number;
+    SVG_PRESERVEASPECTRATIO_XMAXYMIN: number;
+    SVG_PRESERVEASPECTRATIO_XMINYMAX: number;
+    SVG_PRESERVEASPECTRATIO_XMAXYMAX: number;
+    SVG_MEETORSLICE_UNKNOWN: number;
+    SVG_PRESERVEASPECTRATIO_XMAXYMID: number;
+    SVG_PRESERVEASPECTRATIO_XMIDYMAX: number;
+    SVG_PRESERVEASPECTRATIO_XMINYMIN: number;
+    SVG_MEETORSLICE_MEET: number;
+    SVG_PRESERVEASPECTRATIO_XMIDYMID: number;
+    SVG_PRESERVEASPECTRATIO_XMIDYMIN: number;
+    SVG_MEETORSLICE_SLICE: number;
+    SVG_PRESERVEASPECTRATIO_UNKNOWN: number;
+}
+declare var SVGPreserveAspectRatio: {
+    prototype: SVGPreserveAspectRatio;
+    new (): SVGPreserveAspectRatio;
+    SVG_PRESERVEASPECTRATIO_NONE: number;
+    SVG_PRESERVEASPECTRATIO_XMINYMID: number;
+    SVG_PRESERVEASPECTRATIO_XMAXYMIN: number;
+    SVG_PRESERVEASPECTRATIO_XMINYMAX: number;
+    SVG_PRESERVEASPECTRATIO_XMAXYMAX: number;
+    SVG_MEETORSLICE_UNKNOWN: number;
+    SVG_PRESERVEASPECTRATIO_XMAXYMID: number;
+    SVG_PRESERVEASPECTRATIO_XMIDYMAX: number;
+    SVG_PRESERVEASPECTRATIO_XMINYMIN: number;
+    SVG_MEETORSLICE_MEET: number;
+    SVG_PRESERVEASPECTRATIO_XMIDYMID: number;
+    SVG_PRESERVEASPECTRATIO_XMIDYMIN: number;
+    SVG_MEETORSLICE_SLICE: number;
+    SVG_PRESERVEASPECTRATIO_UNKNOWN: number;
+}
+
+interface Attr extends Node {
+    expando: boolean;
+    specified: boolean;
+    ownerElement: Element;
+    value: string;
+    name: string;
+}
+declare var Attr: {
+    prototype: Attr;
+    new (): Attr;
+}
+
+interface PerformanceNavigation {
+    redirectCount: number;
+    type: number;
+    toJSON(): any;
+    TYPE_RELOAD: number;
+    TYPE_RESERVED: number;
+    TYPE_BACK_FORWARD: number;
+    TYPE_NAVIGATE: number;
+}
+declare var PerformanceNavigation: {
+    prototype: PerformanceNavigation;
+    new (): PerformanceNavigation;
+    TYPE_RELOAD: number;
+    TYPE_RESERVED: number;
+    TYPE_BACK_FORWARD: number;
+    TYPE_NAVIGATE: number;
+}
+
+interface SVGStopElement extends SVGElement, SVGStylable {
+    offset: SVGAnimatedNumber;
+}
+declare var SVGStopElement: {
+    prototype: SVGStopElement;
+    new (): SVGStopElement;
+}
+
+interface PositionCallback {
+    (position: Position): void;
+}
+
+interface SVGSymbolElement extends SVGElement, SVGStylable, SVGLangSpace, SVGFitToViewBox, SVGExternalResourcesRequired {
+}
+declare var SVGSymbolElement: {
+    prototype: SVGSymbolElement;
+    new (): SVGSymbolElement;
+}
+
+interface SVGElementInstanceList {
+    length: number;
+    item(index: number): SVGElementInstance;
+}
+declare var SVGElementInstanceList: {
+    prototype: SVGElementInstanceList;
+    new (): SVGElementInstanceList;
+}
+
+interface CSSRuleList {
+    length: number;
+    item(index: number): CSSRule;
+    [index: number]: CSSRule;
+}
+declare var CSSRuleList: {
+    prototype: CSSRuleList;
+    new (): CSSRuleList;
+}
+
+interface MSDataBindingRecordSetExtensions {
+    recordset: Object;
+    namedRecordset(dataMember: string, hierarchy?: any): Object;
+}
+
+interface LinkStyle {
+    styleSheet: StyleSheet;
+    sheet: StyleSheet;
+}
+
+interface HTMLVideoElement extends HTMLMediaElement {
+    /**
+      * Gets or sets the width of the video element.
+      */
+    width: number;
+    /**
+      * Gets the intrinsic width of a video in CSS pixels, or zero if the dimensions are not known.
+      */
+    videoWidth: number;
+    /**
+      * Gets the intrinsic height of a video in CSS pixels, or zero if the dimensions are not known.
+      */
+    videoHeight: number;
+    /**
+      * Gets or sets the height of the video element.
+      */
+    height: number;
+    /**
+      * Gets or sets a URL of an image to display, for example, like a movie poster. This can be a still frame from the video, or another image if no video data is available.
+      */
+    poster: string;
+}
+declare var HTMLVideoElement: {
+    prototype: HTMLVideoElement;
+    new (): HTMLVideoElement;
+}
+
+interface ClientRectList {
+    length: number;
+    item(index: number): ClientRect;
+    [index: number]: ClientRect;
+}
+declare var ClientRectList: {
+    prototype: ClientRectList;
+    new (): ClientRectList;
+}
+
+interface SVGMaskElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired {
+    y: SVGAnimatedLength;
+    width: SVGAnimatedLength;
+    maskUnits: SVGAnimatedEnumeration;
+    maskContentUnits: SVGAnimatedEnumeration;
+    x: SVGAnimatedLength;
+    height: SVGAnimatedLength;
+}
+declare var SVGMaskElement: {
+    prototype: SVGMaskElement;
+    new (): SVGMaskElement;
+}
+
+interface External {
+}
+declare var External: {
+    prototype: External;
+    new (): External;
+}
+
+declare var Audio: { new (src?: string): HTMLAudioElement; };
+declare var Option: { new (text?: string, value?: string, defaultSelected?: boolean, selected?: boolean): HTMLOptionElement; };
+declare var Image: { new (width?: number, height?: number): HTMLImageElement; };
+
+declare var ondragend: (ev: DragEvent) => any;
+declare var onkeydown: (ev: KeyboardEvent) => any;
+declare var ondragover: (ev: DragEvent) => any;
+declare var onkeyup: (ev: KeyboardEvent) => any;
+declare var onreset: (ev: Event) => any;
+declare var onmouseup: (ev: MouseEvent) => any;
+declare var ondragstart: (ev: DragEvent) => any;
+declare var ondrag: (ev: DragEvent) => any;
+declare var screenX: number;
+declare var onmouseover: (ev: MouseEvent) => any;
+declare var ondragleave: (ev: DragEvent) => any;
+declare var history: History;
+declare var pageXOffset: number;
+declare var name: string;
+declare var onafterprint: (ev: Event) => any;
+declare var onpause: (ev: Event) => any;
+declare var onbeforeprint: (ev: Event) => any;
+declare var top: Window;
+declare var onmousedown: (ev: MouseEvent) => any;
+declare var onseeked: (ev: Event) => any;
+declare var opener: Window;
+declare var onclick: (ev: MouseEvent) => any;
+declare var innerHeight: number;
+declare var onwaiting: (ev: Event) => any;
+declare var ononline: (ev: Event) => any;
+declare var ondurationchange: (ev: Event) => any;
+declare var frames: Window;
+declare var onblur: (ev: FocusEvent) => any;
+declare var onemptied: (ev: Event) => any;
+declare var onseeking: (ev: Event) => any;
+declare var oncanplay: (ev: Event) => any;
+declare var outerWidth: number;
+declare var onstalled: (ev: Event) => any;
+declare var onmousemove: (ev: MouseEvent) => any;
+declare var innerWidth: number;
+declare var onoffline: (ev: Event) => any;
+declare var length: number;
+declare var screen: Screen;
+declare var onbeforeunload: (ev: BeforeUnloadEvent) => any;
+declare var onratechange: (ev: Event) => any;
+declare var onstorage: (ev: StorageEvent) => any;
+declare var onloadstart: (ev: Event) => any;
+declare var ondragenter: (ev: DragEvent) => any;
+declare var onsubmit: (ev: Event) => any;
+declare var self: Window;
+declare var document: Document;
+declare var onprogress: (ev: any) => any;
+declare var ondblclick: (ev: MouseEvent) => any;
+declare var pageYOffset: number;
+declare var oncontextmenu: (ev: MouseEvent) => any;
+declare var onchange: (ev: Event) => any;
+declare var onloadedmetadata: (ev: Event) => any;
+declare var onplay: (ev: Event) => any;
+declare var onerror: ErrorEventHandler;
+declare var onplaying: (ev: Event) => any;
+declare var parent: Window;
+declare var location: Location;
+declare var oncanplaythrough: (ev: Event) => any;
+declare var onabort: (ev: UIEvent) => any;
+declare var onreadystatechange: (ev: Event) => any;
+declare var outerHeight: number;
+declare var onkeypress: (ev: KeyboardEvent) => any;
+declare var frameElement: Element;
+declare var onloadeddata: (ev: Event) => any;
+declare var onsuspend: (ev: Event) => any;
+declare var window: Window;
+declare var onfocus: (ev: FocusEvent) => any;
+declare var onmessage: (ev: MessageEvent) => any;
+declare var ontimeupdate: (ev: Event) => any;
+declare var onresize: (ev: UIEvent) => any;
+declare var onselect: (ev: UIEvent) => any;
+declare var navigator: Navigator;
+declare var styleMedia: StyleMedia;
+declare var ondrop: (ev: DragEvent) => any;
+declare var onmouseout: (ev: MouseEvent) => any;
+declare var onended: (ev: Event) => any;
+declare var onhashchange: (ev: Event) => any;
+declare var onunload: (ev: Event) => any;
+declare var onscroll: (ev: UIEvent) => any;
+declare var screenY: number;
+declare var onmousewheel: (ev: MouseWheelEvent) => any;
+declare var onload: (ev: Event) => any;
+declare var onvolumechange: (ev: Event) => any;
+declare var oninput: (ev: Event) => any;
+declare var performance: Performance;
+declare function alert(message?: any): void;
+declare function scroll(x?: number, y?: number): void;
+declare function focus(): void;
+declare function scrollTo(x?: number, y?: number): void;
+declare function print(): void;
+declare function prompt(message?: string, defaul?: string): string;
+declare function toString(): string;
+declare function open(url?: string, target?: string, features?: string, replace?: boolean): Window;
+declare function scrollBy(x?: number, y?: number): void;
+declare function confirm(message?: string): boolean;
+declare function close(): void;
+declare function postMessage(message: any, targetOrigin: string, ports?: any): void;
+declare function showModalDialog(url?: string, argument?: any, options?: any): any;
+declare function blur(): void;
+declare function getSelection(): Selection;
+declare function getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration;
+declare function removeEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+declare function dispatchEvent(evt: Event): boolean;
+declare function attachEvent(event: string, listener: EventListener): boolean;
+declare function detachEvent(event: string, listener: EventListener): void;
+declare var localStorage: Storage;
+declare var status: string;
+declare var onmouseleave: (ev: MouseEvent) => any;
+declare var screenLeft: number;
+declare var offscreenBuffering: any;
+declare var maxConnectionsPerServer: number;
+declare var onmouseenter: (ev: MouseEvent) => any;
+declare var clipboardData: DataTransfer;
+declare var defaultStatus: string;
+declare var clientInformation: Navigator;
+declare var closed: boolean;
+declare var onhelp: (ev: Event) => any;
+declare var external: External;
+declare var event: MSEventObj;
+declare var onfocusout: (ev: FocusEvent) => any;
+declare var screenTop: number;
+declare var onfocusin: (ev: FocusEvent) => any;
+declare function showModelessDialog(url?: string, argument?: any, options?: any): Window;
+declare function navigate(url: string): void;
+declare function resizeBy(x?: number, y?: number): void;
+declare function item(index: any): any;
+declare function resizeTo(x?: number, y?: number): void;
+declare function createPopup(arguments?: any): MSPopupWindow;
+declare function toStaticHTML(html: string): string;
+declare function execScript(code: string, language?: string): any;
+declare function msWriteProfilerMark(profilerMarkName: string): void;
+declare function moveTo(x?: number, y?: number): void;
+declare function moveBy(x?: number, y?: number): void;
+declare function showHelp(url: string, helpArg?: any, features?: string): void;
+declare var sessionStorage: Storage;
+declare function clearTimeout(handle: number): void;
+declare function setTimeout(handler: any, timeout?: any, ...args: any[]): number;
+declare function clearInterval(handle: number): void;
+declare function setInterval(handler: any, timeout?: any, ...args: any[]): number;
+
+
+/////////////////////////////
+/// IE10 DOM APIs 
+/////////////////////////////
+
+
+interface ObjectURLOptions {
+    oneTimeOnly?: boolean;
+}
+
+interface HTMLBodyElement {
+    onpopstate: (ev: PopStateEvent) => any;
+}
+
+interface MSGestureEvent extends UIEvent {
+    offsetY: number;
+    translationY: number;
+    velocityExpansion: number;
+    velocityY: number;
+    velocityAngular: number;
+    translationX: number;
+    velocityX: number;
+    hwTimestamp: number;
+    offsetX: number;
+    screenX: number;
+    rotation: number;
+    expansion: number;
+    clientY: number;
+    screenY: number;
+    scale: number;
+    gestureObject: any;
+    clientX: number;
+    initGestureEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, offsetXArg: number, offsetYArg: number, translationXArg: number, translationYArg: number, scaleArg: number, expansionArg: number, rotationArg: number, velocityXArg: number, velocityYArg: number, velocityExpansionArg: number, velocityAngularArg: number, hwTimestampArg: number): void;
+    MSGESTURE_FLAG_BEGIN: number;
+    MSGESTURE_FLAG_END: number;
+    MSGESTURE_FLAG_CANCEL: number;
+    MSGESTURE_FLAG_INERTIA: number;
+    MSGESTURE_FLAG_NONE: number;
+}
+declare var MSGestureEvent: {
+    MSGESTURE_FLAG_BEGIN: number;
+    MSGESTURE_FLAG_END: number;
+    MSGESTURE_FLAG_CANCEL: number;
+    MSGESTURE_FLAG_INERTIA: number;
+    MSGESTURE_FLAG_NONE: number;
+}
+
+interface HTMLAnchorElement {
+    /**
+      * Retrieves or sets the text of the object as a string. 
+      */
+    text: string;
+}
+
+interface HTMLInputElement {
+    /**
+      * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
+      */
+    validationMessage: string;
+    /**
+      * Returns a FileList object on a file type input object.
+      */
+    files: FileList;
+    /**
+      * Defines the maximum acceptable value for an input element with type="number".When used with the min and step attributes, lets you control the range and increment (such as only even numbers) that the user can enter into an input field.
+      */
+    max: string;
+    /**
+      * Overrides the target attribute on a form element.
+      */
+    formTarget: string;
+    /**
+      * Returns whether an element will successfully validate based on forms validation rules and constraints.
+      */
+    willValidate: boolean;
+    /**
+      * Defines an increment or jump between values that you want to allow the user to enter. When used with the max and min attributes, lets you control the range and increment (for example, allow only even numbers) that the user can enter into an input field.
+      */
+    step: string;
+    /**
+      * Provides a way to direct a user to a specific field when a document loads. This can provide both direction and convenience for a user, reducing the need to click or tab to a field when a page opens. This attribute is true when present on an element, and false when missing.
+      */
+    autofocus: boolean;
+    /**
+      * When present, marks an element that can't be submitted without a value.
+      */
+    required: boolean;
+    /**
+      * Used to override the encoding (formEnctype attribute) specified on the form element.
+      */
+    formEnctype: string;
+    /**
+      * Returns the input field value as a number.
+      */
+    valueAsNumber: number;
+    /**
+      * Gets or sets a text string that is displayed in an input field as a hint or prompt to users as the format or type of information they need to enter.The text appears in an input field until the user puts focus on the field.
+      */
+    placeholder: string;
+    /**
+      * Overrides the submit method attribute previously specified on a form element.
+      */
+    formMethod: string;
+    /**
+      * Specifies the ID of a pre-defined datalist of options for an input element.
+      */
+    list: HTMLElement;
+    /**
+      * Specifies whether autocomplete is applied to an editable text field.
+      */
+    autocomplete: string;
+    /**
+      * Defines the minimum acceptable value for an input element with type="number". When used with the max and step attributes, lets you control the range and increment (such as even numbers only) that the user can enter into an input field.
+      */
+    min: string;
+    /**
+      * Overrides the action attribute (where the data on a form is sent) on the parent form element.
+      */
+    formAction: string;
+    /**
+      * Gets or sets a string containing a regular expression that the user's input must match.
+      */
+    pattern: string;
+    /**
+      * Returns a  ValidityState object that represents the validity states of an element.
+      */
+    validity: ValidityState;
+    /**
+      * Overrides any validation or required attributes on a form or form elements to allow it to be submitted without validation. This can be used to create a "save draft"-type submit option.
+      */
+    formNoValidate: string;
+    /**
+      * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list.
+      */
+    multiple: boolean;
+    /**
+      * Returns whether a form will validate when it is submitted, without having to submit it.
+      */
+    checkValidity(): boolean;
+    /**
+      * Decrements a range input control's value by the value given by the Step attribute. If the optional parameter is used, it will decrement the input control's step value multiplied by the parameter's value.
+      * @param n Value to decrement the value by.
+      */
+    stepDown(n?: number): void;
+    /**
+      * Increments a range input control's value by the value given by the Step attribute. If the optional parameter is used, will increment the input control's value by that value.
+      * @param n Value to increment the value by.
+      */
+    stepUp(n?: number): void;
+    /**
+      * Sets a custom error message that is displayed when a form is submitted.
+      * @param error Sets a custom error message that is displayed when a form is submitted.
+      */
+    setCustomValidity(error: string): void;
+}
+
+interface ErrorEvent extends Event {
+    colno: number;
+    filename: string;
+    error: any;
+    lineno: number;
+    message: string;
+    initErrorEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, messageArg: string, filenameArg: string, linenoArg: number): void;
+}
+
+interface SVGFilterElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGLangSpace, SVGURIReference, SVGExternalResourcesRequired {
+    y: SVGAnimatedLength;
+    width: SVGAnimatedLength;
+    filterResX: SVGAnimatedInteger;
+    filterUnits: SVGAnimatedEnumeration;
+    primitiveUnits: SVGAnimatedEnumeration;
+    x: SVGAnimatedLength;
+    height: SVGAnimatedLength;
+    filterResY: SVGAnimatedInteger;
+    setFilterRes(filterResX: number, filterResY: number): void;
+}
+
+interface TrackEvent extends Event {
+    track: any;
+}
+
+interface SVGFEMergeNodeElement extends SVGElement {
+    in1: SVGAnimatedString;
+}
+
+interface SVGFEFloodElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+}
+
+interface MSGesture {
+    target: Element;
+    addPointer(pointerId: number): void;
+    stop(): void;
+}
+declare var MSGesture: {
+    prototype: MSGesture;
+    new (): MSGesture;
+}
+
+interface TextTrackCue extends EventTarget {
+    onenter: (ev: Event) => any;
+    track: TextTrack;
+    endTime: number;
+    text: string;
+    pauseOnExit: boolean;
+    id: string;
+    startTime: number;
+    onexit: (ev: Event) => any;
+    getCueAsHTML(): DocumentFragment;
+}
+declare var TextTrackCue: {
+    prototype: TextTrackCue;
+    new (): TextTrackCue;
+}
+
+interface MSStreamReader extends MSBaseReader {
+    error: DOMError;
+    readAsArrayBuffer(stream: MSStream, size?: number): void;
+    readAsBlob(stream: MSStream, size?: number): void;
+    readAsDataURL(stream: MSStream, size?: number): void;
+    readAsText(stream: MSStream, encoding?: string, size?: number): void;
+}
+declare var MSStreamReader: {
+    prototype: MSStreamReader;
+    new (): MSStreamReader;
+}
+
+interface DOMTokenList {
+    length: number;
+    contains(token: string): boolean;
+    remove(token: string): void;
+    toggle(token: string): boolean;
+    add(token: string): void;
+    item(index: number): string;
+    [index: number]: string;
+    toString(): string;
+}
+
+interface EventException {
+    name: string;
+}
+
+interface Performance {
+    now(): number;
+}
+
+interface SVGFEFuncAElement extends SVGComponentTransferFunctionElement {
+}
+
+interface SVGFETileElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+    in1: SVGAnimatedString;
+}
+
+interface SVGFEBlendElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+    in2: SVGAnimatedString;
+    mode: SVGAnimatedEnumeration;
+    in1: SVGAnimatedString;
+    SVG_FEBLEND_MODE_DARKEN: number;
+    SVG_FEBLEND_MODE_UNKNOWN: number;
+    SVG_FEBLEND_MODE_MULTIPLY: number;
+    SVG_FEBLEND_MODE_NORMAL: number;
+    SVG_FEBLEND_MODE_SCREEN: number;
+    SVG_FEBLEND_MODE_LIGHTEN: number;
+}
+declare var SVGFEBlendElement: {
+    SVG_FEBLEND_MODE_DARKEN: number;
+    SVG_FEBLEND_MODE_UNKNOWN: number;
+    SVG_FEBLEND_MODE_MULTIPLY: number;
+    SVG_FEBLEND_MODE_NORMAL: number;
+    SVG_FEBLEND_MODE_SCREEN: number;
+    SVG_FEBLEND_MODE_LIGHTEN: number;
+}
+
+interface WindowTimers extends WindowTimersExtension {
+}
+
+interface CSSStyleDeclaration {
+    animationFillMode: string;
+    floodColor: string;
+    animationIterationCount: string;
+    textShadow: string;
+    backfaceVisibility: string;
+    msAnimationIterationCount: string;
+    animationDelay: string;
+    animationTimingFunction: string;
+    columnWidth: any;
+    msScrollSnapX: string;
+    columnRuleColor: any;
+    columnRuleWidth: any;
+    transitionDelay: string;
+    transition: string;
+    msFlowFrom: string;
+    msScrollSnapType: string;
+    msContentZoomSnapType: string;
+    msGridColumns: string;
+    msAnimationName: string;
+    msGridRowAlign: string;
+    msContentZoomChaining: string;
+    msGridColumn: any;
+    msHyphenateLimitZone: any;
+    msScrollRails: string;
+    msAnimationDelay: string;
+    enableBackground: string;
+    msWrapThrough: string;
+    columnRuleStyle: string;
+    msAnimation: string;
+    msFlexFlow: string;
+    msScrollSnapY: string;
+    msHyphenateLimitLines: any;
+    msTouchAction: string;
+    msScrollLimit: string;
+    animation: string;
+    transform: string;
+    filter: string;
+    colorInterpolationFilters: string;
+    transitionTimingFunction: string;
+    msBackfaceVisibility: string;
+    animationPlayState: string;
+    transformOrigin: string;
+    msScrollLimitYMin: any;
+    msFontFeatureSettings: string;
+    msContentZoomLimitMin: any;
+    columnGap: any;
+    transitionProperty: string;
+    msAnimationDuration: string;
+    msAnimationFillMode: string;
+    msFlexDirection: string;
+    msTransitionDuration: string;
+    fontFeatureSettings: string;
+    breakBefore: string;
+    msFlexWrap: string;
+    perspective: string;
+    msFlowInto: string;
+    msTransformStyle: string;
+    msScrollTranslation: string;
+    msTransitionProperty: string;
+    msUserSelect: string;
+    msOverflowStyle: string;
+    msScrollSnapPointsY: string;
+    animationDirection: string;
+    animationDuration: string;
+    msFlex: string;
+    msTransitionTimingFunction: string;
+    animationName: string;
+    columnRule: string;
+    msGridColumnSpan: any;
+    msFlexNegative: string;
+    columnFill: string;
+    msGridRow: any;
+    msFlexOrder: string;
+    msFlexItemAlign: string;
+    msFlexPositive: string;
+    msContentZoomLimitMax: any;
+    msScrollLimitYMax: any;
+    msGridColumnAlign: string;
+    perspectiveOrigin: string;
+    lightingColor: string;
+    columns: string;
+    msScrollChaining: string;
+    msHyphenateLimitChars: string;
+    msTouchSelect: string;
+    floodOpacity: string;
+    msAnimationDirection: string;
+    msAnimationPlayState: string;
+    columnSpan: string;
+    msContentZooming: string;
+    msPerspective: string;
+    msFlexPack: string;
+    msScrollSnapPointsX: string;
+    msContentZoomSnapPoints: string;
+    msGridRowSpan: any;
+    msContentZoomSnap: string;
+    msScrollLimitXMin: any;
+    breakInside: string;
+    msHighContrastAdjust: string;
+    msFlexLinePack: string;
+    msGridRows: string;
+    transitionDuration: string;
+    msHyphens: string;
+    breakAfter: string;
+    msTransition: string;
+    msPerspectiveOrigin: string;
+    msContentZoomLimit: string;
+    msScrollLimitXMax: any;
+    msFlexAlign: string;
+    msWrapMargin: any;
+    columnCount: any;
+    msAnimationTimingFunction: string;
+    msTransitionDelay: string;
+    transformStyle: string;
+    msWrapFlow: string;
+    msFlexPreferredSize: string;
+}
+
+interface MessageChannel {
+    port2: MessagePort;
+    port1: MessagePort;
+}
+declare var MessageChannel: {
+    prototype: MessageChannel;
+    new (): MessageChannel;
+}
+
+interface SVGFEMergeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+}
+
+interface Navigator extends MSFileSaver {
+    msMaxTouchPoints: number;
+    msPointerEnabled: boolean;
+    msManipulationViewsEnabled: boolean;
+    msLaunchUri(uri: string, successCallback?: MSLaunchUriCallback, noHandlerCallback?: MSLaunchUriCallback): void;
+}
+
+interface TransitionEvent extends Event {
+    propertyName: string;
+    elapsedTime: number;
+    initTransitionEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, propertyNameArg: string, elapsedTimeArg: number): void;
+}
+
+interface MediaQueryList {
+    matches: boolean;
+    media: string;
+    addListener(listener: MediaQueryListListener): void;
+    removeListener(listener: MediaQueryListListener): void;
+}
+
+interface DOMError {
+    name: string;
+    toString(): string;
+}
+
+interface CloseEvent extends Event {
+    wasClean: boolean;
+    reason: string;
+    code: number;
+    initCloseEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, wasCleanArg: boolean, codeArg: number, reasonArg: string): void;
+}
+
+interface WebSocket extends EventTarget {
+    protocol: string;
+    readyState: number;
+    bufferedAmount: number;
+    onopen: (ev: Event) => any;
+    extensions: string;
+    onmessage: (ev: any) => any;
+    onclose: (ev: CloseEvent) => any;
+    onerror: (ev: ErrorEvent) => any;
+    binaryType: string;
+    url: string;
+    close(code?: number, reason?: string): void;
+    send(data: any): void;
+    OPEN: number;
+    CLOSING: number;
+    CONNECTING: number;
+    CLOSED: number;
+}
+declare var WebSocket: {
+    prototype: WebSocket;
+    new (url: string): WebSocket;
+    new (url: string, prototcol: string): WebSocket;
+    new (url: string, prototcol: string[]): WebSocket;
+    OPEN: number;
+    CLOSING: number;
+    CONNECTING: number;
+    CLOSED: number;
+}
+
+interface SVGFEPointLightElement extends SVGElement {
+    y: SVGAnimatedNumber;
+    x: SVGAnimatedNumber;
+    z: SVGAnimatedNumber;
+}
+
+interface ProgressEvent extends Event {
+    loaded: number;
+    lengthComputable: boolean;
+    total: number;
+    initProgressEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, lengthComputableArg: boolean, loadedArg: number, totalArg: number): void;
+}
+
+interface IDBObjectStore {
+    indexNames: DOMStringList;
+    name: string;
+    transaction: IDBTransaction;
+    keyPath: string;
+    count(key?: any): IDBRequest;
+    add(value: any, key?: any): IDBRequest;
+    clear(): IDBRequest;
+    createIndex(name: string, keyPath: string, optionalParameters?: any): IDBIndex;
+    put(value: any, key?: any): IDBRequest;
+    openCursor(range?: any, direction?: string): IDBRequest;
+    deleteIndex(indexName: string): void;
+    index(name: string): IDBIndex;
+    get(key: any): IDBRequest;
+    delete(key: any): IDBRequest;
+}
+
+interface HTMLCanvasElement {
+    /**
+      * Returns a blob object encoded as a Portable Network Graphics (PNG) format from a canvas image or drawing.
+      */
+    msToBlob(): Blob;
+}
+
+interface SVGFEGaussianBlurElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+    stdDeviationX: SVGAnimatedNumber;
+    in1: SVGAnimatedString;
+    stdDeviationY: SVGAnimatedNumber;
+    setStdDeviation(stdDeviationX: number, stdDeviationY: number): void;
+}
+
+interface SVGFilterPrimitiveStandardAttributes extends SVGStylable {
+    y: SVGAnimatedLength;
+    width: SVGAnimatedLength;
+    x: SVGAnimatedLength;
+    height: SVGAnimatedLength;
+    result: SVGAnimatedString;
+}
+
+interface Element {
+    msRegionOverflow: string;
+    onmspointerdown: (ev: any) => any;
+    onmsgotpointercapture: (ev: any) => any;
+    onmsgesturedoubletap: (ev: any) => any;
+    onmspointerhover: (ev: any) => any;
+    onmsgesturehold: (ev: any) => any;
+    onmspointermove: (ev: any) => any;
+    onmsgesturechange: (ev: any) => any;
+    onmsgesturestart: (ev: any) => any;
+    onmspointercancel: (ev: any) => any;
+    onmsgestureend: (ev: any) => any;
+    onmsgesturetap: (ev: any) => any;
+    onmspointerout: (ev: any) => any;
+    onmsinertiastart: (ev: any) => any;
+    onmslostpointercapture: (ev: any) => any;
+    onmspointerover: (ev: any) => any;
+    msContentZoomFactor: number;
+    onmspointerup: (ev: any) => any;
+    msGetRegionContent(): MSRangeCollection;
+    msReleasePointerCapture(pointerId: number): void;
+    msSetPointerCapture(pointerId: number): void;
+}
+
+interface IDBVersionChangeEvent extends Event {
+    newVersion: number;
+    oldVersion: number;
+}
+
+interface IDBIndex {
+    unique: boolean;
+    name: string;
+    keyPath: string;
+    objectStore: IDBObjectStore;
+    count(key?: any): IDBRequest;
+    getKey(key: any): IDBRequest;
+    openKeyCursor(range?: IDBKeyRange, direction?: string): IDBRequest;
+    get(key: any): IDBRequest;
+    openCursor(range?: IDBKeyRange, direction?: string): IDBRequest;
+}
+
+interface WheelEvent {
+    getCurrentPoint(element: Element): void;
+}
+
+interface FileList {
+    length: number;
+    item(index: number): File;
+    [index: number]: File;
+}
+
+interface IDBCursor {
+    source: any;
+    direction: string;
+    key: any;
+    primaryKey: any;
+    advance(count: number): void;
+    delete(): IDBRequest;
+    continue(key?: any): void;
+    update(value: any): IDBRequest;
+}
+
+interface SVGFESpecularLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+    kernelUnitLengthY: SVGAnimatedNumber;
+    surfaceScale: SVGAnimatedNumber;
+    specularExponent: SVGAnimatedNumber;
+    in1: SVGAnimatedString;
+    kernelUnitLengthX: SVGAnimatedNumber;
+    specularConstant: SVGAnimatedNumber;
+}
+
+interface File extends Blob {
+    lastModifiedDate: any;
+    name: string;
+}
+
+interface URL {
+    revokeObjectURL(url: string): void;
+    createObjectURL(object: any, options?: ObjectURLOptions): string;
+}
+declare var URL: URL;
+
+interface RangeException {
+    name: string;
+}
+
+interface IDBCursorWithValue extends IDBCursor {
+    value: any;
+}
+
+interface HTMLTextAreaElement {
+    /**
+      * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
+      */
+    validationMessage: string;
+    /**
+      * Provides a way to direct a user to a specific field when a document loads. This can provide both direction and convenience for a user, reducing the need to click or tab to a field when a page opens. This attribute is true when present on an element, and false when missing.
+      */
+    autofocus: boolean;
+    /**
+      * Returns a  ValidityState object that represents the validity states of an element.
+      */
+    validity: ValidityState;
+    /**
+      * When present, marks an element that can't be submitted without a value.
+      */
+    required: boolean;
+    /**
+      * Sets or retrieves the maximum number of characters that the user can enter in a text control.
+      */
+    maxLength: number;
+    /**
+      * Returns whether an element will successfully validate based on forms validation rules and constraints.
+      */
+    willValidate: boolean;
+    /**
+      * Gets or sets a text string that is displayed in an input field as a hint or prompt to users as the format or type of information they need to enter.The text appears in an input field until the user puts focus on the field.
+      */
+    placeholder: string;
+    /**
+      * Returns whether a form will validate when it is submitted, without having to submit it.
+      */
+    checkValidity(): boolean;
+    /**
+      * Sets a custom error message that is displayed when a form is submitted.
+      * @param error Sets a custom error message that is displayed when a form is submitted.
+      */
+    setCustomValidity(error: string): void;
+}
+
+interface XMLHttpRequestEventTarget extends EventTarget {
+    onprogress: (ev: ProgressEvent) => any;
+    onerror: (ev: ErrorEvent) => any;
+    onload: (ev: any) => any;
+    ontimeout: (ev: any) => any;
+    onabort: (ev: any) => any;
+    onloadstart: (ev: any) => any;
+    onloadend: (ev: ProgressEvent) => any;
+}
+
+interface IDBEnvironment {
+    msIndexedDB: IDBFactory;
+    indexedDB: IDBFactory;
+}
+
+interface AudioTrackList extends EventTarget {
+    length: number;
+    onchange: (ev: any) => any;
+    onaddtrack: (ev: TrackEvent) => any;
+    getTrackById(id: string): AudioTrack;
+    item(index: number): AudioTrack;
+    [index: number]: AudioTrack;
+}
+
+interface MSBaseReader extends EventTarget {
+    onprogress: (ev: ProgressEvent) => any;
+    readyState: number;
+    onabort: (ev: any) => any;
+    onloadend: (ev: ProgressEvent) => any;
+    onerror: (ev: ErrorEvent) => any;
+    onload: (ev: any) => any;
+    onloadstart: (ev: any) => any;
+    result: any;
+    abort(): void;
+    LOADING: number;
+    EMPTY: number;
+    DONE: number;
+}
+
+interface History {
+    state: any;
+    replaceState(statedata: any, title: string, url?: string): void;
+    pushState(statedata: any, title: string, url?: string): void;
+}
+
+interface SVGFEMorphologyElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+    operator: SVGAnimatedEnumeration;
+    radiusX: SVGAnimatedNumber;
+    radiusY: SVGAnimatedNumber;
+    in1: SVGAnimatedString;
+    SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number;
+    SVG_MORPHOLOGY_OPERATOR_ERODE: number;
+    SVG_MORPHOLOGY_OPERATOR_DILATE: number;
+}
+declare var SVGFEMorphologyElement: {
+    SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number;
+    SVG_MORPHOLOGY_OPERATOR_ERODE: number;
+    SVG_MORPHOLOGY_OPERATOR_DILATE: number;
+}
+
+interface HTMLSelectElement {
+    /**
+      * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
+      */
+    validationMessage: string;
+    /**
+      * Provides a way to direct a user to a specific field when a document loads. This can provide both direction and convenience for a user, reducing the need to click or tab to a field when a page opens. This attribute is true when present on an element, and false when missing.
+      */
+    autofocus: boolean;
+    /**
+      * Returns a  ValidityState object that represents the validity states of an element.
+      */
+    validity: ValidityState;
+    /**
+      * When present, marks an element that can't be submitted without a value.
+      */
+    required: boolean;
+    /**
+      * Returns whether an element will successfully validate based on forms validation rules and constraints.
+      */
+    willValidate: boolean;
+    /**
+      * Returns whether a form will validate when it is submitted, without having to submit it.
+      */
+    checkValidity(): boolean;
+    /**
+      * Sets a custom error message that is displayed when a form is submitted.
+      * @param error Sets a custom error message that is displayed when a form is submitted.
+      */
+    setCustomValidity(error: string): void;
+}
+
+interface CSSRule {
+    KEYFRAMES_RULE: number;
+    KEYFRAME_RULE: number;
+    VIEWPORT_RULE: number;
+}
+//declare var CSSRule: {
+//    KEYFRAMES_RULE: number;
+//    KEYFRAME_RULE: number;
+//    VIEWPORT_RULE: number;
+//}
+
+interface SVGFEFuncRElement extends SVGComponentTransferFunctionElement {
+}
+
+interface WindowTimersExtension {
+    msSetImmediate(expression: any, ...args: any[]): number;
+    clearImmediate(handle: number): void;
+    msClearImmediate(handle: number): void;
+    setImmediate(expression: any, ...args: any[]): number;
+}
+
+interface SVGFEDisplacementMapElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+    in2: SVGAnimatedString;
+    xChannelSelector: SVGAnimatedEnumeration;
+    yChannelSelector: SVGAnimatedEnumeration;
+    scale: SVGAnimatedNumber;
+    in1: SVGAnimatedString;
+    SVG_CHANNEL_B: number;
+    SVG_CHANNEL_R: number;
+    SVG_CHANNEL_G: number;
+    SVG_CHANNEL_UNKNOWN: number;
+    SVG_CHANNEL_A: number;
+}
+declare var SVGFEDisplacementMapElement: {
+    SVG_CHANNEL_B: number;
+    SVG_CHANNEL_R: number;
+    SVG_CHANNEL_G: number;
+    SVG_CHANNEL_UNKNOWN: number;
+    SVG_CHANNEL_A: number;
+}
+
+interface AnimationEvent extends Event {
+    animationName: string;
+    elapsedTime: number;
+    initAnimationEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, animationNameArg: string, elapsedTimeArg: number): void;
+}
+
+interface SVGComponentTransferFunctionElement extends SVGElement {
+    tableValues: SVGAnimatedNumberList;
+    slope: SVGAnimatedNumber;
+    type: SVGAnimatedEnumeration;
+    exponent: SVGAnimatedNumber;
+    amplitude: SVGAnimatedNumber;
+    intercept: SVGAnimatedNumber;
+    offset: SVGAnimatedNumber;
+    SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number;
+    SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number;
+    SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number;
+    SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number;
+    SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number;
+    SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number;
+}
+declare var SVGComponentTransferFunctionElement: {
+    SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number;
+    SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number;
+    SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number;
+    SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number;
+    SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number;
+    SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number;
+}
+
+interface MSRangeCollection {
+    length: number;
+    item(index: number): Range;
+    [index: number]: Range;
+}
+
+interface SVGFEDistantLightElement extends SVGElement {
+    azimuth: SVGAnimatedNumber;
+    elevation: SVGAnimatedNumber;
+}
+
+interface SVGException {
+    name: string;
+}
+
+interface SVGFEFuncBElement extends SVGComponentTransferFunctionElement {
+}
+
+interface IDBKeyRange {
+    upper: any;
+    upperOpen: boolean;
+    lower: any;
+    lowerOpen: boolean;
+    bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
+    only(value: any): IDBKeyRange;
+    lowerBound(bound: any, open?: boolean): IDBKeyRange;
+    upperBound(bound: any, open?: boolean): IDBKeyRange;
+}
+
+interface WindowConsole {
+    console: Console;
+}
+
+interface IDBTransaction extends EventTarget {
+    oncomplete: (ev: Event) => any;
+    db: IDBDatabase;
+    mode: string;
+    error: DOMError;
+    onerror: (ev: ErrorEvent) => any;
+    onabort: (ev: any) => any;
+    abort(): void;
+    objectStore(name: string): IDBObjectStore;
+}
+
+interface AudioTrack {
+    kind: string;
+    language: string;
+    id: string;
+    label: string;
+    enabled: boolean;
+}
+
+interface SVGFEConvolveMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+    orderY: SVGAnimatedInteger;
+    kernelUnitLengthY: SVGAnimatedNumber;
+    orderX: SVGAnimatedInteger;
+    preserveAlpha: SVGAnimatedBoolean;
+    kernelMatrix: SVGAnimatedNumberList;
+    edgeMode: SVGAnimatedEnumeration;
+    kernelUnitLengthX: SVGAnimatedNumber;
+    bias: SVGAnimatedNumber;
+    targetX: SVGAnimatedInteger;
+    targetY: SVGAnimatedInteger;
+    divisor: SVGAnimatedNumber;
+    in1: SVGAnimatedString;
+    SVG_EDGEMODE_WRAP: number;
+    SVG_EDGEMODE_DUPLICATE: number;
+    SVG_EDGEMODE_UNKNOWN: number;
+    SVG_EDGEMODE_NONE: number;
+}
+declare var SVGFEConvolveMatrixElement: {
+    SVG_EDGEMODE_WRAP: number;
+    SVG_EDGEMODE_DUPLICATE: number;
+    SVG_EDGEMODE_UNKNOWN: number;
+    SVG_EDGEMODE_NONE: number;
+}
+
+interface TextTrackCueList {
+    length: number;
+    item(index: number): TextTrackCue;
+    [index: number]: TextTrackCue;
+    getCueById(id: string): TextTrackCue;
+}
+
+interface CSSKeyframesRule extends CSSRule {
+    name: string;
+    cssRules: CSSRuleList;
+    findRule(rule: string): CSSKeyframeRule;
+    deleteRule(rule: string): void;
+    appendRule(rule: string): void;
+}
+
+interface Window extends WindowBase64, IDBEnvironment, WindowConsole {
+    onmspointerdown: (ev: any) => any;
+    animationStartTime: number;
+    onmsgesturedoubletap: (ev: any) => any;
+    onmspointerhover: (ev: any) => any;
+    onmsgesturehold: (ev: any) => any;
+    onmspointermove: (ev: any) => any;
+    onmsgesturechange: (ev: any) => any;
+    onmsgesturestart: (ev: any) => any;
+    onmspointercancel: (ev: any) => any;
+    onmsgestureend: (ev: any) => any;
+    onmsgesturetap: (ev: any) => any;
+    onmspointerout: (ev: any) => any;
+    msAnimationStartTime: number;
+    applicationCache: ApplicationCache;
+    onmsinertiastart: (ev: any) => any;
+    onmspointerover: (ev: any) => any;
+    onpopstate: (ev: PopStateEvent) => any;
+    onmspointerup: (ev: any) => any;
+    msCancelRequestAnimationFrame(handle: number): void;
+    matchMedia(mediaQuery: string): MediaQueryList;
+    cancelAnimationFrame(handle: number): void;
+    msIsStaticHTML(html: string): boolean;
+    msMatchMedia(mediaQuery: string): MediaQueryList;
+    requestAnimationFrame(callback: FrameRequestCallback): number;
+    msRequestAnimationFrame(callback: FrameRequestCallback): number;
+}
+
+interface SVGFETurbulenceElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+    baseFrequencyX: SVGAnimatedNumber;
+    numOctaves: SVGAnimatedInteger;
+    type: SVGAnimatedEnumeration;
+    baseFrequencyY: SVGAnimatedNumber;
+    stitchTiles: SVGAnimatedEnumeration;
+    seed: SVGAnimatedNumber;
+    SVG_STITCHTYPE_UNKNOWN: number;
+    SVG_STITCHTYPE_NOSTITCH: number;
+    SVG_TURBULENCE_TYPE_UNKNOWN: number;
+    SVG_TURBULENCE_TYPE_TURBULENCE: number;
+    SVG_TURBULENCE_TYPE_FRACTALNOISE: number;
+    SVG_STITCHTYPE_STITCH: number;
+}
+declare var SVGFETurbulenceElement: {
+    SVG_STITCHTYPE_UNKNOWN: number;
+    SVG_STITCHTYPE_NOSTITCH: number;
+    SVG_TURBULENCE_TYPE_UNKNOWN: number;
+    SVG_TURBULENCE_TYPE_TURBULENCE: number;
+    SVG_TURBULENCE_TYPE_FRACTALNOISE: number;
+    SVG_STITCHTYPE_STITCH: number;
+}
+
+interface TextTrackList {
+    length: number;
+    item(index: number): TextTrack;
+    [index: number]: TextTrack;
+}
+
+interface SVGFEFuncGElement extends SVGComponentTransferFunctionElement {
+}
+
+interface SVGFEColorMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+    in1: SVGAnimatedString;
+    type: SVGAnimatedEnumeration;
+    values: SVGAnimatedNumberList;
+    SVG_FECOLORMATRIX_TYPE_SATURATE: number;
+    SVG_FECOLORMATRIX_TYPE_UNKNOWN: number;
+    SVG_FECOLORMATRIX_TYPE_MATRIX: number;
+    SVG_FECOLORMATRIX_TYPE_HUEROTATE: number;
+    SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number;
+}
+declare var SVGFEColorMatrixElement: {
+    SVG_FECOLORMATRIX_TYPE_SATURATE: number;
+    SVG_FECOLORMATRIX_TYPE_UNKNOWN: number;
+    SVG_FECOLORMATRIX_TYPE_MATRIX: number;
+    SVG_FECOLORMATRIX_TYPE_HUEROTATE: number;
+    SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number;
+}
+
+interface Console {
+    info(message?: any, ...optionalParams: any[]): void;
+    profile(reportName?: string): void;
+    assert(test?: boolean, message?: string, ...optionalParams: any[]): void;
+    msIsIndependentlyComposed(element: Element): boolean;
+    clear(): void;
+    dir(value?: any, ...optionalParams: any[]): void;
+    warn(message?: any, ...optionalParams: any[]): void;
+    error(message?: any, ...optionalParams: any[]): void;
+    log(message?: any, ...optionalParams: any[]): void;
+    profileEnd(): void;
+}
+
+interface SVGFESpotLightElement extends SVGElement {
+    pointsAtY: SVGAnimatedNumber;
+    y: SVGAnimatedNumber;
+    limitingConeAngle: SVGAnimatedNumber;
+    specularExponent: SVGAnimatedNumber;
+    x: SVGAnimatedNumber;
+    pointsAtZ: SVGAnimatedNumber;
+    z: SVGAnimatedNumber;
+    pointsAtX: SVGAnimatedNumber;
+}
+
+interface HTMLImageElement {
+    /**
+      * Gets or sets the primary DLNA PlayTo device.
+      */
+    msPlayToPrimary: boolean;
+    /**
+      * Gets or sets whether the DLNA PlayTo device is available.
+      */
+    msPlayToDisabled: boolean;
+    /**
+      * Gets the source associated with the media element for use by the PlayToManager.
+      */
+    msPlayToSource: any;
+}
+
+interface WindowBase64 {
+    btoa(rawString: string): string;
+    atob(encodedString: string): string;
+}
+
+interface IDBDatabase extends EventTarget {
+    version: string;
+    name: string;
+    objectStoreNames: DOMStringList;
+    onerror: (ev: ErrorEvent) => any;
+    onabort: (ev: any) => any;
+    createObjectStore(name: string, optionalParameters?: any): IDBObjectStore;
+    close(): void;
+    transaction(storeNames: any, mode?: string): IDBTransaction;
+    deleteObjectStore(name: string): void;
+}
+
+interface DOMStringList {
+    length: number;
+    contains(str: string): boolean;
+    item(index: number): string;
+    [index: number]: string;
+}
+
+interface HTMLButtonElement {
+    /**
+      * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
+      */
+    validationMessage: string;
+    /**
+      * Overrides the target attribute on a form element.
+      */
+    formTarget: string;
+    /**
+      * Returns whether an element will successfully validate based on forms validation rules and constraints.
+      */
+    willValidate: boolean;
+    /**
+      * Overrides the action attribute (where the data on a form is sent) on the parent form element.
+      */
+    formAction: string;
+    /**
+      * Provides a way to direct a user to a specific field when a document loads. This can provide both direction and convenience for a user, reducing the need to click or tab to a field when a page opens. This attribute is true when present on an element, and false when missing.
+      */
+    autofocus: boolean;
+    /**
+      * Returns a  ValidityState object that represents the validity states of an element.
+      */
+    validity: ValidityState;
+    /**
+      * Overrides any validation or required attributes on a form or form elements to allow it to be submitted without validation. This can be used to create a "save draft"-type submit option.
+      */
+    formNoValidate: string;
+    /**
+      * Used to override the encoding (formEnctype attribute) specified on the form element.
+      */
+    formEnctype: string;
+    /**
+      * Overrides the submit method attribute previously specified on a form element.
+      */
+    formMethod: string;
+    /**
+      * Returns whether a form will validate when it is submitted, without having to submit it.
+      */
+    checkValidity(): boolean;
+    /**
+      * Sets a custom error message that is displayed when a form is submitted.
+      * @param error Sets a custom error message that is displayed when a form is submitted.
+      */
+    setCustomValidity(error: string): void;
+}
+
+interface IDBOpenDBRequest extends IDBRequest {
+    onupgradeneeded: (ev: IDBVersionChangeEvent) => any;
+    onblocked: (ev: Event) => any;
+}
+
+interface HTMLProgressElement extends HTMLElement {
+    /**
+      * Sets or gets the current value of a progress element. The value must be a non-negative number between 0 and the max value.
+      */
+    value: number;
+    /**
+      * Defines the maximum, or "done" value for a progress element.
+      */
+    max: number;
+    /**
+      * Returns the quotient of value/max when the value attribute is set (determinate progress bar), or -1 when the value attribute is missing (indeterminate progress bar).
+      */
+    position: number;
+    /**
+      * Retrieves a reference to the form that the object is embedded in.
+      */
+    form: HTMLFormElement;
+}
+
+interface MSLaunchUriCallback {
+    (): void;
+}
+
+interface SVGFEOffsetElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+    dy: SVGAnimatedNumber;
+    in1: SVGAnimatedString;
+    dx: SVGAnimatedNumber;
+}
+
+interface HTMLFormElement {
+    /**
+      * Specifies whether autocomplete is applied to an editable text field.
+      */
+    autocomplete: string;
+    /**
+      * Designates a form that is not validated when submitted.
+      */
+    noValidate: boolean;
+    /**
+      * Returns whether a form will validate when it is submitted, without having to submit it.
+      */
+    checkValidity(): boolean;
+}
+
+interface MSUnsafeFunctionCallback {
+    (): any;
+}
+
+interface Document {
+    onmspointerdown: (ev: any) => any;
+    msHidden: boolean;
+    msVisibilityState: string;
+    onmsgesturedoubletap: (ev: any) => any;
+    visibilityState: string;
+    onmsmanipulationstatechanged: (ev: any) => any;
+    onmspointerhover: (ev: any) => any;
+    onmscontentzoom: (ev: any) => any;
+    onmspointermove: (ev: any) => any;
+    onmsgesturehold: (ev: any) => any;
+    onmsgesturechange: (ev: any) => any;
+    onmsgesturestart: (ev: any) => any;
+    onmspointercancel: (ev: any) => any;
+    onmsgestureend: (ev: any) => any;
+    onmsgesturetap: (ev: any) => any;
+    onmspointerout: (ev: any) => any;
+    onmsinertiastart: (ev: any) => any;
+    msCSSOMElementFloatMetrics: boolean;
+    onmspointerover: (ev: any) => any;
+    hidden: boolean;
+    onmspointerup: (ev: any) => any;
+    msElementsFromPoint(x: number, y: number): NodeList;
+    msElementsFromRect(left: number, top: number, width: number, height: number): NodeList;
+    clear(): void;
+}
+
+interface MessageEvent extends Event {
+    ports: any;
+}
+
+interface HTMLScriptElement {
+    async: boolean;
+}
+
+interface HTMLMediaElement {
+    /**
+      * Specifies the purpose of the audio or video media, such as background audio or alerts.
+      */
+    msAudioCategory: string;
+    /**
+      * Specifies whether or not to enable low-latency playback on the media element.
+      */
+    msRealTime: boolean;
+    /**
+      * Gets or sets the primary DLNA PlayTo device.
+      */
+    msPlayToPrimary: boolean;
+    textTracks: TextTrackList;
+    /**
+      * Gets or sets whether the DLNA PlayTo device is available.
+      */
+    msPlayToDisabled: boolean;
+    /**
+      * Returns an AudioTrackList object with the audio tracks for a given video element.
+      */
+    audioTracks: AudioTrackList;
+    /**
+      * Gets the source associated with the media element for use by the PlayToManager.
+      */
+    msPlayToSource: any;
+    /**
+      * Specifies the output device id that the audio will be sent to.
+      */
+    msAudioDeviceType: string;
+    /**
+      * Clears all effects from the media pipeline.
+      */
+    msClearEffects(): void;
+    /**
+      * Specifies the media protection manager for a given media pipeline.
+      */
+    msSetMediaProtectionManager(mediaProtectionManager?: any): void;
+    /**
+      * Inserts the specified audio effect into media pipeline.
+      */
+    msInsertAudioEffect(activatableClassId: string, effectRequired: boolean, config?: any): void;
+}
+
+interface TextTrack extends EventTarget {
+    language: string;
+    mode: any;
+    readyState: number;
+    activeCues: TextTrackCueList;
+    cues: TextTrackCueList;
+    oncuechange: (ev: Event) => any;
+    kind: string;
+    onload: (ev: any) => any;
+    onerror: (ev: ErrorEvent) => any;
+    label: string;
+    ERROR: number;
+    SHOWING: number;
+    LOADING: number;
+    LOADED: number;
+    NONE: number;
+    HIDDEN: number;
+    DISABLED: number;
+}
+declare var TextTrack: {
+    ERROR: number;
+    SHOWING: number;
+    LOADING: number;
+    LOADED: number;
+    NONE: number;
+    HIDDEN: number;
+    DISABLED: number;
+}
+
+interface MediaQueryListListener {
+    (mql: MediaQueryList): void;
+}
+
+interface IDBRequest extends EventTarget {
+    source: any;
+    onsuccess: (ev: Event) => any;
+    error: DOMError;
+    transaction: IDBTransaction;
+    onerror: (ev: ErrorEvent) => any;
+    readyState: string;
+    result: any;
+}
+
+interface MessagePort extends EventTarget {
+    onmessage: (ev: any) => any;
+    close(): void;
+    postMessage(message?: any, ports?: any): void;
+    start(): void;
+}
+
+interface FileReader extends MSBaseReader {
+    error: DOMError;
+    readAsArrayBuffer(blob: Blob): void;
+    readAsDataURL(blob: Blob): void;
+    readAsText(blob: Blob, encoding?: string): void;
+}
+declare var FileReader: {
+    prototype: FileReader;
+    new (): FileReader;
+}
+
+interface BlobPropertyBag {
+    type?: string;
+    endings?: string;
+}
+
+interface Blob {
+    type: string;
+    size: number;
+    msDetachStream(): any;
+    slice(start?: number, end?: number, contentType?: string): Blob;
+    msClose(): void;
+}
+declare var Blob: {
+    prototype: Blob;
+    new (blobParts?: any[], options?: BlobPropertyBag): Blob;
+}
+
+interface ApplicationCache extends EventTarget {
+    status: number;
+    ondownloading: (ev: Event) => any;
+    onprogress: (ev: ProgressEvent) => any;
+    onupdateready: (ev: Event) => any;
+    oncached: (ev: Event) => any;
+    onobsolete: (ev: Event) => any;
+    onerror: (ev: ErrorEvent) => any;
+    onchecking: (ev: Event) => any;
+    onnoupdate: (ev: Event) => any;
+    swapCache(): void;
+    abort(): void;
+    update(): void;
+    CHECKING: number;
+    UNCACHED: number;
+    UPDATEREADY: number;
+    DOWNLOADING: number;
+    IDLE: number;
+    OBSOLETE: number;
+}
+declare var ApplicationCache: {
+    CHECKING: number;
+    UNCACHED: number;
+    UPDATEREADY: number;
+    DOWNLOADING: number;
+    IDLE: number;
+    OBSOLETE: number;
+}
+
+interface FrameRequestCallback {
+    (time: number): void;
+}
+
+interface XMLHttpRequest {
+    response: any;
+    withCredentials: boolean;
+    onprogress: (ev: ProgressEvent) => any;
+    onabort: (ev: any) => any;
+    responseType: string;
+    onloadend: (ev: ProgressEvent) => any;
+    upload: XMLHttpRequestEventTarget;
+    onerror: (ev: ErrorEvent) => any;
+    onloadstart: (ev: any) => any;
+}
+
+interface PopStateEvent extends Event {
+    state: any;
+    initPopStateEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, stateArg: any): void;
+}
+
+interface CSSKeyframeRule extends CSSRule {
+    keyText: string;
+    style: CSSStyleDeclaration;
+}
+
+interface MSFileSaver {
+    msSaveBlob(blob: any, defaultName?: string): boolean;
+    msSaveOrOpenBlob(blob: any, defaultName?: string): boolean;
+}
+
+interface MSStream {
+    type: string;
+    msDetachStream(): any;
+    msClose(): void;
+}
+
+interface MediaError {
+    msExtendedCode: number;
+}
+
+interface HTMLFieldSetElement {
+    /**
+      * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
+      */
+    validationMessage: string;
+    /**
+      * Returns a  ValidityState object that represents the validity states of an element.
+      */
+    validity: ValidityState;
+    /**
+      * Returns whether an element will successfully validate based on forms validation rules and constraints.
+      */
+    willValidate: boolean;
+    /**
+      * Returns whether a form will validate when it is submitted, without having to submit it.
+      */
+    checkValidity(): boolean;
+    /**
+      * Sets a custom error message that is displayed when a form is submitted.
+      * @param error Sets a custom error message that is displayed when a form is submitted.
+      */
+    setCustomValidity(error: string): void;
+}
+
+interface MSBlobBuilder {
+    append(data: any, endings?: string): void;
+    getBlob(contentType?: string): Blob;
+}
+declare var MSBlobBuilder: {
+    prototype: MSBlobBuilder;
+    new (): MSBlobBuilder;
+}
+
+interface HTMLElement {
+    onmscontentzoom: (ev: any) => any;
+    oncuechange: (ev: Event) => any;
+    spellcheck: boolean;
+    classList: DOMTokenList;
+    onmsmanipulationstatechanged: (ev: any) => any;
+    draggable: boolean;
+}
+
+interface DataTransfer {
+    types: DOMStringList;
+    files: FileList;
+}
+
+interface DOMSettableTokenList extends DOMTokenList {
+    value: string;
+}
+
+interface IDBFactory {
+    open(name: string, version?: number): IDBOpenDBRequest;
+    cmp(first: any, second: any): number;
+    deleteDatabase(name: string): IDBOpenDBRequest;
+}
+
+interface Range {
+    createContextualFragment(fragment: string): DocumentFragment;
+}
+
+interface HTMLObjectElement {
+    /**
+      * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting.
+      */
+    validationMessage: string;
+    /**
+      * Returns a  ValidityState object that represents the validity states of an element.
+      */
+    validity: ValidityState;
+    /**
+      * Returns whether an element will successfully validate based on forms validation rules and constraints.
+      */
+    willValidate: boolean;
+    /**
+      * Returns whether a form will validate when it is submitted, without having to submit it.
+      */
+    checkValidity(): boolean;
+    /**
+      * Sets a custom error message that is displayed when a form is submitted.
+      * @param error Sets a custom error message that is displayed when a form is submitted.
+      */
+    setCustomValidity(error: string): void;
+}
+
+interface MSPointerEvent extends MouseEvent {
+    width: number;
+    rotation: number;
+    pressure: number;
+    pointerType: any;
+    isPrimary: boolean;
+    tiltY: number;
+    height: number;
+    intermediatePoints: any;
+    currentPoint: any;
+    tiltX: number;
+    hwTimestamp: number;
+    pointerId: number;
+    initPointerEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget, offsetXArg: number, offsetYArg: number, widthArg: number, heightArg: number, pressure: number, rotation: number, tiltX: number, tiltY: number, pointerIdArg: number, pointerType: any, hwTimestampArg: number, isPrimary: boolean): void;
+    getCurrentPoint(element: Element): void;
+    getIntermediatePoints(element: Element): void;
+    MSPOINTER_TYPE_PEN: number;
+    MSPOINTER_TYPE_MOUSE: number;
+    MSPOINTER_TYPE_TOUCH: number;
+}
+declare var MSPointerEvent: {
+    MSPOINTER_TYPE_PEN: number;
+    MSPOINTER_TYPE_MOUSE: number;
+    MSPOINTER_TYPE_TOUCH: number;
+}
+
+interface DOMException {
+    name: string;
+    INVALID_NODE_TYPE_ERR: number;
+    DATA_CLONE_ERR: number;
+    TIMEOUT_ERR: number;
+}
+//declare var DOMException: {
+//    INVALID_NODE_TYPE_ERR: number;
+//    DATA_CLONE_ERR: number;
+//    TIMEOUT_ERR: number;
+//}
+
+interface MSManipulationEvent extends UIEvent {
+    lastState: number;
+    currentState: number;
+    initMSManipulationEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, lastState: number, currentState: number): void;
+    MS_MANIPULATION_STATE_STOPPED: number;
+    MS_MANIPULATION_STATE_ACTIVE: number;
+    MS_MANIPULATION_STATE_INERTIA: number;
+}
+declare var MSManipulationEvent: {
+    MS_MANIPULATION_STATE_STOPPED: number;
+    MS_MANIPULATION_STATE_ACTIVE: number;
+    MS_MANIPULATION_STATE_INERTIA: number;
+}
+
+interface FormData {
+    append(name: any, value: any, blobName?: string): void;
+}
+declare var FormData: {
+    prototype: FormData;
+    new (form?: HTMLFormElement): FormData;
+}
+
+interface HTMLDataListElement extends HTMLElement {
+    options: HTMLCollection;
+}
+
+interface SVGFEImageElement extends SVGElement, SVGLangSpace, SVGFilterPrimitiveStandardAttributes, SVGURIReference, SVGExternalResourcesRequired {
+    preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
+}
+
+interface AbstractWorker extends EventTarget {
+    onerror: (ev: ErrorEvent) => any;
+}
+
+interface SVGFECompositeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+    operator: SVGAnimatedEnumeration;
+    in2: SVGAnimatedString;
+    k2: SVGAnimatedNumber;
+    k1: SVGAnimatedNumber;
+    k3: SVGAnimatedNumber;
+    in1: SVGAnimatedString;
+    k4: SVGAnimatedNumber;
+    SVG_FECOMPOSITE_OPERATOR_OUT: number;
+    SVG_FECOMPOSITE_OPERATOR_OVER: number;
+    SVG_FECOMPOSITE_OPERATOR_XOR: number;
+    SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number;
+    SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number;
+    SVG_FECOMPOSITE_OPERATOR_IN: number;
+    SVG_FECOMPOSITE_OPERATOR_ATOP: number;
+}
+declare var SVGFECompositeElement: {
+    SVG_FECOMPOSITE_OPERATOR_OUT: number;
+    SVG_FECOMPOSITE_OPERATOR_OVER: number;
+    SVG_FECOMPOSITE_OPERATOR_XOR: number;
+    SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number;
+    SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number;
+    SVG_FECOMPOSITE_OPERATOR_IN: number;
+    SVG_FECOMPOSITE_OPERATOR_ATOP: number;
+}
+
+interface ValidityState {
+    customError: boolean;
+    valueMissing: boolean;
+    stepMismatch: boolean;
+    rangeUnderflow: boolean;
+    rangeOverflow: boolean;
+    typeMismatch: boolean;
+    patternMismatch: boolean;
+    tooLong: boolean;
+    valid: boolean;
+}
+
+interface HTMLTrackElement extends HTMLElement {
+    kind: string;
+    src: string;
+    srclang: string;
+    track: TextTrack;
+    label: string;
+    default: boolean;
+}
+
+interface MSApp {
+    createFileFromStorageFile(storageFile: any): File;
+    createBlobFromRandomAccessStream(type: string, seeker: any): Blob;
+    createStreamFromInputStream(type: string, inputStream: any): MSStream;
+    terminateApp(exceptionObject: any): void;
+    createDataPackage(object: any): any;
+    execUnsafeLocalFunction(unsafeFunction: MSUnsafeFunctionCallback): any;
+    getHtmlPrintDocumentSource(htmlDoc: any): any;
+    addPublicLocalApplicationUri(uri: string): void;
+    createDataPackageFromSelection(): any;
+}
+declare var MSApp: MSApp;
+
+interface HTMLVideoElement {
+    msIsStereo3D: boolean;
+    msStereo3DPackingMode: string;
+    onMSVideoOptimalLayoutChanged: (ev: any) => any;
+    onMSVideoFrameStepCompleted: (ev: any) => any;
+    msStereo3DRenderMode: string;
+    msIsLayoutOptimalForPlayback: boolean;
+    msHorizontalMirror: boolean;
+    onMSVideoFormatChanged: (ev: any) => any;
+    msZoom: boolean;
+    msInsertVideoEffect(activatableClassId: string, effectRequired: boolean, config?: any): void;
+    msSetVideoRectangle(left: number, top: number, right: number, bottom: number): void;
+    msFrameStep(forward: boolean): void;
+}
+
+interface SVGFEComponentTransferElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+    in1: SVGAnimatedString;
+}
+
+interface SVGFEDiffuseLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+    kernelUnitLengthY: SVGAnimatedNumber;
+    surfaceScale: SVGAnimatedNumber;
+    in1: SVGAnimatedString;
+    kernelUnitLengthX: SVGAnimatedNumber;
+    diffuseConstant: SVGAnimatedNumber;
+}
+
+interface MSCSSMatrix {
+    m24: number;
+    m34: number;
+    a: number;
+    d: number;
+    m32: number;
+    m41: number;
+    m11: number;
+    f: number;
+    e: number;
+    m23: number;
+    m14: number;
+    m33: number;
+    m22: number;
+    m21: number;
+    c: number;
+    m12: number;
+    b: number;
+    m42: number;
+    m31: number;
+    m43: number;
+    m13: number;
+    m44: number;
+    multiply(secondMatrix: MSCSSMatrix): MSCSSMatrix;
+    skewY(angle: number): MSCSSMatrix;
+    setMatrixValue(value: string): void;
+    inverse(): MSCSSMatrix;
+    rotateAxisAngle(x: number, y: number, z: number, angle: number): MSCSSMatrix;
+    toString(): string;
+    rotate(angleX: number, angleY?: number, angleZ?: number): MSCSSMatrix;
+    translate(x: number, y: number, z?: number): MSCSSMatrix;
+    scale(scaleX: number, scaleY?: number, scaleZ?: number): MSCSSMatrix;
+    skewX(angle: number): MSCSSMatrix;
+}
+declare var MSCSSMatrix: {
+    prototype: MSCSSMatrix;
+    new (text?: string): MSCSSMatrix;
+}
+
+interface Worker extends AbstractWorker {
+    onmessage: (ev: any) => any;
+    postMessage(message: any, ports?: any): void;
+    terminate(): void;
+}
+declare var Worker: {
+    prototype: Worker;
+    new (stringUrl: string): Worker;
+}
+
+interface HTMLIFrameElement {
+    sandbox: DOMSettableTokenList;
+}
+
+declare var onmspointerdown: (ev: any) => any;
+declare var animationStartTime: number;
+declare var onmsgesturedoubletap: (ev: any) => any;
+declare var onmspointerhover: (ev: any) => any;
+declare var onmsgesturehold: (ev: any) => any;
+declare var onmspointermove: (ev: any) => any;
+declare var onmsgesturechange: (ev: any) => any;
+declare var onmsgesturestart: (ev: any) => any;
+declare var onmspointercancel: (ev: any) => any;
+declare var onmsgestureend: (ev: any) => any;
+declare var onmsgesturetap: (ev: any) => any;
+declare var onmspointerout: (ev: any) => any;
+declare var msAnimationStartTime: number;
+declare var applicationCache: ApplicationCache;
+declare var onmsinertiastart: (ev: any) => any;
+declare var onmspointerover: (ev: any) => any;
+declare var onpopstate: (ev: PopStateEvent) => any;
+declare var onmspointerup: (ev: any) => any;
+declare function msCancelRequestAnimationFrame(handle: number): void;
+declare function matchMedia(mediaQuery: string): MediaQueryList;
+declare function cancelAnimationFrame(handle: number): void;
+declare function msIsStaticHTML(html: string): boolean;
+declare function msMatchMedia(mediaQuery: string): MediaQueryList;
+declare function requestAnimationFrame(callback: FrameRequestCallback): number;
+declare function msRequestAnimationFrame(callback: FrameRequestCallback): number;
+declare function btoa(rawString: string): string;
+declare function atob(encodedString: string): string;
+declare var msIndexedDB: IDBFactory;
+declare var indexedDB: IDBFactory;
+declare var console: Console;
+
+
+/////////////////////////////
+/// IE11 DOM APIs 
+/////////////////////////////
+
+
+interface StoreExceptionsInformation extends ExceptionInformation {
+    siteName?: string;
+    explanationString?: string;
+    detailURI?: string;
+}
+
+interface StoreSiteSpecificExceptionsInformation extends StoreExceptionsInformation {
+    arrayOfDomainStrings?: Array<string>;
+}
+
+interface ConfirmSiteSpecificExceptionsInformation extends ExceptionInformation {
+    arrayOfDomainStrings?: Array<string>;
+}
+
+interface AlgorithmParameters {
+}
+
+interface MutationObserverInit {
+    childList?: boolean;
+    attributes?: boolean;
+    characterData?: boolean;
+    subtree?: boolean;
+    attributeOldValue?: boolean;
+    characterDataOldValue?: boolean;
+    attributeFilter?: Array<string>;
+}
+
+interface ExceptionInformation {
+    domain?: string;
+}
+
+interface MsZoomToOptions {
+    contentX?: number;
+    contentY?: number;
+    viewportX?: string;
+    viewportY?: string;
+    scaleFactor?: number;
+    animate?: string;
+}
+
+interface DeviceAccelerationDict {
+    x?: number;
+    y?: number;
+    z?: number;
+}
+
+interface DeviceRotationRateDict {
+    alpha?: number;
+    beta?: number;
+    gamma?: number;
+}
+
+interface Algorithm {
+    name?: string;
+    params?: AlgorithmParameters;
+}
+
+interface NavigatorID {
+    product: string;
+    vendor: string;
+}
+
+interface HTMLBodyElement {
+    onpageshow: (ev: PageTransitionEvent) => any;
+    onpagehide: (ev: PageTransitionEvent) => any;
+}
+
+interface MSExecAtPriorityFunctionCallback {
+    (...args: any[]): any;
+}
+
+interface MSWindowExtensions {
+    captureEvents(): void;
+    releaseEvents(): void;
+}
+
+interface MSGraphicsTrust {
+    status: string;
+    constrictionActive: boolean;
+}
+
+interface AudioTrack {
+    sourceBuffer: SourceBuffer;
+}
+
+interface DragEvent {
+    msConvertURL(file: File, targetType: string, targetURL?: string): void;
+}
+
+interface SubtleCrypto {
+    unwrapKey(wrappedKey: ArrayBufferView, keyAlgorithm: any, keyEncryptionKey: Key, extractable?: boolean, keyUsages?: string[]): KeyOperation;
+    encrypt(algorithm: any, key: Key, buffer?: ArrayBufferView): CryptoOperation;
+    importKey(format: string, keyData: ArrayBufferView, algorithm: any, extractable?: boolean, keyUsages?: string[]): KeyOperation;
+    wrapKey(key: Key, keyEncryptionKey: Key, keyWrappingAlgorithm: any): KeyOperation;
+    verify(algorithm: any, key: Key, signature: ArrayBufferView, buffer?: ArrayBufferView): CryptoOperation;
+    deriveKey(algorithm: any, baseKey: Key, derivedKeyType: any, extractable?: boolean, keyUsages?: string[]): KeyOperation;
+    digest(algorithm: any, buffer?: ArrayBufferView): CryptoOperation;
+    exportKey(format: string, key: Key): KeyOperation;
+    generateKey(algorithm: any, extractable?: boolean, keyUsages?: string[]): KeyOperation;
+    sign(algorithm: any, key: Key, buffer?: ArrayBufferView): CryptoOperation;
+    decrypt(algorithm: any, key: Key, buffer?: ArrayBufferView): CryptoOperation;
+}
+
+interface Crypto extends RandomSource {
+    subtle: SubtleCrypto;
+}
+
+interface VideoPlaybackQuality {
+    totalFrameDelay: number;
+    creationTime: number;
+    totalVideoFrames: number;
+    droppedVideoFrames: number;
+}
+
+interface GlobalEventHandlers {
+    onpointerenter: (ev: PointerEvent) => any;
+    onpointerout: (ev: PointerEvent) => any;
+    onpointerdown: (ev: PointerEvent) => any;
+    onpointerup: (ev: PointerEvent) => any;
+    onpointercancel: (ev: PointerEvent) => any;
+    onpointerover: (ev: PointerEvent) => any;
+    onpointermove: (ev: PointerEvent) => any;
+    onpointerleave: (ev: PointerEvent) => any;
+}
+
+interface Window extends GlobalEventHandlers {
+    onpageshow: (ev: PageTransitionEvent) => any;
+    ondevicemotion: (ev: DeviceMotionEvent) => any;
+    devicePixelRatio: number;
+    msCrypto: Crypto;
+    ondeviceorientation: (ev: DeviceOrientationEvent) => any;
+    doNotTrack: string;
+    onmspointerenter: (ev: any) => any;
+    onpagehide: (ev: PageTransitionEvent) => any;
+    onmspointerleave: (ev: any) => any;
+}
+
+interface Key {
+    algorithm: Algorithm;
+    type: string;
+    extractable: boolean;
+    keyUsage: string[];
+}
+
+interface TextTrackList extends EventTarget {
+    onaddtrack: (ev: any) => any;
+}
+
+interface DeviceAcceleration {
+    y: number;
+    x: number;
+    z: number;
+}
+
+interface Console {
+    count(countTitle?: string): void;
+    groupEnd(): void;
+    time(timerName?: string): void;
+    timeEnd(timerName?: string): void;
+    trace(): void;
+    group(groupTitle?: string): void;
+    dirxml(value: any): void;
+    debug(message?: string, ...optionalParams: any[]): void;
+    groupCollapsed(groupTitle?: string): void;
+    select(element: Element): void;
+}
+
+interface MSNavigatorDoNotTrack {
+    removeSiteSpecificTrackingException(args: ExceptionInformation): void;
+    removeWebWideTrackingException(args: ExceptionInformation): void;
+    storeWebWideTrackingException(args: StoreExceptionsInformation): void;
+    storeSiteSpecificTrackingException(args: StoreSiteSpecificExceptionsInformation): void;
+    confirmSiteSpecificTrackingException(args: ConfirmSiteSpecificExceptionsInformation): boolean;
+    confirmWebWideTrackingException(args: ExceptionInformation): boolean;
+}
+
+interface HTMLImageElement {
+    crossOrigin: string;
+    msPlayToPreferredSourceUri: string;
+}
+
+interface HTMLAllCollection extends HTMLCollection {
+    namedItem(name: string): Element;
+    //[name: string]: Element;
+}
+
+interface MSNavigatorExtensions {
+    language: string;
+}
+
+interface AesGcmEncryptResult {
+    ciphertext: ArrayBuffer;
+    tag: ArrayBuffer;
+}
+
+interface HTMLSourceElement {
+    msKeySystem: string;
+}
+
+interface CSSStyleDeclaration {
+    alignItems: string;
+    borderImageSource: string;
+    flexBasis: string;
+    borderImageWidth: string;
+    borderImageRepeat: string;
+    order: string;
+    flex: string;
+    alignContent: string;
+    msImeAlign: string;
+    flexShrink: string;
+    flexGrow: string;
+    borderImageSlice: string;
+    flexWrap: string;
+    borderImageOutset: string;
+    flexDirection: string;
+    touchAction: string;
+    flexFlow: string;
+    borderImage: string;
+    justifyContent: string;
+    alignSelf: string;
+    msTextCombineHorizontal: string;
+}
+
+interface NavigationCompletedEvent extends NavigationEvent {
+    webErrorStatus: number;
+    isSuccess: boolean;
+}
+
+interface MutationRecord {
+    oldValue: string;
+    previousSibling: Node;
+    addedNodes: NodeList;
+    attributeName: string;
+    removedNodes: NodeList;
+    target: Node;
+    nextSibling: Node;
+    attributeNamespace: string;
+    type: string;
+}
+
+interface Navigator {
+    pointerEnabled: boolean;
+    maxTouchPoints: number;
+}
+
+interface Document extends MSDocumentExtensions, GlobalEventHandlers {
+    msFullscreenEnabled: boolean;
+    onmsfullscreenerror: (ev: any) => any;
+    onmspointerenter: (ev: any) => any;
+    msFullscreenElement: Element;
+    onmsfullscreenchange: (ev: any) => any;
+    onmspointerleave: (ev: any) => any;
+    msExitFullscreen(): void;
+}
+
+interface MimeTypeArray {
+    length: number;
+    item(index: number): Plugin;
+    [index: number]: Plugin;
+    namedItem(type: string): Plugin;
+    //[type: string]: Plugin;
+}
+
+interface HTMLMediaElement {
+    /**
+      * Gets or sets the path to the preferred media source. This enables the Play To target device to stream the media content, which can be DRM protected, from a different location, such as a cloud media server.
+      */
+    msPlayToPreferredSourceUri: string;
+    onmsneedkey: (ev: MSMediaKeyNeededEvent) => any;
+    /**
+      * Gets the MSMediaKeys object, which is used for decrypting media data, that is associated with this media element.
+      */
+    msKeys: MSMediaKeys;
+    msGraphicsTrustStatus: MSGraphicsTrust;
+    msSetMediaKeys(mediaKeys: MSMediaKeys): void;
+    addTextTrack(kind: string, label?: string, language?: string): TextTrack;
+}
+
+interface TextTrack {
+    addCue(cue: TextTrackCue): void;
+    removeCue(cue: TextTrackCue): void;
+}
+
+interface KeyOperation extends EventTarget {
+    oncomplete: (ev: any) => any;
+    onerror: (ev: any) => any;
+    result: any;
+}
+
+interface DOMStringMap {
+}
+
+interface DeviceOrientationEvent extends Event {
+    gamma: number;
+    alpha: number;
+    absolute: boolean;
+    beta: number;
+    initDeviceOrientationEvent(type: string, bubbles: boolean, cancelable: boolean, alpha: number, beta: number, gamma: number, absolute: boolean): void;
+}
+
+interface MSMediaKeys {
+    keySystem: string;
+    createSession(type: string, initData: Uint8Array, cdmData?: Uint8Array): MSMediaKeySession;
+    isTypeSupported(keySystem: string, type?: string): boolean;
+}
+declare var MSMediaKeys: {
+    prototype: MSMediaKeys;
+    new (): MSMediaKeys;
+}
+
+interface MSMediaKeyMessageEvent extends Event {
+    destinationURL: string;
+    message: Uint8Array;
+}
+
+interface MSHTMLWebViewElement extends HTMLElement {
+    documentTitle: string;
+    width: number;
+    src: string;
+    canGoForward: boolean;
+    height: number;
+    canGoBack: boolean;
+    navigateWithHttpRequestMessage(requestMessage: any): void;
+    goBack(): void;
+    navigate(uri: string): void;
+    stop(): void;
+    navigateToString(contents: string): void;
+    captureSelectedContentToDataPackageAsync(): MSWebViewAsyncOperation;
+    capturePreviewToBlobAsync(): MSWebViewAsyncOperation;
+    refresh(): void;
+    goForward(): void;
+    navigateToLocalStreamUri(source: string, streamResolver: any): void;
+    invokeScriptAsync(scriptName: string, ...args: any[]): MSWebViewAsyncOperation;
+    buildLocalStreamUri(contentIdentifier: string, relativePath: string): string;
+}
+
+interface NavigationEvent extends Event {
+    uri: string;
+}
+
+interface Element extends GlobalEventHandlers {
+    onlostpointercapture: (ev: PointerEvent) => any;
+    onmspointerenter: (ev: any) => any;
+    ongotpointercapture: (ev: PointerEvent) => any;
+    onmspointerleave: (ev: any) => any;
+    msZoomTo(args: MsZoomToOptions): void;
+    setPointerCapture(pointerId: number): void;
+    msGetUntransformedBounds(): ClientRect;
+    releasePointerCapture(pointerId: number): void;
+    msRequestFullscreen(): void;
+}
+
+interface RandomSource {
+    getRandomValues(array: ArrayBufferView): ArrayBufferView;
+}
+
+interface XMLHttpRequest {
+    msCaching: string;
+    msCachingEnabled(): boolean;
+    overrideMimeType(mime: string): void;
+}
+
+interface SourceBuffer extends EventTarget {
+    updating: boolean;
+    appendWindowStart: number;
+    appendWindowEnd: number;
+    buffered: TimeRanges;
+    timestampOffset: number;
+    audioTracks: AudioTrackList;
+    appendBuffer(data: ArrayBuffer): void;
+    remove(start: number, end: number): void;
+    abort(): void;
+    appendStream(stream: MSStream, maxSize?: number): void;
+}
+
+interface MSInputMethodContext extends EventTarget {
+    oncandidatewindowshow: (ev: any) => any;
+    target: HTMLElement;
+    compositionStartOffset: number;
+    oncandidatewindowhide: (ev: any) => any;
+    oncandidatewindowupdate: (ev: any) => any;
+    compositionEndOffset: number;
+    getCompositionAlternatives(): string[];
+    getCandidateWindowClientRect(): ClientRect;
+    hasComposition(): boolean;
+    isCandidateWindowVisible(): boolean;
+}
+
+interface DeviceRotationRate {
+    gamma: number;
+    alpha: number;
+    beta: number;
+}
+
+interface PluginArray {
+    length: number;
+    refresh(reload?: boolean): void;
+    item(index: number): Plugin;
+    [index: number]: Plugin;
+    namedItem(name: string): Plugin;
+    //[name: string]: Plugin;
+}
+
+interface MSMediaKeyError {
+    systemCode: number;
+    code: number;
+    MS_MEDIA_KEYERR_SERVICE: number;
+    MS_MEDIA_KEYERR_HARDWARECHANGE: number;
+    MS_MEDIA_KEYERR_OUTPUT: number;
+    MS_MEDIA_KEYERR_DOMAIN: number;
+    MS_MEDIA_KEYERR_UNKNOWN: number;
+    MS_MEDIA_KEYERR_CLIENT: number;
+}
+declare var MSMediaKeyError: {
+    MS_MEDIA_KEYERR_SERVICE: number;
+    MS_MEDIA_KEYERR_HARDWARECHANGE: number;
+    MS_MEDIA_KEYERR_OUTPUT: number;
+    MS_MEDIA_KEYERR_DOMAIN: number;
+    MS_MEDIA_KEYERR_UNKNOWN: number;
+    MS_MEDIA_KEYERR_CLIENT: number;
+}
+
+interface Plugin {
+    length: number;
+    filename: string;
+    version: string;
+    name: string;
+    description: string;
+    item(index: number): MimeType;
+    [index: number]: MimeType;
+    namedItem(type: string): MimeType;
+    //[type: string]: MimeType;
+}
+
+interface HTMLFrameSetElement {
+    onpageshow: (ev: PageTransitionEvent) => any;
+    onpagehide: (ev: PageTransitionEvent) => any;
+}
+
+interface Screen extends EventTarget {
+    msOrientation: string;
+    onmsorientationchange: (ev: any) => any;
+    msLockOrientation(orientation: string): boolean;
+    msLockOrientation(orientations: string[]): boolean;
+    msUnlockOrientation(): void;
+}
+
+interface MediaSource extends EventTarget {
+    sourceBuffers: SourceBufferList;
+    duration: number;
+    readyState: string;
+    activeSourceBuffers: SourceBufferList;
+    addSourceBuffer(type: string): SourceBuffer;
+    endOfStream(error?: string): void;
+    isTypeSupported(type: string): boolean;
+    removeSourceBuffer(sourceBuffer: SourceBuffer): void;
+}
+declare var MediaSource: {
+    prototype: MediaSource;
+    new (): MediaSource;
+}
+
+interface MediaError {
+    MS_MEDIA_ERR_ENCRYPTED: number;
+}
+//declare var MediaError: {
+//    MS_MEDIA_ERR_ENCRYPTED: number;
+//}
+
+interface SourceBufferList extends EventTarget {
+    length: number;
+    item(index: number): SourceBuffer;
+    [index: number]: SourceBuffer;
+}
+
+interface XMLDocument extends Document {
+}
+
+interface DeviceMotionEvent extends Event {
+    rotationRate: DeviceRotationRate;
+    acceleration: DeviceAcceleration;
+    interval: number;
+    accelerationIncludingGravity: DeviceAcceleration;
+    initDeviceMotionEvent(type: string, bubbles: boolean, cancelable: boolean, acceleration: DeviceAccelerationDict, accelerationIncludingGravity: DeviceAccelerationDict, rotationRate: DeviceRotationRateDict, interval: number): void;
+}
+
+interface MimeType {
+    enabledPlugin: Plugin;
+    suffixes: string;
+    type: string;
+    description: string;
+}
+
+interface PointerEvent extends MouseEvent {
+    width: number;
+    rotation: number;
+    pressure: number;
+    pointerType: any;
+    isPrimary: boolean;
+    tiltY: number;
+    height: number;
+    intermediatePoints: any;
+    currentPoint: any;
+    tiltX: number;
+    hwTimestamp: number;
+    pointerId: number;
+    initPointerEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget, offsetXArg: number, offsetYArg: number, widthArg: number, heightArg: number, pressure: number, rotation: number, tiltX: number, tiltY: number, pointerIdArg: number, pointerType: any, hwTimestampArg: number, isPrimary: boolean): void;
+    getCurrentPoint(element: Element): void;
+    getIntermediatePoints(element: Element): void;
+}
+
+interface MSDocumentExtensions {
+    captureEvents(): void;
+    releaseEvents(): void;
+}
+
+interface HTMLElement {
+    dataset: DOMStringMap;
+    hidden: boolean;
+    msGetInputContext(): MSInputMethodContext;
+}
+
+interface MutationObserver {
+    observe(target: Node, options: MutationObserverInit): void;
+    takeRecords(): MutationRecord[];
+    disconnect(): void;
+}
+declare var MutationObserver: {
+    prototype: MutationObserver;
+    new (): MutationObserver;
+}
+
+interface AudioTrackList {
+    onremovetrack: (ev: PluginArray) => any;
+}
+
+interface HTMLObjectElement {
+    /**
+      * Gets or sets the path to the preferred media source. This enables the Play To target device to stream the media content, which can be DRM protected, from a different location, such as a cloud media server.
+      */
+    msPlayToPreferredSourceUri: string;
+    /**
+      * Gets or sets the primary DLNA PlayTo device.
+      */
+    msPlayToPrimary: boolean;
+    /**
+      * Gets or sets whether the DLNA PlayTo device is available.
+      */
+    msPlayToDisabled: boolean;
+    readyState: number;
+    /**
+      * Gets the source associated with the media element for use by the PlayToManager.
+      */
+    msPlayToSource: any;
+}
+
+interface HTMLEmbedElement {
+    /**
+      * Gets or sets the path to the preferred media source. This enables the Play To target device to stream the media content, which can be DRM protected, from a different location, such as a cloud media server.
+      */
+    msPlayToPreferredSourceUri: string;
+    /**
+      * Gets or sets the primary DLNA PlayTo device.
+      */
+    msPlayToPrimary: boolean;
+    /**
+      * Gets or sets whether the DLNA PlayTo device is available.
+      */
+    msPlayToDisabled: boolean;
+    readyState: string;
+    /**
+      * Gets the source associated with the media element for use by the PlayToManager.
+      */
+    msPlayToSource: any;
+}
+
+interface MSWebViewAsyncOperation extends EventTarget {
+    target: MSHTMLWebViewElement;
+    oncomplete: (ev: any) => any;
+    error: DOMError;
+    onerror: (ev: any) => any;
+    readyState: number;
+    type: number;
+    result: any;
+    start(): void;
+    ERROR: number;
+    TYPE_CREATE_DATA_PACKAGE_FROM_SELECTION: number;
+    TYPE_INVOKE_SCRIPT: number;
+    COMPLETED: number;
+    TYPE_CAPTURE_PREVIEW_TO_RANDOM_ACCESS_STREAM: number;
+    STARTED: number;
+}
+declare var MSWebViewAsyncOperation: {
+    ERROR: number;
+    TYPE_CREATE_DATA_PACKAGE_FROM_SELECTION: number;
+    TYPE_INVOKE_SCRIPT: number;
+    COMPLETED: number;
+    TYPE_CAPTURE_PREVIEW_TO_RANDOM_ACCESS_STREAM: number;
+    STARTED: number;
+}
+
+interface ScriptNotifyEvent extends Event {
+    value: string;
+    callingUri: string;
+}
+
+interface PerformanceNavigationTiming extends PerformanceEntry {
+    redirectStart: number;
+    domainLookupEnd: number;
+    responseStart: number;
+    domComplete: number;
+    domainLookupStart: number;
+    loadEventStart: number;
+    unloadEventEnd: number;
+    fetchStart: number;
+    requestStart: number;
+    domInteractive: number;
+    navigationStart: number;
+    connectEnd: number;
+    loadEventEnd: number;
+    connectStart: number;
+    responseEnd: number;
+    domLoading: number;
+    redirectEnd: number;
+    redirectCount: number;
+    unloadEventStart: number;
+    domContentLoadedEventStart: number;
+    domContentLoadedEventEnd: number;
+    type: string;
+}
+
+interface MSMediaKeyNeededEvent extends Event {
+    initData: Uint8Array;
+}
+
+interface MSManipulationEvent {
+    MS_MANIPULATION_STATE_SELECTING: number;
+    MS_MANIPULATION_STATE_COMMITTED: number;
+    MS_MANIPULATION_STATE_PRESELECT: number;
+    MS_MANIPULATION_STATE_DRAGGING: number;
+    MS_MANIPULATION_STATE_CANCELLED: number;
+}
+//declare var MSManipulationEvent: {
+//    MS_MANIPULATION_STATE_SELECTING: number;
+//    MS_MANIPULATION_STATE_COMMITTED: number;
+//    MS_MANIPULATION_STATE_PRESELECT: number;
+//    MS_MANIPULATION_STATE_DRAGGING: number;
+//    MS_MANIPULATION_STATE_CANCELLED: number;
+//}
+
+interface LongRunningScriptDetectedEvent extends Event {
+    stopPageScriptExecution: boolean;
+    executionTime: number;
+}
+
+interface MSAppView {
+    viewId: number;
+    close(): void;
+    postMessage(message: any, targetOrigin: string, ports?: any): void;
+}
+
+interface PerfWidgetExternal {
+    maxCpuSpeed: number;
+    independentRenderingEnabled: boolean;
+    irDisablingContentString: string;
+    irStatusAvailable: boolean;
+    performanceCounter: number;
+    averagePaintTime: number;
+    activeNetworkRequestCount: number;
+    paintRequestsPerSecond: number;
+    extraInformationEnabled: boolean;
+    performanceCounterFrequency: number;
+    averageFrameTime: number;
+    repositionWindow(x: number, y: number): void;
+    getRecentMemoryUsage(last: number): any;
+    getMemoryUsage(): number;
+    resizeWindow(width: number, height: number): void;
+    getProcessCpuUsage(): number;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+    removeEventListener(eventType: string, callback: (ev: any) => any): void;
+    getRecentCpuUsage(last: number): any;
+    addEventListener(eventType: string, callback: (ev: any) => any): void;
+    getRecentFrames(last: number): any;
+    getRecentPaintRequests(last: number): any;
+}
+
+interface PageTransitionEvent extends Event {
+    persisted: boolean;
+}
+
+interface MutationCallback {
+    (mutations: MutationRecord[], observer: MutationObserver): void;
+}
+
+interface HTMLDocument extends Document {
+}
+
+interface KeyPair {
+    privateKey: Key;
+    publicKey: Key;
+}
+
+interface MSApp {
+    getViewOpener(): MSAppView;
+    suppressSubdownloadCredentialPrompts(suppress: boolean): void;
+    execAsyncAtPriority(asynchronousCallback: MSExecAtPriorityFunctionCallback, priority: string, ...args: any[]): void;
+    isTaskScheduledAtPriorityOrHigher(priority: string): boolean;
+    execAtPriority(synchronousCallback: MSExecAtPriorityFunctionCallback, priority: string, ...args: any[]): any;
+    createNewView(uri: string): MSAppView;
+    getCurrentPriority(): string;
+    NORMAL: string;
+    HIGH: string;
+    IDLE: string;
+    CURRENT: string;
+}
+//declare var MSApp: {
+//    NORMAL: string;
+//    HIGH: string;
+//    IDLE: string;
+//    CURRENT: string;
+//}
+
+interface MSMediaKeySession extends EventTarget {
+    sessionId: string;
+    error: MSMediaKeyError;
+    keySystem: string;
+    close(): void;
+    update(key: Uint8Array): void;
+}
+
+interface HTMLTrackElement {
+    readyState: number;
+    ERROR: number;
+    LOADING: number;
+    LOADED: number;
+    NONE: number;
+}
+//declare var HTMLTrackElement: {
+//    ERROR: number;
+//    LOADING: number;
+//    LOADED: number;
+//    NONE: number;
+//}
+
+interface HTMLVideoElement {
+    getVideoPlaybackQuality(): VideoPlaybackQuality;
+}
+
+interface UnviewableContentIdentifiedEvent extends NavigationEvent {
+    referrer: string;
+}
+
+interface CryptoOperation extends EventTarget {
+    algorithm: Algorithm;
+    oncomplete: (ev: any) => any;
+    onerror: (ev: any) => any;
+    onprogress: (ev: any) => any;
+    onabort: (ev: any) => any;
+    key: Key;
+    result: any;
+    abort(): void;
+    finish(): void;
+    process(buffer: ArrayBufferView): void;
+}
+
+declare var onpageshow: (ev: PageTransitionEvent) => any;
+declare var ondevicemotion: (ev: DeviceMotionEvent) => any;
+declare var devicePixelRatio: number;
+declare var msCrypto: Crypto;
+declare var ondeviceorientation: (ev: DeviceOrientationEvent) => any;
+declare var doNotTrack: string;
+declare var onmspointerenter: (ev: any) => any;
+declare var onpagehide: (ev: PageTransitionEvent) => any;
+declare var onmspointerleave: (ev: any) => any;
+declare var onpointerenter: (ev: PointerEvent) => any;
+declare var onpointerout: (ev: PointerEvent) => any;
+declare var onpointerdown: (ev: PointerEvent) => any;
+declare var onpointerup: (ev: PointerEvent) => any;
+declare var onpointercancel: (ev: PointerEvent) => any;
+declare var onpointerover: (ev: PointerEvent) => any;
+declare var onpointermove: (ev: PointerEvent) => any;
+declare var onpointerleave: (ev: PointerEvent) => any;
+
+
+/////////////////////////////
+/// WebGL APIs 
+/////////////////////////////
+
+
+interface WebGLTexture extends WebGLObject {
+}
+
+interface OES_texture_float {
+}
+
+interface WebGLContextEvent extends Event {
+    statusMessage: string;
+}
+declare var WebGLContextEvent: {
+    prototype: WebGLContextEvent;
+    new (): WebGLContextEvent;
+}
+
+interface WebGLRenderbuffer extends WebGLObject {
+}
+
+interface WebGLUniformLocation {
+}
+
+interface WebGLActiveInfo {
+    name: string;
+    type: number;
+    size: number;
+}
+
+interface WEBGL_compressed_texture_s3tc {
+    COMPRESSED_RGBA_S3TC_DXT1_EXT: number;
+    COMPRESSED_RGBA_S3TC_DXT5_EXT: number;
+    COMPRESSED_RGBA_S3TC_DXT3_EXT: number;
+    COMPRESSED_RGB_S3TC_DXT1_EXT: number;
+}
+declare var WEBGL_compressed_texture_s3tc: {
+    COMPRESSED_RGBA_S3TC_DXT1_EXT: number;
+    COMPRESSED_RGBA_S3TC_DXT5_EXT: number;
+    COMPRESSED_RGBA_S3TC_DXT3_EXT: number;
+    COMPRESSED_RGB_S3TC_DXT1_EXT: number;
+}
+
+interface WebGLContextAttributes {
+    alpha: boolean;
+    depth: boolean;
+    stencil: boolean;
+    antialias: boolean;
+    premultipliedAlpha: boolean;
+    preserveDrawingBuffer: boolean;
+}
+
+interface WebGLRenderingContext {
+    drawingBufferWidth: number;
+    drawingBufferHeight: number;
+    canvas: HTMLCanvasElement;
+    getUniformLocation(program: WebGLProgram, name: string): WebGLUniformLocation;
+    bindTexture(target: number, texture: WebGLTexture): void;
+    bufferData(target: number, data: ArrayBufferView, usage: number): void;
+    bufferData(target: number, data: ArrayBuffer, usage: number): void;
+    bufferData(target: number, size: number, usage: number): void;
+    depthMask(flag: boolean): void;
+    getUniform(program: WebGLProgram, location: WebGLUniformLocation): any;
+    vertexAttrib3fv(indx: number, values: number[]): void;
+    vertexAttrib3fv(indx: number, values: Float32Array): void;
+    linkProgram(program: WebGLProgram): void;
+    getSupportedExtensions(): string[];
+    bufferSubData(target: number, offset: number, data: ArrayBuffer): void;
+    bufferSubData(target: number, offset: number, data: ArrayBufferView): void;
+    vertexAttribPointer(indx: number, size: number, type: number, normalized: boolean, stride: number, offset: number): void;
+    polygonOffset(factor: number, units: number): void;
+    blendColor(red: number, green: number, blue: number, alpha: number): void;
+    createTexture(): WebGLTexture;
+    hint(target: number, mode: number): void;
+    getVertexAttrib(index: number, pname: number): any;
+    enableVertexAttribArray(index: number): void;
+    depthRange(zNear: number, zFar: number): void;
+    cullFace(mode: number): void;
+    createFramebuffer(): WebGLFramebuffer;
+    uniformMatrix4fv(location: WebGLUniformLocation, transpose: boolean, value: number[]): void;
+    uniformMatrix4fv(location: WebGLUniformLocation, transpose: boolean, value: Float32Array): void;
+    framebufferTexture2D(target: number, attachment: number, textarget: number, texture: WebGLTexture, level: number): void;
+    deleteFramebuffer(framebuffer: WebGLFramebuffer): void;
+    colorMask(red: boolean, green: boolean, blue: boolean, alpha: boolean): void;
+    compressedTexImage2D(target: number, level: number, internalformat: number, width: number, height: number, border: number, data: ArrayBufferView): void;
+    uniformMatrix2fv(location: WebGLUniformLocation, transpose: boolean, value: number[]): void;
+    uniformMatrix2fv(location: WebGLUniformLocation, transpose: boolean, value: Float32Array): void;
+    getExtension(name: string): Object;
+    createProgram(): WebGLProgram;
+    deleteShader(shader: WebGLShader): void;
+    getAttachedShaders(program: WebGLProgram): WebGLShader[];
+    enable(cap: number): void;
+    blendEquation(mode: number): void;
+    texImage2D(target: number, level: number, internalformat: number, width: number, height: number, border: number, format: number, type: number, pixels: ArrayBufferView): void;
+    texImage2D(target: number, level: number, internalformat: number, format: number, type: number, image: HTMLImageElement): void;
+    texImage2D(target: number, level: number, internalformat: number, format: number, type: number, canvas: HTMLCanvasElement): void;
+    texImage2D(target: number, level: number, internalformat: number, format: number, type: number, video: HTMLVideoElement): void;
+    texImage2D(target: number, level: number, internalformat: number, format: number, type: number, pixels: ImageData): void;
+    createBuffer(): WebGLBuffer;
+    deleteTexture(texture: WebGLTexture): void;
+    useProgram(program: WebGLProgram): void;
+    vertexAttrib2fv(indx: number, values: number[]): void;
+    vertexAttrib2fv(indx: number, values: Float32Array): void;
+    checkFramebufferStatus(target: number): number;
+    frontFace(mode: number): void;
+    getBufferParameter(target: number, pname: number): any;
+    texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, width: number, height: number, format: number, type: number, pixels: ArrayBufferView): void;
+    texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, image: HTMLImageElement): void;
+    texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, canvas: HTMLCanvasElement): void;
+    texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, video: HTMLVideoElement): void;
+    texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, pixels: ImageData): void;
+    copyTexImage2D(target: number, level: number, internalformat: number, x: number, y: number, width: number, height: number, border: number): void;
+    getVertexAttribOffset(index: number, pname: number): number;
+    disableVertexAttribArray(index: number): void;
+    blendFunc(sfactor: number, dfactor: number): void;
+    drawElements(mode: number, count: number, type: number, offset: number): void;
+    isFramebuffer(framebuffer: WebGLFramebuffer): boolean;
+    uniform3iv(location: WebGLUniformLocation, v: number[]): void;
+    uniform3iv(location: WebGLUniformLocation, v: Int32Array): void;
+    lineWidth(width: number): void;
+    getShaderInfoLog(shader: WebGLShader): string;
+    getTexParameter(target: number, pname: number): any;
+    getParameter(pname: number): any;
+    getShaderPrecisionFormat(shadertype: number, precisiontype: number): WebGLShaderPrecisionFormat;
+    getContextAttributes(): WebGLContextAttributes;
+    vertexAttrib1f(indx: number, x: number): void;
+    bindFramebuffer(target: number, framebuffer: WebGLFramebuffer): void;
+    compressedTexSubImage2D(target: number, level: number, xoffset: number, yoffset: number, width: number, height: number, format: number, data: ArrayBufferView): void;
+    isContextLost(): boolean;
+    uniform1iv(location: WebGLUniformLocation, v: number[]): void;
+    uniform1iv(location: WebGLUniformLocation, v: Int32Array): void;
+    getRenderbufferParameter(target: number, pname: number): any;
+    uniform2fv(location: WebGLUniformLocation, v: number[]): void;
+    uniform2fv(location: WebGLUniformLocation, v: Float32Array): void;
+    isTexture(texture: WebGLTexture): boolean;
+    getError(): number;
+    shaderSource(shader: WebGLShader, source: string): void;
+    deleteRenderbuffer(renderbuffer: WebGLRenderbuffer): void;
+    stencilMask(mask: number): void;
+    bindBuffer(target: number, buffer: WebGLBuffer): void;
+    getAttribLocation(program: WebGLProgram, name: string): number;
+    uniform3i(location: WebGLUniformLocation, x: number, y: number, z: number): void;
+    blendEquationSeparate(modeRGB: number, modeAlpha: number): void;
+    clear(mask: number): void;
+    blendFuncSeparate(srcRGB: number, dstRGB: number, srcAlpha: number, dstAlpha: number): void;
+    stencilFuncSeparate(face: number, func: number, ref: number, mask: number): void;
+    readPixels(x: number, y: number, width: number, height: number, format: number, type: number, pixels: ArrayBufferView): void;
+    scissor(x: number, y: number, width: number, height: number): void;
+    uniform2i(location: WebGLUniformLocation, x: number, y: number): void;
+    getActiveAttrib(program: WebGLProgram, index: number): WebGLActiveInfo;
+    getShaderSource(shader: WebGLShader): string;
+    generateMipmap(target: number): void;
+    bindAttribLocation(program: WebGLProgram, index: number, name: string): void;
+    uniform1fv(location: WebGLUniformLocation, v: number[]): void;
+    uniform1fv(location: WebGLUniformLocation, v: Float32Array): void;
+    uniform2iv(location: WebGLUniformLocation, v: number[]): void;
+    uniform2iv(location: WebGLUniformLocation, v: Int32Array): void;
+    stencilOp(fail: number, zfail: number, zpass: number): void;
+    uniform4fv(location: WebGLUniformLocation, v: number[]): void;
+    uniform4fv(location: WebGLUniformLocation, v: Float32Array): void;
+    vertexAttrib1fv(indx: number, values: number[]): void;
+    vertexAttrib1fv(indx: number, values: Float32Array): void;
+    flush(): void;
+    uniform4f(location: WebGLUniformLocation, x: number, y: number, z: number, w: number): void;
+    deleteProgram(program: WebGLProgram): void;
+    isRenderbuffer(renderbuffer: WebGLRenderbuffer): boolean;
+    uniform1i(location: WebGLUniformLocation, x: number): void;
+    getProgramParameter(program: WebGLProgram, pname: number): any;
+    getActiveUniform(program: WebGLProgram, index: number): WebGLActiveInfo;
+    stencilFunc(func: number, ref: number, mask: number): void;
+    pixelStorei(pname: number, param: number): void;
+    disable(cap: number): void;
+    vertexAttrib4fv(indx: number, values: number[]): void;
+    vertexAttrib4fv(indx: number, values: Float32Array): void;
+    createRenderbuffer(): WebGLRenderbuffer;
+    isBuffer(buffer: WebGLBuffer): boolean;
+    stencilOpSeparate(face: number, fail: number, zfail: number, zpass: number): void;
+    getFramebufferAttachmentParameter(target: number, attachment: number, pname: number): any;
+    uniform4i(location: WebGLUniformLocation, x: number, y: number, z: number, w: number): void;
+    sampleCoverage(value: number, invert: boolean): void;
+    depthFunc(func: number): void;
+    texParameterf(target: number, pname: number, param: number): void;
+    vertexAttrib3f(indx: number, x: number, y: number, z: number): void;
+    drawArrays(mode: number, first: number, count: number): void;
+    texParameteri(target: number, pname: number, param: number): void;
+    vertexAttrib4f(indx: number, x: number, y: number, z: number, w: number): void;
+    getShaderParameter(shader: WebGLShader, pname: number): any;
+    clearDepth(depth: number): void;
+    activeTexture(texture: number): void;
+    viewport(x: number, y: number, width: number, height: number): void;
+    detachShader(program: WebGLProgram, shader: WebGLShader): void;
+    uniform1f(location: WebGLUniformLocation, x: number): void;
+    uniformMatrix3fv(location: WebGLUniformLocation, transpose: boolean, value: number[]): void;
+    uniformMatrix3fv(location: WebGLUniformLocation, transpose: boolean, value: Float32Array): void;
+    deleteBuffer(buffer: WebGLBuffer): void;
+    copyTexSubImage2D(target: number, level: number, xoffset: number, yoffset: number, x: number, y: number, width: number, height: number): void;
+    uniform3fv(location: WebGLUniformLocation, v: number[]): void;
+    uniform3fv(location: WebGLUniformLocation, v: Float32Array): void;
+    stencilMaskSeparate(face: number, mask: number): void;
+    attachShader(program: WebGLProgram, shader: WebGLShader): void;
+    compileShader(shader: WebGLShader): void;
+    clearColor(red: number, green: number, blue: number, alpha: number): void;
+    isShader(shader: WebGLShader): boolean;
+    clearStencil(s: number): void;
+    framebufferRenderbuffer(target: number, attachment: number, renderbuffertarget: number, renderbuffer: WebGLRenderbuffer): void;
+    finish(): void;
+    uniform2f(location: WebGLUniformLocation, x: number, y: number): void;
+    renderbufferStorage(target: number, internalformat: number, width: number, height: number): void;
+    uniform3f(location: WebGLUniformLocation, x: number, y: number, z: number): void;
+    getProgramInfoLog(program: WebGLProgram): string;
+    validateProgram(program: WebGLProgram): void;
+    isEnabled(cap: number): boolean;
+    vertexAttrib2f(indx: number, x: number, y: number): void;
+    isProgram(program: WebGLProgram): boolean;
+    createShader(type: number): WebGLShader;
+    bindRenderbuffer(target: number, renderbuffer: WebGLRenderbuffer): void;
+    uniform4iv(location: WebGLUniformLocation, v: number[]): void;
+    uniform4iv(location: WebGLUniformLocation, v: Int32Array): void;
+    DEPTH_FUNC: number;
+    DEPTH_COMPONENT16: number;
+    REPLACE: number;
+    REPEAT: number;
+    VERTEX_ATTRIB_ARRAY_ENABLED: number;
+    FRAMEBUFFER_INCOMPLETE_DIMENSIONS: number;
+    STENCIL_BUFFER_BIT: number;
+    RENDERER: number;
+    STENCIL_BACK_REF: number;
+    TEXTURE26: number;
+    RGB565: number;
+    DITHER: number;
+    CONSTANT_COLOR: number;
+    GENERATE_MIPMAP_HINT: number;
+    POINTS: number;
+    DECR: number;
+    INT_VEC3: number;
+    TEXTURE28: number;
+    ONE_MINUS_CONSTANT_ALPHA: number;
+    BACK: number;
+    RENDERBUFFER_STENCIL_SIZE: number;
+    UNPACK_FLIP_Y_WEBGL: number;
+    BLEND: number;
+    TEXTURE9: number;
+    ARRAY_BUFFER_BINDING: number;
+    MAX_VIEWPORT_DIMS: number;
+    INVALID_FRAMEBUFFER_OPERATION: number;
+    TEXTURE: number;
+    TEXTURE0: number;
+    TEXTURE31: number;
+    TEXTURE24: number;
+    HIGH_INT: number;
+    RENDERBUFFER_BINDING: number;
+    BLEND_COLOR: number;
+    FASTEST: number;
+    STENCIL_WRITEMASK: number;
+    ALIASED_POINT_SIZE_RANGE: number;
+    TEXTURE12: number;
+    DST_ALPHA: number;
+    BLEND_EQUATION_RGB: number;
+    FRAMEBUFFER_COMPLETE: number;
+    NEAREST_MIPMAP_NEAREST: number;
+    VERTEX_ATTRIB_ARRAY_SIZE: number;
+    TEXTURE3: number;
+    DEPTH_WRITEMASK: number;
+    CONTEXT_LOST_WEBGL: number;
+    INVALID_VALUE: number;
+    TEXTURE_MAG_FILTER: number;
+    ONE_MINUS_CONSTANT_COLOR: number;
+    ONE_MINUS_SRC_ALPHA: number;
+    TEXTURE_CUBE_MAP_POSITIVE_Z: number;
+    NOTEQUAL: number;
+    ALPHA: number;
+    DEPTH_STENCIL: number;
+    MAX_VERTEX_UNIFORM_VECTORS: number;
+    DEPTH_COMPONENT: number;
+    RENDERBUFFER_RED_SIZE: number;
+    TEXTURE20: number;
+    RED_BITS: number;
+    RENDERBUFFER_BLUE_SIZE: number;
+    SCISSOR_BOX: number;
+    VENDOR: number;
+    FRONT_AND_BACK: number;
+    CONSTANT_ALPHA: number;
+    VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: number;
+    NEAREST: number;
+    CULL_FACE: number;
+    ALIASED_LINE_WIDTH_RANGE: number;
+    TEXTURE19: number;
+    FRONT: number;
+    DEPTH_CLEAR_VALUE: number;
+    GREEN_BITS: number;
+    TEXTURE29: number;
+    TEXTURE23: number;
+    MAX_RENDERBUFFER_SIZE: number;
+    STENCIL_ATTACHMENT: number;
+    TEXTURE27: number;
+    BOOL_VEC2: number;
+    OUT_OF_MEMORY: number;
+    MIRRORED_REPEAT: number;
+    POLYGON_OFFSET_UNITS: number;
+    TEXTURE_MIN_FILTER: number;
+    STENCIL_BACK_PASS_DEPTH_PASS: number;
+    LINE_LOOP: number;
+    FLOAT_MAT3: number;
+    TEXTURE14: number;
+    LINEAR: number;
+    RGB5_A1: number;
+    ONE_MINUS_SRC_COLOR: number;
+    SAMPLE_COVERAGE_INVERT: number;
+    DONT_CARE: number;
+    FRAMEBUFFER_BINDING: number;
+    RENDERBUFFER_ALPHA_SIZE: number;
+    STENCIL_REF: number;
+    ZERO: number;
+    DECR_WRAP: number;
+    SAMPLE_COVERAGE: number;
+    STENCIL_BACK_FUNC: number;
+    TEXTURE30: number;
+    VIEWPORT: number;
+    STENCIL_BITS: number;
+    FLOAT: number;
+    COLOR_WRITEMASK: number;
+    SAMPLE_COVERAGE_VALUE: number;
+    TEXTURE_CUBE_MAP_NEGATIVE_Y: number;
+    STENCIL_BACK_FAIL: number;
+    FLOAT_MAT4: number;
+    UNSIGNED_SHORT_4_4_4_4: number;
+    TEXTURE6: number;
+    RENDERBUFFER_WIDTH: number;
+    RGBA4: number;
+    ALWAYS: number;
+    BLEND_EQUATION_ALPHA: number;
+    COLOR_BUFFER_BIT: number;
+    TEXTURE_CUBE_MAP: number;
+    DEPTH_BUFFER_BIT: number;
+    STENCIL_CLEAR_VALUE: number;
+    BLEND_EQUATION: number;
+    RENDERBUFFER_GREEN_SIZE: number;
+    NEAREST_MIPMAP_LINEAR: number;
+    VERTEX_ATTRIB_ARRAY_TYPE: number;
+    INCR_WRAP: number;
+    ONE_MINUS_DST_COLOR: number;
+    HIGH_FLOAT: number;
+    BYTE: number;
+    FRONT_FACE: number;
+    SAMPLE_ALPHA_TO_COVERAGE: number;
+    CCW: number;
+    TEXTURE13: number;
+    MAX_VERTEX_ATTRIBS: number;
+    MAX_VERTEX_TEXTURE_IMAGE_UNITS: number;
+    TEXTURE_WRAP_T: number;
+    UNPACK_PREMULTIPLY_ALPHA_WEBGL: number;
+    FLOAT_VEC2: number;
+    LUMINANCE: number;
+    GREATER: number;
+    INT_VEC2: number;
+    VALIDATE_STATUS: number;
+    FRAMEBUFFER: number;
+    FRAMEBUFFER_UNSUPPORTED: number;
+    TEXTURE5: number;
+    FUNC_SUBTRACT: number;
+    BLEND_DST_ALPHA: number;
+    SAMPLER_CUBE: number;
+    ONE_MINUS_DST_ALPHA: number;
+    LESS: number;
+    TEXTURE_CUBE_MAP_POSITIVE_X: number;
+    BLUE_BITS: number;
+    DEPTH_TEST: number;
+    VERTEX_ATTRIB_ARRAY_STRIDE: number;
+    DELETE_STATUS: number;
+    TEXTURE18: number;
+    POLYGON_OFFSET_FACTOR: number;
+    UNSIGNED_INT: number;
+    TEXTURE_2D: number;
+    DST_COLOR: number;
+    FLOAT_MAT2: number;
+    COMPRESSED_TEXTURE_FORMATS: number;
+    MAX_FRAGMENT_UNIFORM_VECTORS: number;
+    DEPTH_STENCIL_ATTACHMENT: number;
+    LUMINANCE_ALPHA: number;
+    CW: number;
+    VERTEX_ATTRIB_ARRAY_NORMALIZED: number;
+    TEXTURE_CUBE_MAP_NEGATIVE_Z: number;
+    LINEAR_MIPMAP_LINEAR: number;
+    BUFFER_SIZE: number;
+    SAMPLE_BUFFERS: number;
+    TEXTURE15: number;
+    ACTIVE_TEXTURE: number;
+    VERTEX_SHADER: number;
+    TEXTURE22: number;
+    VERTEX_ATTRIB_ARRAY_POINTER: number;
+    INCR: number;
+    COMPILE_STATUS: number;
+    MAX_COMBINED_TEXTURE_IMAGE_UNITS: number;
+    TEXTURE7: number;
+    UNSIGNED_SHORT_5_5_5_1: number;
+    DEPTH_BITS: number;
+    RGBA: number;
+    TRIANGLE_STRIP: number;
+    COLOR_CLEAR_VALUE: number;
+    BROWSER_DEFAULT_WEBGL: number;
+    INVALID_ENUM: number;
+    SCISSOR_TEST: number;
+    LINE_STRIP: number;
+    FRAMEBUFFER_INCOMPLETE_ATTACHMENT: number;
+    STENCIL_FUNC: number;
+    FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: number;
+    RENDERBUFFER_HEIGHT: number;
+    TEXTURE8: number;
+    TRIANGLES: number;
+    FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: number;
+    STENCIL_BACK_VALUE_MASK: number;
+    TEXTURE25: number;
+    RENDERBUFFER: number;
+    LEQUAL: number;
+    TEXTURE1: number;
+    STENCIL_INDEX8: number;
+    FUNC_ADD: number;
+    STENCIL_FAIL: number;
+    BLEND_SRC_ALPHA: number;
+    BOOL: number;
+    ALPHA_BITS: number;
+    LOW_INT: number;
+    TEXTURE10: number;
+    SRC_COLOR: number;
+    MAX_VARYING_VECTORS: number;
+    BLEND_DST_RGB: number;
+    TEXTURE_BINDING_CUBE_MAP: number;
+    STENCIL_INDEX: number;
+    TEXTURE_BINDING_2D: number;
+    MEDIUM_INT: number;
+    SHADER_TYPE: number;
+    POLYGON_OFFSET_FILL: number;
+    DYNAMIC_DRAW: number;
+    TEXTURE4: number;
+    STENCIL_BACK_PASS_DEPTH_FAIL: number;
+    STREAM_DRAW: number;
+    MAX_CUBE_MAP_TEXTURE_SIZE: number;
+    TEXTURE17: number;
+    TRIANGLE_FAN: number;
+    UNPACK_ALIGNMENT: number;
+    CURRENT_PROGRAM: number;
+    LINES: number;
+    INVALID_OPERATION: number;
+    FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: number;
+    LINEAR_MIPMAP_NEAREST: number;
+    CLAMP_TO_EDGE: number;
+    RENDERBUFFER_DEPTH_SIZE: number;
+    TEXTURE_WRAP_S: number;
+    ELEMENT_ARRAY_BUFFER: number;
+    UNSIGNED_SHORT_5_6_5: number;
+    ACTIVE_UNIFORMS: number;
+    FLOAT_VEC3: number;
+    NO_ERROR: number;
+    ATTACHED_SHADERS: number;
+    DEPTH_ATTACHMENT: number;
+    TEXTURE11: number;
+    STENCIL_TEST: number;
+    ONE: number;
+    FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: number;
+    STATIC_DRAW: number;
+    GEQUAL: number;
+    BOOL_VEC4: number;
+    COLOR_ATTACHMENT0: number;
+    PACK_ALIGNMENT: number;
+    MAX_TEXTURE_SIZE: number;
+    STENCIL_PASS_DEPTH_FAIL: number;
+    CULL_FACE_MODE: number;
+    TEXTURE16: number;
+    STENCIL_BACK_WRITEMASK: number;
+    SRC_ALPHA: number;
+    UNSIGNED_SHORT: number;
+    TEXTURE21: number;
+    FUNC_REVERSE_SUBTRACT: number;
+    SHADING_LANGUAGE_VERSION: number;
+    EQUAL: number;
+    FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: number;
+    BOOL_VEC3: number;
+    SAMPLER_2D: number;
+    TEXTURE_CUBE_MAP_NEGATIVE_X: number;
+    MAX_TEXTURE_IMAGE_UNITS: number;
+    TEXTURE_CUBE_MAP_POSITIVE_Y: number;
+    RENDERBUFFER_INTERNAL_FORMAT: number;
+    STENCIL_VALUE_MASK: number;
+    ELEMENT_ARRAY_BUFFER_BINDING: number;
+    ARRAY_BUFFER: number;
+    DEPTH_RANGE: number;
+    NICEST: number;
+    ACTIVE_ATTRIBUTES: number;
+    NEVER: number;
+    FLOAT_VEC4: number;
+    CURRENT_VERTEX_ATTRIB: number;
+    STENCIL_PASS_DEPTH_PASS: number;
+    INVERT: number;
+    LINK_STATUS: number;
+    RGB: number;
+    INT_VEC4: number;
+    TEXTURE2: number;
+    UNPACK_COLORSPACE_CONVERSION_WEBGL: number;
+    MEDIUM_FLOAT: number;
+    SRC_ALPHA_SATURATE: number;
+    BUFFER_USAGE: number;
+    SHORT: number;
+    NONE: number;
+    UNSIGNED_BYTE: number;
+    INT: number;
+    SUBPIXEL_BITS: number;
+    KEEP: number;
+    SAMPLES: number;
+    FRAGMENT_SHADER: number;
+    LINE_WIDTH: number;
+    BLEND_SRC_RGB: number;
+    LOW_FLOAT: number;
+    VERSION: number;
+}
+declare var WebGLRenderingContext: {
+    DEPTH_FUNC: number;
+    DEPTH_COMPONENT16: number;
+    REPLACE: number;
+    REPEAT: number;
+    VERTEX_ATTRIB_ARRAY_ENABLED: number;
+    FRAMEBUFFER_INCOMPLETE_DIMENSIONS: number;
+    STENCIL_BUFFER_BIT: number;
+    RENDERER: number;
+    STENCIL_BACK_REF: number;
+    TEXTURE26: number;
+    RGB565: number;
+    DITHER: number;
+    CONSTANT_COLOR: number;
+    GENERATE_MIPMAP_HINT: number;
+    POINTS: number;
+    DECR: number;
+    INT_VEC3: number;
+    TEXTURE28: number;
+    ONE_MINUS_CONSTANT_ALPHA: number;
+    BACK: number;
+    RENDERBUFFER_STENCIL_SIZE: number;
+    UNPACK_FLIP_Y_WEBGL: number;
+    BLEND: number;
+    TEXTURE9: number;
+    ARRAY_BUFFER_BINDING: number;
+    MAX_VIEWPORT_DIMS: number;
+    INVALID_FRAMEBUFFER_OPERATION: number;
+    TEXTURE: number;
+    TEXTURE0: number;
+    TEXTURE31: number;
+    TEXTURE24: number;
+    HIGH_INT: number;
+    RENDERBUFFER_BINDING: number;
+    BLEND_COLOR: number;
+    FASTEST: number;
+    STENCIL_WRITEMASK: number;
+    ALIASED_POINT_SIZE_RANGE: number;
+    TEXTURE12: number;
+    DST_ALPHA: number;
+    BLEND_EQUATION_RGB: number;
+    FRAMEBUFFER_COMPLETE: number;
+    NEAREST_MIPMAP_NEAREST: number;
+    VERTEX_ATTRIB_ARRAY_SIZE: number;
+    TEXTURE3: number;
+    DEPTH_WRITEMASK: number;
+    CONTEXT_LOST_WEBGL: number;
+    INVALID_VALUE: number;
+    TEXTURE_MAG_FILTER: number;
+    ONE_MINUS_CONSTANT_COLOR: number;
+    ONE_MINUS_SRC_ALPHA: number;
+    TEXTURE_CUBE_MAP_POSITIVE_Z: number;
+    NOTEQUAL: number;
+    ALPHA: number;
+    DEPTH_STENCIL: number;
+    MAX_VERTEX_UNIFORM_VECTORS: number;
+    DEPTH_COMPONENT: number;
+    RENDERBUFFER_RED_SIZE: number;
+    TEXTURE20: number;
+    RED_BITS: number;
+    RENDERBUFFER_BLUE_SIZE: number;
+    SCISSOR_BOX: number;
+    VENDOR: number;
+    FRONT_AND_BACK: number;
+    CONSTANT_ALPHA: number;
+    VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: number;
+    NEAREST: number;
+    CULL_FACE: number;
+    ALIASED_LINE_WIDTH_RANGE: number;
+    TEXTURE19: number;
+    FRONT: number;
+    DEPTH_CLEAR_VALUE: number;
+    GREEN_BITS: number;
+    TEXTURE29: number;
+    TEXTURE23: number;
+    MAX_RENDERBUFFER_SIZE: number;
+    STENCIL_ATTACHMENT: number;
+    TEXTURE27: number;
+    BOOL_VEC2: number;
+    OUT_OF_MEMORY: number;
+    MIRRORED_REPEAT: number;
+    POLYGON_OFFSET_UNITS: number;
+    TEXTURE_MIN_FILTER: number;
+    STENCIL_BACK_PASS_DEPTH_PASS: number;
+    LINE_LOOP: number;
+    FLOAT_MAT3: number;
+    TEXTURE14: number;
+    LINEAR: number;
+    RGB5_A1: number;
+    ONE_MINUS_SRC_COLOR: number;
+    SAMPLE_COVERAGE_INVERT: number;
+    DONT_CARE: number;
+    FRAMEBUFFER_BINDING: number;
+    RENDERBUFFER_ALPHA_SIZE: number;
+    STENCIL_REF: number;
+    ZERO: number;
+    DECR_WRAP: number;
+    SAMPLE_COVERAGE: number;
+    STENCIL_BACK_FUNC: number;
+    TEXTURE30: number;
+    VIEWPORT: number;
+    STENCIL_BITS: number;
+    FLOAT: number;
+    COLOR_WRITEMASK: number;
+    SAMPLE_COVERAGE_VALUE: number;
+    TEXTURE_CUBE_MAP_NEGATIVE_Y: number;
+    STENCIL_BACK_FAIL: number;
+    FLOAT_MAT4: number;
+    UNSIGNED_SHORT_4_4_4_4: number;
+    TEXTURE6: number;
+    RENDERBUFFER_WIDTH: number;
+    RGBA4: number;
+    ALWAYS: number;
+    BLEND_EQUATION_ALPHA: number;
+    COLOR_BUFFER_BIT: number;
+    TEXTURE_CUBE_MAP: number;
+    DEPTH_BUFFER_BIT: number;
+    STENCIL_CLEAR_VALUE: number;
+    BLEND_EQUATION: number;
+    RENDERBUFFER_GREEN_SIZE: number;
+    NEAREST_MIPMAP_LINEAR: number;
+    VERTEX_ATTRIB_ARRAY_TYPE: number;
+    INCR_WRAP: number;
+    ONE_MINUS_DST_COLOR: number;
+    HIGH_FLOAT: number;
+    BYTE: number;
+    FRONT_FACE: number;
+    SAMPLE_ALPHA_TO_COVERAGE: number;
+    CCW: number;
+    TEXTURE13: number;
+    MAX_VERTEX_ATTRIBS: number;
+    MAX_VERTEX_TEXTURE_IMAGE_UNITS: number;
+    TEXTURE_WRAP_T: number;
+    UNPACK_PREMULTIPLY_ALPHA_WEBGL: number;
+    FLOAT_VEC2: number;
+    LUMINANCE: number;
+    GREATER: number;
+    INT_VEC2: number;
+    VALIDATE_STATUS: number;
+    FRAMEBUFFER: number;
+    FRAMEBUFFER_UNSUPPORTED: number;
+    TEXTURE5: number;
+    FUNC_SUBTRACT: number;
+    BLEND_DST_ALPHA: number;
+    SAMPLER_CUBE: number;
+    ONE_MINUS_DST_ALPHA: number;
+    LESS: number;
+    TEXTURE_CUBE_MAP_POSITIVE_X: number;
+    BLUE_BITS: number;
+    DEPTH_TEST: number;
+    VERTEX_ATTRIB_ARRAY_STRIDE: number;
+    DELETE_STATUS: number;
+    TEXTURE18: number;
+    POLYGON_OFFSET_FACTOR: number;
+    UNSIGNED_INT: number;
+    TEXTURE_2D: number;
+    DST_COLOR: number;
+    FLOAT_MAT2: number;
+    COMPRESSED_TEXTURE_FORMATS: number;
+    MAX_FRAGMENT_UNIFORM_VECTORS: number;
+    DEPTH_STENCIL_ATTACHMENT: number;
+    LUMINANCE_ALPHA: number;
+    CW: number;
+    VERTEX_ATTRIB_ARRAY_NORMALIZED: number;
+    TEXTURE_CUBE_MAP_NEGATIVE_Z: number;
+    LINEAR_MIPMAP_LINEAR: number;
+    BUFFER_SIZE: number;
+    SAMPLE_BUFFERS: number;
+    TEXTURE15: number;
+    ACTIVE_TEXTURE: number;
+    VERTEX_SHADER: number;
+    TEXTURE22: number;
+    VERTEX_ATTRIB_ARRAY_POINTER: number;
+    INCR: number;
+    COMPILE_STATUS: number;
+    MAX_COMBINED_TEXTURE_IMAGE_UNITS: number;
+    TEXTURE7: number;
+    UNSIGNED_SHORT_5_5_5_1: number;
+    DEPTH_BITS: number;
+    RGBA: number;
+    TRIANGLE_STRIP: number;
+    COLOR_CLEAR_VALUE: number;
+    BROWSER_DEFAULT_WEBGL: number;
+    INVALID_ENUM: number;
+    SCISSOR_TEST: number;
+    LINE_STRIP: number;
+    FRAMEBUFFER_INCOMPLETE_ATTACHMENT: number;
+    STENCIL_FUNC: number;
+    FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: number;
+    RENDERBUFFER_HEIGHT: number;
+    TEXTURE8: number;
+    TRIANGLES: number;
+    FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: number;
+    STENCIL_BACK_VALUE_MASK: number;
+    TEXTURE25: number;
+    RENDERBUFFER: number;
+    LEQUAL: number;
+    TEXTURE1: number;
+    STENCIL_INDEX8: number;
+    FUNC_ADD: number;
+    STENCIL_FAIL: number;
+    BLEND_SRC_ALPHA: number;
+    BOOL: number;
+    ALPHA_BITS: number;
+    LOW_INT: number;
+    TEXTURE10: number;
+    SRC_COLOR: number;
+    MAX_VARYING_VECTORS: number;
+    BLEND_DST_RGB: number;
+    TEXTURE_BINDING_CUBE_MAP: number;
+    STENCIL_INDEX: number;
+    TEXTURE_BINDING_2D: number;
+    MEDIUM_INT: number;
+    SHADER_TYPE: number;
+    POLYGON_OFFSET_FILL: number;
+    DYNAMIC_DRAW: number;
+    TEXTURE4: number;
+    STENCIL_BACK_PASS_DEPTH_FAIL: number;
+    STREAM_DRAW: number;
+    MAX_CUBE_MAP_TEXTURE_SIZE: number;
+    TEXTURE17: number;
+    TRIANGLE_FAN: number;
+    UNPACK_ALIGNMENT: number;
+    CURRENT_PROGRAM: number;
+    LINES: number;
+    INVALID_OPERATION: number;
+    FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: number;
+    LINEAR_MIPMAP_NEAREST: number;
+    CLAMP_TO_EDGE: number;
+    RENDERBUFFER_DEPTH_SIZE: number;
+    TEXTURE_WRAP_S: number;
+    ELEMENT_ARRAY_BUFFER: number;
+    UNSIGNED_SHORT_5_6_5: number;
+    ACTIVE_UNIFORMS: number;
+    FLOAT_VEC3: number;
+    NO_ERROR: number;
+    ATTACHED_SHADERS: number;
+    DEPTH_ATTACHMENT: number;
+    TEXTURE11: number;
+    STENCIL_TEST: number;
+    ONE: number;
+    FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: number;
+    STATIC_DRAW: number;
+    GEQUAL: number;
+    BOOL_VEC4: number;
+    COLOR_ATTACHMENT0: number;
+    PACK_ALIGNMENT: number;
+    MAX_TEXTURE_SIZE: number;
+    STENCIL_PASS_DEPTH_FAIL: number;
+    CULL_FACE_MODE: number;
+    TEXTURE16: number;
+    STENCIL_BACK_WRITEMASK: number;
+    SRC_ALPHA: number;
+    UNSIGNED_SHORT: number;
+    TEXTURE21: number;
+    FUNC_REVERSE_SUBTRACT: number;
+    SHADING_LANGUAGE_VERSION: number;
+    EQUAL: number;
+    FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: number;
+    BOOL_VEC3: number;
+    SAMPLER_2D: number;
+    TEXTURE_CUBE_MAP_NEGATIVE_X: number;
+    MAX_TEXTURE_IMAGE_UNITS: number;
+    TEXTURE_CUBE_MAP_POSITIVE_Y: number;
+    RENDERBUFFER_INTERNAL_FORMAT: number;
+    STENCIL_VALUE_MASK: number;
+    ELEMENT_ARRAY_BUFFER_BINDING: number;
+    ARRAY_BUFFER: number;
+    DEPTH_RANGE: number;
+    NICEST: number;
+    ACTIVE_ATTRIBUTES: number;
+    NEVER: number;
+    FLOAT_VEC4: number;
+    CURRENT_VERTEX_ATTRIB: number;
+    STENCIL_PASS_DEPTH_PASS: number;
+    INVERT: number;
+    LINK_STATUS: number;
+    RGB: number;
+    INT_VEC4: number;
+    TEXTURE2: number;
+    UNPACK_COLORSPACE_CONVERSION_WEBGL: number;
+    MEDIUM_FLOAT: number;
+    SRC_ALPHA_SATURATE: number;
+    BUFFER_USAGE: number;
+    SHORT: number;
+    NONE: number;
+    UNSIGNED_BYTE: number;
+    INT: number;
+    SUBPIXEL_BITS: number;
+    KEEP: number;
+    SAMPLES: number;
+    FRAGMENT_SHADER: number;
+    LINE_WIDTH: number;
+    BLEND_SRC_RGB: number;
+    LOW_FLOAT: number;
+    VERSION: number;
+}
+
+interface WebGLProgram extends WebGLObject {
+}
+
+interface OES_standard_derivatives {
+    FRAGMENT_SHADER_DERIVATIVE_HINT_OES: number;
+}
+declare var OES_standard_derivatives: {
+    FRAGMENT_SHADER_DERIVATIVE_HINT_OES: number;
+}
+
+interface WebGLFramebuffer extends WebGLObject {
+}
+
+interface WebGLShader extends WebGLObject {
+}
+
+interface OES_texture_float_linear {
+}
+
+interface WebGLObject {
+}
+
+interface WebGLBuffer extends WebGLObject {
+}
+
+interface WebGLShaderPrecisionFormat {
+    rangeMin: number;
+    rangeMax: number;
+    precision: number;
+}
+
+interface EXT_texture_filter_anisotropic {
+    TEXTURE_MAX_ANISOTROPY_EXT: number;
+    MAX_TEXTURE_MAX_ANISOTROPY_EXT: number;
+}
+declare var EXT_texture_filter_anisotropic: {
+    TEXTURE_MAX_ANISOTROPY_EXT: number;
+    MAX_TEXTURE_MAX_ANISOTROPY_EXT: number;
+}
+
+
+/////////////////////////////
+/// addEventListener overloads
+/////////////////////////////
+
+interface HTMLElement {
+    addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgotpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mslostpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "lostpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "gotpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "move", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "deactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetchanged", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsdelete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "losecapture", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "controlselect", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "layoutcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "filterchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "errorupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "cellchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowexit", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsinserted", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "propertychange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforepaste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecopy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "paste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "moveend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeeditfocus", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "afterupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizeend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dataavailable", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforedeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "activate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "movestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "selectstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "cut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "copy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowenter", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mscontentzoom", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "cuechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "msmanipulationstatechanged", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface Document {
+    addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "deactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetchanged", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsdelete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "controlselect", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "errorupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "msthumbnailclick", listener: (ev: MSSiteModeEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "cellchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowexit", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsinserted", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "propertychange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "stop", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mssitemodejumplistitemremoved", listener: (ev: MSSiteModeEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeeditfocus", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "afterupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "selectionchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "storagecommit", listener: (ev: StorageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dataavailable", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforedeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "activate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "selectstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowenter", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msmanipulationstatechanged", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mscontentzoom", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msfullscreenerror", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msfullscreenchange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface Element {
+    addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgotpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mslostpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "lostpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "gotpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface MSNamespaceInfo {
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface Window {
+    addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "afterprint", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeprint", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "online", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "offline", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeunload", listener: (ev: BeforeUnloadEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "storage", listener: (ev: StorageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "hashchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "popstate", listener: (ev: PopStateEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "pageshow", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "devicemotion", listener: (ev: DeviceMotionEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "deviceorientation", listener: (ev: DeviceOrientationEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "pagehide", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface SVGElement {
+    addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgotpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mslostpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "lostpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "gotpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface HTMLFrameElement {
+    addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgotpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mslostpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "lostpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "gotpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "move", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "deactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetchanged", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsdelete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "losecapture", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "controlselect", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "layoutcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "filterchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "errorupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "cellchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowexit", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsinserted", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "propertychange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforepaste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecopy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "paste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "moveend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeeditfocus", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "afterupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizeend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dataavailable", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforedeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "activate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "movestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "selectstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "cut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "copy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowenter", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mscontentzoom", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "cuechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "msmanipulationstatechanged", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface XMLHttpRequest {
+    addEventListener(type: "timeout", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadend", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface HTMLFrameSetElement {
+    addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgotpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mslostpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "lostpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "gotpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "move", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "deactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetchanged", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsdelete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "losecapture", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "controlselect", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "layoutcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "filterchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "errorupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "cellchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowexit", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsinserted", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "propertychange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforepaste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecopy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "paste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "moveend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeeditfocus", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "afterupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizeend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dataavailable", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforedeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "activate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "movestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "selectstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "cut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "copy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowenter", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mscontentzoom", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "cuechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "msmanipulationstatechanged", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "online", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "afterprint", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeprint", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "offline", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "hashchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeunload", listener: (ev: BeforeUnloadEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "storage", listener: (ev: StorageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pageshow", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pagehide", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface Screen {
+    addEventListener(type: "msorientationchange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface SVGSVGElement {
+    addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgotpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mslostpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "lostpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "gotpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "zoom", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface HTMLIFrameElement {
+    addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgotpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mslostpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "lostpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "gotpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "move", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "deactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetchanged", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsdelete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "losecapture", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "controlselect", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "layoutcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "filterchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "errorupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "cellchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowexit", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsinserted", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "propertychange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforepaste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecopy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "paste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "moveend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeeditfocus", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "afterupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizeend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dataavailable", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforedeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "activate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "movestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "selectstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "cut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "copy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowenter", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mscontentzoom", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "cuechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "msmanipulationstatechanged", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface HTMLBodyElement {
+    addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgotpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mslostpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "lostpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "gotpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "move", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "deactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetchanged", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsdelete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "losecapture", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "controlselect", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "layoutcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "filterchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "errorupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "cellchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowexit", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsinserted", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "propertychange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforepaste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecopy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "paste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "moveend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeeditfocus", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "afterupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizeend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dataavailable", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforedeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "activate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "movestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "selectstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "cut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "copy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowenter", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mscontentzoom", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "cuechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "msmanipulationstatechanged", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "online", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "afterprint", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeprint", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "offline", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "hashchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeunload", listener: (ev: BeforeUnloadEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "storage", listener: (ev: StorageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "popstate", listener: (ev: PopStateEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pageshow", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pagehide", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface XDomainRequest {
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "timeout", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface HTMLMarqueeElement {
+    addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgotpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mslostpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "lostpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "gotpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "move", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "deactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetchanged", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsdelete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "losecapture", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "controlselect", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "layoutcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "filterchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "errorupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "cellchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowexit", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsinserted", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "propertychange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforepaste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecopy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "paste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "moveend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeeditfocus", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "afterupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizeend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dataavailable", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforedeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "activate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "movestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "selectstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "cut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "copy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowenter", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mscontentzoom", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "cuechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "msmanipulationstatechanged", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "bounce", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "start", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "finish", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface MSWindowExtensions {
+    addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface HTMLMediaElement {
+    addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgotpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mslostpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "lostpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "gotpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "move", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "deactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetchanged", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsdelete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "losecapture", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "controlselect", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "layoutcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "filterchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "errorupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "cellchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowexit", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsinserted", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "propertychange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforepaste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecopy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "paste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "moveend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeeditfocus", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "afterupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizeend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dataavailable", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforedeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "activate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "movestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "selectstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "cut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "copy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowenter", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mscontentzoom", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "cuechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "msmanipulationstatechanged", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msneedkey", listener: (ev: MSMediaKeyNeededEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface HTMLVideoElement {
+    addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgotpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mslostpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "lostpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "gotpointercapture", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "move", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "deactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetchanged", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsdelete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "losecapture", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "controlselect", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "layoutcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "filterchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "datasetcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "errorupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "cellchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowexit", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowsinserted", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "propertychange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforepaste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforecopy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "paste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "moveend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforeeditfocus", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "afterupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resizeend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "dataavailable", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "beforedeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "activate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "movestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "selectstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "cut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "copy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "rowenter", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "mscontentzoom", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    addEventListener(type: "cuechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "msmanipulationstatechanged", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "msneedkey", listener: (ev: MSMediaKeyNeededEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "MSVideoOptimalLayoutChanged", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "MSVideoFrameStepCompleted", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "MSVideoFormatChanged", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface TextTrackCue {
+    addEventListener(type: "enter", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "exit", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface WebSocket {
+    addEventListener(type: "open", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "close", listener: (ev: CloseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface XMLHttpRequestEventTarget {
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "timeout", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadend", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface AudioTrackList {
+    addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "addtrack", listener: (ev: TrackEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "removetrack", listener: (ev: any /*PluginArray*/) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface MSBaseReader {
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadend", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+interface IDBTransaction {
+    addEventListener(type: "complete", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface TextTrackList {
+    addEventListener(type: "addtrack", listener: (ev: TrackEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface IDBDatabase {
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface IDBOpenDBRequest {
+    addEventListener(type: "success", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "upgradeneeded", listener: (ev: IDBVersionChangeEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "blocked", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface TextTrack {
+    addEventListener(type: "cuechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface IDBRequest {
+    addEventListener(type: "success", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface MessagePort {
+    addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface ApplicationCache {
+    addEventListener(type: "downloading", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "updateready", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "cached", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "obsolete", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "checking", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "noupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface AbstractWorker {
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+interface Worker {
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface GlobalEventHandlers {
+    addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+interface KeyOperation {
+    addEventListener(type: "complete", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface MSInputMethodContext {
+    addEventListener(type: "candidatewindowshow", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "candidatewindowhide", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: "candidatewindowupdate", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface MSWebViewAsyncOperation {
+    addEventListener(type: "complete", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+interface CryptoOperation {
+    addEventListener(type: "complete", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+}
+
+
+declare function addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "afterprint", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "beforeprint", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "online", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "offline", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "beforeunload", listener: (ev: BeforeUnloadEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "storage", listener: (ev: StorageEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "hashchange", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "popstate", listener: (ev: PopStateEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "pageshow", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "devicemotion", listener: (ev: DeviceMotionEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "deviceorientation", listener: (ev: DeviceOrientationEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "pagehide", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void;
+declare function addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+
+
+/////////////////////////////
+/// WorkerGlobalScope APIs 
+/////////////////////////////
+// TODO: These are only available in a Web Worker - should be in a separate lib file
+declare function importScripts(...urls: string[]): void;
+
+
+/////////////////////////////
+/// Windows Script Host APIS
+/////////////////////////////
+declare var ActiveXObject: { new (s: string): any; };
+
+interface ITextWriter {
+    Write(s: string): void;
+    WriteLine(s: string): void;
+    Close(): void;
+}
+
+declare var WScript: {
+    Echo(s: any): void;
+    StdErr: ITextWriter;
+    StdOut: ITextWriter;
+    Arguments: { length: number; Item(n: number): string; };
+    ScriptFullName: string;
+    Quit(exitCode?: number): number;
+}
diff --git a/_infrastructure/tests/typescript/1.0.0/tsc b/_infrastructure/tests/typescript/1.0.0/tsc
new file mode 100644
index 000000000..3c0dab574
--- /dev/null
+++ b/_infrastructure/tests/typescript/1.0.0/tsc
@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./tsc.js')
diff --git a/_infrastructure/tests/typescript/1.0.0/tsc.js b/_infrastructure/tests/typescript/1.0.0/tsc.js
new file mode 100644
index 000000000..55f7090d3
--- /dev/null
+++ b/_infrastructure/tests/typescript/1.0.0/tsc.js
@@ -0,0 +1,62789 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved. 
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0  
+ 
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
+MERCHANTABLITY OR NON-INFRINGEMENT. 
+ 
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+var TypeScript;
+(function (TypeScript) {
+    TypeScript.DiagnosticCode = {
+        error_TS_0_1: "error TS{0}: {1}",
+        warning_TS_0_1: "warning TS{0}: {1}",
+        Unrecognized_escape_sequence: "Unrecognized escape sequence.",
+        Unexpected_character_0: "Unexpected character {0}.",
+        Missing_close_quote_character: "Missing close quote character.",
+        Identifier_expected: "Identifier expected.",
+        _0_keyword_expected: "'{0}' keyword expected.",
+        _0_expected: "'{0}' expected.",
+        Identifier_expected_0_is_a_keyword: "Identifier expected; '{0}' is a keyword.",
+        Automatic_semicolon_insertion_not_allowed: "Automatic semicolon insertion not allowed.",
+        Unexpected_token_0_expected: "Unexpected token; '{0}' expected.",
+        Trailing_separator_not_allowed: "Trailing separator not allowed.",
+        AsteriskSlash_expected: "'*/' expected.",
+        public_or_private_modifier_must_precede_static: "'public' or 'private' modifier must precede 'static'.",
+        Unexpected_token: "Unexpected token.",
+        Catch_clause_parameter_cannot_have_a_type_annotation: "Catch clause parameter cannot have a type annotation.",
+        Rest_parameter_must_be_last_in_list: "Rest parameter must be last in list.",
+        Parameter_cannot_have_question_mark_and_initializer: "Parameter cannot have question mark and initializer.",
+        Required_parameter_cannot_follow_optional_parameter: "Required parameter cannot follow optional parameter.",
+        Index_signatures_cannot_have_rest_parameters: "Index signatures cannot have rest parameters.",
+        Index_signature_parameter_cannot_have_accessibility_modifiers: "Index signature parameter cannot have accessibility modifiers.",
+        Index_signature_parameter_cannot_have_a_question_mark: "Index signature parameter cannot have a question mark.",
+        Index_signature_parameter_cannot_have_an_initializer: "Index signature parameter cannot have an initializer.",
+        Index_signature_must_have_a_type_annotation: "Index signature must have a type annotation.",
+        Index_signature_parameter_must_have_a_type_annotation: "Index signature parameter must have a type annotation.",
+        Index_signature_parameter_type_must_be_string_or_number: "Index signature parameter type must be 'string' or 'number'.",
+        extends_clause_already_seen: "'extends' clause already seen.",
+        extends_clause_must_precede_implements_clause: "'extends' clause must precede 'implements' clause.",
+        Classes_can_only_extend_a_single_class: "Classes can only extend a single class.",
+        implements_clause_already_seen: "'implements' clause already seen.",
+        Accessibility_modifier_already_seen: "Accessibility modifier already seen.",
+        _0_modifier_must_precede_1_modifier: "'{0}' modifier must precede '{1}' modifier.",
+        _0_modifier_already_seen: "'{0}' modifier already seen.",
+        _0_modifier_cannot_appear_on_a_class_element: "'{0}' modifier cannot appear on a class element.",
+        Interface_declaration_cannot_have_implements_clause: "Interface declaration cannot have 'implements' clause.",
+        super_invocation_cannot_have_type_arguments: "'super' invocation cannot have type arguments.",
+        Only_ambient_modules_can_use_quoted_names: "Only ambient modules can use quoted names.",
+        Statements_are_not_allowed_in_ambient_contexts: "Statements are not allowed in ambient contexts.",
+        Implementations_are_not_allowed_in_ambient_contexts: "Implementations are not allowed in ambient contexts.",
+        declare_modifier_not_allowed_for_code_already_in_an_ambient_context: "'declare' modifier not allowed for code already in an ambient context.",
+        Initializers_are_not_allowed_in_ambient_contexts: "Initializers are not allowed in ambient contexts.",
+        Parameter_property_declarations_can_only_be_used_in_a_non_ambient_constructor_declaration: "Parameter property declarations can only be used in a non-ambient constructor declaration.",
+        Function_implementation_expected: "Function implementation expected.",
+        Constructor_implementation_expected: "Constructor implementation expected.",
+        Function_overload_name_must_be_0: "Function overload name must be '{0}'.",
+        _0_modifier_cannot_appear_on_a_module_element: "'{0}' modifier cannot appear on a module element.",
+        declare_modifier_cannot_appear_on_an_interface_declaration: "'declare' modifier cannot appear on an interface declaration.",
+        declare_modifier_required_for_top_level_element: "'declare' modifier required for top level element.",
+        Rest_parameter_cannot_be_optional: "Rest parameter cannot be optional.",
+        Rest_parameter_cannot_have_an_initializer: "Rest parameter cannot have an initializer.",
+        set_accessor_must_have_one_and_only_one_parameter: "'set' accessor must have one and only one parameter.",
+        set_accessor_parameter_cannot_be_optional: "'set' accessor parameter cannot be optional.",
+        set_accessor_parameter_cannot_have_an_initializer: "'set' accessor parameter cannot have an initializer.",
+        set_accessor_cannot_have_rest_parameter: "'set' accessor cannot have rest parameter.",
+        get_accessor_cannot_have_parameters: "'get' accessor cannot have parameters.",
+        Modifiers_cannot_appear_here: "Modifiers cannot appear here.",
+        Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: "Accessors are only available when targeting ECMAScript 5 and higher.",
+        Class_name_cannot_be_0: "Class name cannot be '{0}'.",
+        Interface_name_cannot_be_0: "Interface name cannot be '{0}'.",
+        Enum_name_cannot_be_0: "Enum name cannot be '{0}'.",
+        Module_name_cannot_be_0: "Module name cannot be '{0}'.",
+        Enum_member_must_have_initializer: "Enum member must have initializer.",
+        Export_assignment_cannot_be_used_in_internal_modules: "Export assignment cannot be used in internal modules.",
+        Export_assignment_not_allowed_in_module_with_exported_element: "Export assignment not allowed in module with exported element.",
+        Module_cannot_have_multiple_export_assignments: "Module cannot have multiple export assignments.",
+        Ambient_enum_elements_can_only_have_integer_literal_initializers: "Ambient enum elements can only have integer literal initializers.",
+        module_class_interface_enum_import_or_statement: "module, class, interface, enum, import or statement",
+        constructor_function_accessor_or_variable: "constructor, function, accessor or variable",
+        statement: "statement",
+        case_or_default_clause: "case or default clause",
+        identifier: "identifier",
+        call_construct_index_property_or_function_signature: "call, construct, index, property or function signature",
+        expression: "expression",
+        type_name: "type name",
+        property_or_accessor: "property or accessor",
+        parameter: "parameter",
+        type: "type",
+        type_parameter: "type parameter",
+        declare_modifier_not_allowed_on_import_declaration: "'declare' modifier not allowed on import declaration.",
+        Function_overload_must_be_static: "Function overload must be static.",
+        Function_overload_must_not_be_static: "Function overload must not be static.",
+        Parameter_property_declarations_cannot_be_used_in_a_constructor_overload: "Parameter property declarations cannot be used in a constructor overload.",
+        Invalid_reference_directive_syntax: "Invalid 'reference' directive syntax.",
+        Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher: "Octal literals are not available when targeting ECMAScript 5 and higher.",
+        Accessors_are_not_allowed_in_ambient_contexts: "Accessors are not allowed in ambient contexts.",
+        _0_modifier_cannot_appear_on_a_constructor_declaration: "'{0}' modifier cannot appear on a constructor declaration.",
+        _0_modifier_cannot_appear_on_a_parameter: "'{0}' modifier cannot appear on a parameter.",
+        Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: "Only a single variable declaration is allowed in a 'for...in' statement.",
+        Type_parameters_cannot_appear_on_a_constructor_declaration: "Type parameters cannot appear on a constructor declaration.",
+        Type_annotation_cannot_appear_on_a_constructor_declaration: "Type annotation cannot appear on a constructor declaration.",
+        Duplicate_identifier_0: "Duplicate identifier '{0}'.",
+        The_name_0_does_not_exist_in_the_current_scope: "The name '{0}' does not exist in the current scope.",
+        The_name_0_does_not_refer_to_a_value: "The name '{0}' does not refer to a value.",
+        super_can_only_be_used_inside_a_class_instance_method: "'super' can only be used inside a class instance method.",
+        The_left_hand_side_of_an_assignment_expression_must_be_a_variable_property_or_indexer: "The left-hand side of an assignment expression must be a variable, property or indexer.",
+        Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: "Value of type '{0}' is not callable. Did you mean to include 'new'?",
+        Value_of_type_0_is_not_callable: "Value of type '{0}' is not callable.",
+        Value_of_type_0_is_not_newable: "Value of type '{0}' is not newable.",
+        Value_of_type_0_is_not_indexable_by_type_1: "Value of type '{0}' is not indexable by type '{1}'.",
+        Operator_0_cannot_be_applied_to_types_1_and_2: "Operator '{0}' cannot be applied to types '{1}' and '{2}'.",
+        Operator_0_cannot_be_applied_to_types_1_and_2_3: "Operator '{0}' cannot be applied to types '{1}' and '{2}': {3}",
+        Cannot_convert_0_to_1: "Cannot convert '{0}' to '{1}'.",
+        Cannot_convert_0_to_1_NL_2: "Cannot convert '{0}' to '{1}':{NL}{2}",
+        Expected_var_class_interface_or_module: "Expected var, class, interface, or module.",
+        Operator_0_cannot_be_applied_to_type_1: "Operator '{0}' cannot be applied to type '{1}'.",
+        Getter_0_already_declared: "Getter '{0}' already declared.",
+        Setter_0_already_declared: "Setter '{0}' already declared.",
+        Exported_class_0_extends_private_class_1: "Exported class '{0}' extends private class '{1}'.",
+        Exported_class_0_implements_private_interface_1: "Exported class '{0}' implements private interface '{1}'.",
+        Exported_interface_0_extends_private_interface_1: "Exported interface '{0}' extends private interface '{1}'.",
+        Exported_class_0_extends_class_from_inaccessible_module_1: "Exported class '{0}' extends class from inaccessible module {1}.",
+        Exported_class_0_implements_interface_from_inaccessible_module_1: "Exported class '{0}' implements interface from inaccessible module {1}.",
+        Exported_interface_0_extends_interface_from_inaccessible_module_1: "Exported interface '{0}' extends interface from inaccessible module {1}.",
+        Public_static_property_0_of_exported_class_has_or_is_using_private_type_1: "Public static property '{0}' of exported class has or is using private type '{1}'.",
+        Public_property_0_of_exported_class_has_or_is_using_private_type_1: "Public property '{0}' of exported class has or is using private type '{1}'.",
+        Property_0_of_exported_interface_has_or_is_using_private_type_1: "Property '{0}' of exported interface has or is using private type '{1}'.",
+        Exported_variable_0_has_or_is_using_private_type_1: "Exported variable '{0}' has or is using private type '{1}'.",
+        Public_static_property_0_of_exported_class_is_using_inaccessible_module_1: "Public static property '{0}' of exported class is using inaccessible module {1}.",
+        Public_property_0_of_exported_class_is_using_inaccessible_module_1: "Public property '{0}' of exported class is using inaccessible module {1}.",
+        Property_0_of_exported_interface_is_using_inaccessible_module_1: "Property '{0}' of exported interface is using inaccessible module {1}.",
+        Exported_variable_0_is_using_inaccessible_module_1: "Exported variable '{0}' is using inaccessible module {1}.",
+        Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of constructor from exported class has or is using private type '{1}'.",
+        Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public static property setter from exported class has or is using private type '{1}'.",
+        Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public property setter from exported class has or is using private type '{1}'.",
+        Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1: "Parameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.",
+        Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1: "Parameter '{0}' of call signature from exported interface has or is using private type '{1}'.",
+        Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public static method from exported class has or is using private type '{1}'.",
+        Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public method from exported class has or is using private type '{1}'.",
+        Parameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1: "Parameter '{0}' of method from exported interface has or is using private type '{1}'.",
+        Parameter_0_of_exported_function_has_or_is_using_private_type_1: "Parameter '{0}' of exported function has or is using private type '{1}'.",
+        Parameter_0_of_constructor_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of constructor from exported class is using inaccessible module {1}.",
+        Parameter_0_of_public_static_property_setter_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public static property setter from exported class is using inaccessible module {1}.",
+        Parameter_0_of_public_property_setter_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public property setter from exported class is using inaccessible module {1}.",
+        Parameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1: "Parameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.",
+        Parameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1: "Parameter '{0}' of call signature from exported interface is using inaccessible module {1}",
+        Parameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public static method from exported class is using inaccessible module {1}.",
+        Parameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public method from exported class is using inaccessible module {1}.",
+        Parameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1: "Parameter '{0}' of method from exported interface is using inaccessible module {1}.",
+        Parameter_0_of_exported_function_is_using_inaccessible_module_1: "Parameter '{0}' of exported function is using inaccessible module {1}.",
+        Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_type_0: "Return type of public static property getter from exported class has or is using private type '{0}'.",
+        Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_type_0: "Return type of public property getter from exported class has or is using private type '{0}'.",
+        Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_0: "Return type of constructor signature from exported interface has or is using private type '{0}'.",
+        Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_type_0: "Return type of call signature from exported interface has or is using private type '{0}'.",
+        Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_type_0: "Return type of index signature from exported interface has or is using private type '{0}'.",
+        Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_type_0: "Return type of public static method from exported class has or is using private type '{0}'.",
+        Return_type_of_public_method_from_exported_class_has_or_is_using_private_type_0: "Return type of public method from exported class has or is using private type '{0}'.",
+        Return_type_of_method_from_exported_interface_has_or_is_using_private_type_0: "Return type of method from exported interface has or is using private type '{0}'.",
+        Return_type_of_exported_function_has_or_is_using_private_type_0: "Return type of exported function has or is using private type '{0}'.",
+        Return_type_of_public_static_property_getter_from_exported_class_is_using_inaccessible_module_0: "Return type of public static property getter from exported class is using inaccessible module {0}.",
+        Return_type_of_public_property_getter_from_exported_class_is_using_inaccessible_module_0: "Return type of public property getter from exported class is using inaccessible module {0}.",
+        Return_type_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_0: "Return type of constructor signature from exported interface is using inaccessible module {0}.",
+        Return_type_of_call_signature_from_exported_interface_is_using_inaccessible_module_0: "Return type of call signature from exported interface is using inaccessible module {0}.",
+        Return_type_of_index_signature_from_exported_interface_is_using_inaccessible_module_0: "Return type of index signature from exported interface is using inaccessible module {0}.",
+        Return_type_of_public_static_method_from_exported_class_is_using_inaccessible_module_0: "Return type of public static method from exported class is using inaccessible module {0}.",
+        Return_type_of_public_method_from_exported_class_is_using_inaccessible_module_0: "Return type of public method from exported class is using inaccessible module {0}.",
+        Return_type_of_method_from_exported_interface_is_using_inaccessible_module_0: "Return type of method from exported interface is using inaccessible module {0}.",
+        Return_type_of_exported_function_is_using_inaccessible_module_0: "Return type of exported function is using inaccessible module {0}.",
+        new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead: "'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.",
+        A_parameter_list_must_follow_a_generic_type_argument_list_expected: "A parameter list must follow a generic type argument list. '(' expected.",
+        Multiple_constructor_implementations_are_not_allowed: "Multiple constructor implementations are not allowed.",
+        Unable_to_resolve_external_module_0: "Unable to resolve external module '{0}'.",
+        Module_cannot_be_aliased_to_a_non_module_type: "Module cannot be aliased to a non-module type.",
+        A_class_may_only_extend_another_class: "A class may only extend another class.",
+        A_class_may_only_implement_another_class_or_interface: "A class may only implement another class or interface.",
+        An_interface_may_only_extend_another_class_or_interface: "An interface may only extend another class or interface.",
+        Unable_to_resolve_type: "Unable to resolve type.",
+        Unable_to_resolve_type_of_0: "Unable to resolve type of '{0}'.",
+        Unable_to_resolve_type_parameter_constraint: "Unable to resolve type parameter constraint.",
+        Type_parameter_constraint_cannot_be_a_primitive_type: "Type parameter constraint cannot be a primitive type.",
+        Supplied_parameters_do_not_match_any_signature_of_call_target: "Supplied parameters do not match any signature of call target.",
+        Supplied_parameters_do_not_match_any_signature_of_call_target_NL_0: "Supplied parameters do not match any signature of call target:{NL}{0}",
+        Invalid_new_expression: "Invalid 'new' expression.",
+        Call_signatures_used_in_a_new_expression_must_have_a_void_return_type: "Call signatures used in a 'new' expression must have a 'void' return type.",
+        Could_not_select_overload_for_new_expression: "Could not select overload for 'new' expression.",
+        Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2: "Type '{0}' does not satisfy the constraint '{1}' for type parameter '{2}'.",
+        Could_not_select_overload_for_call_expression: "Could not select overload for 'call' expression.",
+        Cannot_invoke_an_expression_whose_type_lacks_a_call_signature: "Cannot invoke an expression whose type lacks a call signature.",
+        Calls_to_super_are_only_valid_inside_a_class: "Calls to 'super' are only valid inside a class.",
+        Generic_type_0_requires_1_type_argument_s: "Generic type '{0}' requires {1} type argument(s).",
+        Type_of_array_literal_cannot_be_determined_Best_common_type_could_not_be_found_for_array_elements: "Type of array literal cannot be determined. Best common type could not be found for array elements.",
+        Could_not_find_enclosing_symbol_for_dotted_name_0: "Could not find enclosing symbol for dotted name '{0}'.",
+        The_property_0_does_not_exist_on_value_of_type_1: "The property '{0}' does not exist on value of type '{1}'.",
+        Could_not_find_symbol_0: "Could not find symbol '{0}'.",
+        get_and_set_accessor_must_have_the_same_type: "'get' and 'set' accessor must have the same type.",
+        this_cannot_be_referenced_in_current_location: "'this' cannot be referenced in current location.",
+        Static_members_cannot_reference_class_type_parameters: "Static members cannot reference class type parameters.",
+        Class_0_is_recursively_referenced_as_a_base_type_of_itself: "Class '{0}' is recursively referenced as a base type of itself.",
+        Interface_0_is_recursively_referenced_as_a_base_type_of_itself: "Interface '{0}' is recursively referenced as a base type of itself.",
+        super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.",
+        super_cannot_be_referenced_in_non_derived_classes: "'super' cannot be referenced in non-derived classes.",
+        A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties: "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties.",
+        Constructors_for_derived_classes_must_contain_a_super_call: "Constructors for derived classes must contain a 'super' call.",
+        Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors: "Super calls are not permitted outside constructors or in nested functions inside constructors.",
+        _0_1_is_inaccessible: "'{0}.{1}' is inaccessible.",
+        this_cannot_be_referenced_within_module_bodies: "'this' cannot be referenced within module bodies.",
+        Invalid_expression_types_not_known_to_support_the_addition_operator: "Invalid '+' expression - types not known to support the addition operator.",
+        The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: "The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.",
+        The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: "The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.",
+        The_type_of_a_unary_arithmetic_operation_operand_must_be_of_type_any_number_or_an_enum_type: "The type of a unary arithmetic operation operand must be of type 'any', 'number' or an enum type.",
+        Variable_declarations_of_a_for_statement_cannot_use_a_type_annotation: "Variable declarations of a 'for' statement cannot use a type annotation.",
+        Variable_declarations_of_a_for_statement_must_be_of_types_string_or_any: "Variable declarations of a 'for' statement must be of types 'string' or 'any'.",
+        The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter: "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter.",
+        The_left_hand_side_of_an_in_expression_must_be_of_types_any_string_or_number: "The left-hand side of an 'in' expression must be of types 'any', 'string' or 'number'.",
+        The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter.",
+        The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.",
+        The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type: "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type.",
+        Setters_cannot_return_a_value: "Setters cannot return a value.",
+        Tried_to_query_type_of_uninitialized_module_0: "Tried to query type of uninitialized module '{0}'.",
+        Tried_to_set_variable_type_to_uninitialized_module_type_0: "Tried to set variable type to uninitialized module type '{0}'.",
+        Type_0_does_not_have_type_parameters: "Type '{0}' does not have type parameters.",
+        Getters_must_return_a_value: "Getters must return a value.",
+        Getter_and_setter_accessors_do_not_agree_in_visibility: "Getter and setter accessors do not agree in visibility.",
+        Invalid_left_hand_side_of_assignment_expression: "Invalid left-hand side of assignment expression.",
+        Function_declared_a_non_void_return_type_but_has_no_return_expression: "Function declared a non-void return type, but has no return expression.",
+        Cannot_resolve_return_type_reference: "Cannot resolve return type reference.",
+        Constructors_cannot_have_a_return_type_of_void: "Constructors cannot have a return type of 'void'.",
+        Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: "Subsequent variable declarations must have the same type.  Variable '{0}' must be of type '{1}', but here has type '{2}'.",
+        All_symbols_within_a_with_block_will_be_resolved_to_any: "All symbols within a with block will be resolved to 'any'.",
+        Import_declarations_in_an_internal_module_cannot_reference_an_external_module: "Import declarations in an internal module cannot reference an external module.",
+        Class_0_declares_interface_1_but_does_not_implement_it_NL_2: "Class {0} declares interface {1} but does not implement it:{NL}{2}",
+        Class_0_declares_class_1_as_an_interface_but_does_not_implement_it_NL_2: "Class {0} declares class {1} as an interface but does not implement it:{NL}{2}",
+        The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer: "The operand of an increment or decrement operator must be a variable, property or indexer.",
+        this_cannot_be_referenced_in_static_initializers_in_a_class_body: "'this' cannot be referenced in static initializers in a class body.",
+        Class_0_cannot_extend_class_1_NL_2: "Class '{0}' cannot extend class '{1}':{NL}{2}",
+        Interface_0_cannot_extend_class_1_NL_2: "Interface '{0}' cannot extend class '{1}':{NL}{2}",
+        Interface_0_cannot_extend_interface_1_NL_2: "Interface '{0}' cannot extend interface '{1}':{NL}{2}",
+        Duplicate_overload_signature_for_0: "Duplicate overload signature for '{0}'.",
+        Duplicate_constructor_overload_signature: "Duplicate constructor overload signature.",
+        Duplicate_overload_call_signature: "Duplicate overload call signature.",
+        Duplicate_overload_construct_signature: "Duplicate overload construct signature.",
+        Overload_signature_is_not_compatible_with_function_definition: "Overload signature is not compatible with function definition.",
+        Overload_signature_is_not_compatible_with_function_definition_NL_0: "Overload signature is not compatible with function definition:{NL}{0}",
+        Overload_signatures_must_all_be_public_or_private: "Overload signatures must all be public or private.",
+        Overload_signatures_must_all_be_exported_or_not_exported: "Overload signatures must all be exported or not exported.",
+        Overload_signatures_must_all_be_ambient_or_non_ambient: "Overload signatures must all be ambient or non-ambient.",
+        Overload_signatures_must_all_be_optional_or_required: "Overload signatures must all be optional or required.",
+        Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature: "Specialized overload signature is not assignable to any non-specialized signature.",
+        this_cannot_be_referenced_in_constructor_arguments: "'this' cannot be referenced in constructor arguments.",
+        Instance_member_cannot_be_accessed_off_a_class: "Instance member cannot be accessed off a class.",
+        Untyped_function_calls_may_not_accept_type_arguments: "Untyped function calls may not accept type arguments.",
+        Non_generic_functions_may_not_accept_type_arguments: "Non-generic functions may not accept type arguments.",
+        A_generic_type_may_not_reference_itself_with_a_wrapped_form_of_its_own_type_parameters: "A generic type may not reference itself with a wrapped form of its own type parameters.",
+        Rest_parameters_must_be_array_types: "Rest parameters must be array types.",
+        Overload_signature_implementation_cannot_use_specialized_type: "Overload signature implementation cannot use specialized type.",
+        Export_assignments_may_only_be_used_at_the_top_level_of_external_modules: "Export assignments may only be used at the top-level of external modules.",
+        Export_assignments_may_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules: "Export assignments may only be made with variables, functions, classes, interfaces, enums and internal modules.",
+        Only_public_methods_of_the_base_class_are_accessible_via_the_super_keyword: "Only public methods of the base class are accessible via the 'super' keyword.",
+        Numeric_indexer_type_0_must_be_assignable_to_string_indexer_type_1: "Numeric indexer type '{0}' must be assignable to string indexer type '{1}'.",
+        Numeric_indexer_type_0_must_be_assignable_to_string_indexer_type_1_NL_2: "Numeric indexer type '{0}' must be assignable to string indexer type '{1}':{NL}{2}",
+        All_numerically_named_properties_must_be_assignable_to_numeric_indexer_type_0: "All numerically named properties must be assignable to numeric indexer type '{0}'.",
+        All_numerically_named_properties_must_be_assignable_to_numeric_indexer_type_0_NL_1: "All numerically named properties must be assignable to numeric indexer type '{0}':{NL}{1}",
+        All_named_properties_must_be_assignable_to_string_indexer_type_0: "All named properties must be assignable to string indexer type '{0}'.",
+        All_named_properties_must_be_assignable_to_string_indexer_type_0_NL_1: "All named properties must be assignable to string indexer type '{0}':{NL}{1}",
+        Generic_type_references_must_include_all_type_arguments: "Generic type references must include all type arguments.",
+        Default_arguments_are_only_allowed_in_implementation: "Default arguments are only allowed in implementation.",
+        Overloads_cannot_differ_only_by_return_type: "Overloads cannot differ only by return type.",
+        Function_expression_declared_a_non_void_return_type_but_has_no_return_expression: "Function expression declared a non-void return type, but has no return expression.",
+        Import_declaration_referencing_identifier_from_internal_module_can_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules: "Import declaration referencing identifier from internal module can only be made with variables, functions, classes, interfaces, enums and internal modules.",
+        Could_not_find_symbol_0_in_module_1: "Could not find symbol '{0}' in module '{1}'.",
+        Unable_to_resolve_module_reference_0: "Unable to resolve module reference '{0}'.",
+        Could_not_find_module_0_in_module_1: "Could not find module '{0}' in module '{1}'.",
+        Exported_import_declaration_0_is_assigned_value_with_type_that_has_or_is_using_private_type_1: "Exported import declaration '{0}' is assigned value with type that has or is using private type '{1}'.",
+        Exported_import_declaration_0_is_assigned_value_with_type_that_is_using_inaccessible_module_1: "Exported import declaration '{0}' is assigned value with type that is using inaccessible module '{1}'.",
+        Exported_import_declaration_0_is_assigned_type_that_has_or_is_using_private_type_1: "Exported import declaration '{0}' is assigned type that has or is using private type '{1}'.",
+        Exported_import_declaration_0_is_assigned_type_that_is_using_inaccessible_module_1: "Exported import declaration '{0}' is assigned type that is using inaccessible module '{1}'.",
+        Exported_import_declaration_0_is_assigned_container_that_is_or_is_using_inaccessible_module_1: "Exported import declaration '{0}' is assigned container that is or is using inaccessible module '{1}'.",
+        Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_1: "Type name '{0}' in extends clause does not reference constructor function for '{1}'.",
+        Internal_module_reference_0_in_import_declaration_does_not_reference_module_instance_for_1: "Internal module reference '{0}' in import declaration does not reference module instance for '{1}'.",
+        Module_0_cannot_merge_with_previous_declaration_of_1_in_a_different_file_2: "Module '{0}' cannot merge with previous declaration of '{1}' in a different file '{2}'.",
+        Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3: "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}':{NL}{3}",
+        Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it: "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it.",
+        Ambient_external_module_declaration_cannot_be_reopened: "Ambient external module declaration cannot be reopened.",
+        All_declarations_of_merged_declaration_0_must_be_exported_or_not_exported: "All declarations of merged declaration '{0}' must be exported or not exported.",
+        super_cannot_be_referenced_in_constructor_arguments: "'super' cannot be referenced in constructor arguments.",
+        Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class: "Return type of constructor signature must be assignable to the instance type of the class.",
+        Ambient_external_module_declaration_must_be_defined_in_global_context: "Ambient external module declaration must be defined in global context.",
+        Ambient_external_module_declaration_cannot_specify_relative_module_name: "Ambient external module declaration cannot specify relative module name.",
+        Import_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name: "Import declaration in an ambient external module declaration cannot reference external module through relative external module name.",
+        Could_not_find_the_best_common_type_of_types_of_all_return_statement_expressions: "Could not find the best common type of types of all return statement expressions.",
+        Import_declaration_cannot_refer_to_external_module_reference_when_noResolve_option_is_set: "Import declaration cannot refer to external module reference when --noResolve option is set.",
+        Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference.",
+        continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: "'continue' statement can only be used within an enclosing iteration statement.",
+        break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: "'break' statement can only be used within an enclosing iteration or switch statement.",
+        Jump_target_not_found: "Jump target not found.",
+        Jump_target_cannot_cross_function_boundary: "Jump target cannot cross function boundary.",
+        Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference: "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference.",
+        Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference.",
+        Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: "Expression resolves to '_super' that compiler uses to capture base class reference.",
+        TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.",
+        TypeParameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of call signature from exported interface has or is using private type '{1}'.",
+        TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1: "TypeParameter '{0}' of public static method from exported class has or is using private type '{1}'.",
+        TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1: "TypeParameter '{0}' of public method from exported class has or is using private type '{1}'.",
+        TypeParameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of method from exported interface has or is using private type '{1}'.",
+        TypeParameter_0_of_exported_function_has_or_is_using_private_type_1: "TypeParameter '{0}' of exported function has or is using private type '{1}'.",
+        TypeParameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.",
+        TypeParameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of call signature from exported interface is using inaccessible module {1}",
+        TypeParameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1: "TypeParameter '{0}' of public static method from exported class is using inaccessible module {1}.",
+        TypeParameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1: "TypeParameter '{0}' of public method from exported class is using inaccessible module {1}.",
+        TypeParameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of method from exported interface is using inaccessible module {1}.",
+        TypeParameter_0_of_exported_function_is_using_inaccessible_module_1: "TypeParameter '{0}' of exported function is using inaccessible module {1}.",
+        TypeParameter_0_of_exported_class_has_or_is_using_private_type_1: "TypeParameter '{0}' of exported class has or is using private type '{1}'.",
+        TypeParameter_0_of_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of exported interface has or is using private type '{1}'.",
+        TypeParameter_0_of_exported_class_is_using_inaccessible_module_1: "TypeParameter '{0}' of exported class is using inaccessible module {1}.",
+        TypeParameter_0_of_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of exported interface is using inaccessible module {1}.",
+        Duplicate_identifier_i_Compiler_uses_i_to_initialize_rest_parameter: "Duplicate identifier '_i'. Compiler uses '_i' to initialize rest parameter.",
+        Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters: "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.",
+        Type_of_conditional_0_must_be_identical_to_1_or_2: "Type of conditional '{0}' must be identical to '{1}' or '{2}'.",
+        Type_of_conditional_0_must_be_identical_to_1_2_or_3: "Type of conditional '{0}' must be identical to '{1}', '{2}' or '{3}'.",
+        Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module: "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of an external module.",
+        Constraint_of_a_type_parameter_cannot_reference_any_type_parameter_from_the_same_type_parameter_list: "Constraint of a type parameter cannot reference any type parameter from the same type parameter list.",
+        Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor.",
+        Parameter_0_cannot_be_referenced_in_its_initializer: "Parameter '{0}' cannot be referenced in its initializer.",
+        Duplicate_string_index_signature: "Duplicate string index signature.",
+        Duplicate_number_index_signature: "Duplicate number index signature.",
+        All_declarations_of_an_interface_must_have_identical_type_parameters: "All declarations of an interface must have identical type parameters.",
+        Expression_resolves_to_variable_declaration_i_that_compiler_uses_to_initialize_rest_parameter: "Expression resolves to variable declaration '_i' that compiler uses to initialize rest parameter.",
+        Type_0_is_missing_property_1_from_type_2: "Type '{0}' is missing property '{1}' from type '{2}'.",
+        Types_of_property_0_of_types_1_and_2_are_incompatible: "Types of property '{0}' of types '{1}' and '{2}' are incompatible.",
+        Types_of_property_0_of_types_1_and_2_are_incompatible_NL_3: "Types of property '{0}' of types '{1}' and '{2}' are incompatible:{NL}{3}",
+        Property_0_defined_as_private_in_type_1_is_defined_as_public_in_type_2: "Property '{0}' defined as private in type '{1}' is defined as public in type '{2}'.",
+        Property_0_defined_as_public_in_type_1_is_defined_as_private_in_type_2: "Property '{0}' defined as public in type '{1}' is defined as private in type '{2}'.",
+        Types_0_and_1_define_property_2_as_private: "Types '{0}' and '{1}' define property '{2}' as private.",
+        Call_signatures_of_types_0_and_1_are_incompatible: "Call signatures of types '{0}' and '{1}' are incompatible.",
+        Call_signatures_of_types_0_and_1_are_incompatible_NL_2: "Call signatures of types '{0}' and '{1}' are incompatible:{NL}{2}",
+        Type_0_requires_a_call_signature_but_type_1_lacks_one: "Type '{0}' requires a call signature, but type '{1}' lacks one.",
+        Construct_signatures_of_types_0_and_1_are_incompatible: "Construct signatures of types '{0}' and '{1}' are incompatible.",
+        Construct_signatures_of_types_0_and_1_are_incompatible_NL_2: "Construct signatures of types '{0}' and '{1}' are incompatible:{NL}{2}",
+        Type_0_requires_a_construct_signature_but_type_1_lacks_one: "Type '{0}' requires a construct signature, but type '{1}' lacks one.",
+        Index_signatures_of_types_0_and_1_are_incompatible: "Index signatures of types '{0}' and '{1}' are incompatible.",
+        Index_signatures_of_types_0_and_1_are_incompatible_NL_2: "Index signatures of types '{0}' and '{1}' are incompatible:{NL}{2}",
+        Call_signature_expects_0_or_fewer_parameters: "Call signature expects {0} or fewer parameters.",
+        Could_not_apply_type_0_to_argument_1_which_is_of_type_2: "Could not apply type '{0}' to argument {1} which is of type '{2}'.",
+        Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function.",
+        Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function.",
+        Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor.",
+        Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property.",
+        Types_of_static_property_0_of_class_1_and_class_2_are_incompatible: "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible.",
+        Types_of_static_property_0_of_class_1_and_class_2_are_incompatible_NL_3: "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible:{NL}{3}",
+        Type_reference_cannot_refer_to_container_0: "Type reference cannot refer to container '{0}'.",
+        Type_reference_must_refer_to_type: "Type reference must refer to type.",
+        In_enums_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_the_first_enum_element: "In enums with multiple declarations only one declaration can omit an initializer for the first enum element.",
+        _0_overload_s: " (+ {0} overload(s))",
+        Variable_declaration_cannot_have_the_same_name_as_an_import_declaration: "Variable declaration cannot have the same name as an import declaration.",
+        Signature_expected_0_type_arguments_got_1_instead: "Signature expected {0} type arguments, got {1} instead.",
+        Property_0_defined_as_optional_in_type_1_but_is_required_in_type_2: "Property '{0}' defined as optional in type '{1}', but is required in type '{2}'.",
+        Types_0_and_1_originating_in_infinitely_expanding_type_reference_do_not_refer_to_same_named_type: "Types '{0}' and '{1}' originating in infinitely expanding type reference do not refer to same named type.",
+        Types_0_and_1_originating_in_infinitely_expanding_type_reference_have_incompatible_type_arguments: "Types '{0}' and '{1}' originating in infinitely expanding type reference have incompatible type arguments.",
+        Types_0_and_1_originating_in_infinitely_expanding_type_reference_have_incompatible_type_arguments_NL_2: "Types '{0}' and '{1}' originating in infinitely expanding type reference have incompatible type arguments:{NL}{2}",
+        Named_properties_0_of_types_1_and_2_are_not_identical: "Named properties '{0}' of types '{1}' and '{2}' are not identical.",
+        Types_of_string_indexer_of_types_0_and_1_are_not_identical: "Types of string indexer of types '{0}' and '{1}' are not identical.",
+        Types_of_number_indexer_of_types_0_and_1_are_not_identical: "Types of number indexer of types '{0}' and '{1}' are not identical.",
+        Type_of_number_indexer_in_type_0_is_not_assignable_to_string_indexer_type_in_type_1_NL_2: "Type of number indexer in type '{0}' is not assignable to string indexer type in type '{1}'.{NL}{2}",
+        Type_of_property_0_in_type_1_is_not_assignable_to_string_indexer_type_in_type_2_NL_3: "Type of property '{0}' in type '{1}' is not assignable to string indexer type in type '{2}'.{NL}{3}",
+        Type_of_property_0_in_type_1_is_not_assignable_to_number_indexer_type_in_type_2_NL_3: "Type of property '{0}' in type '{1}' is not assignable to number indexer type in type '{2}'.{NL}{3}",
+        Static_property_0_defined_as_private_in_type_1_is_defined_as_public_in_type_2: "Static property '{0}' defined as private in type '{1}' is defined as public in type '{2}'.",
+        Static_property_0_defined_as_public_in_type_1_is_defined_as_private_in_type_2: "Static property '{0}' defined as public in type '{1}' is defined as private in type '{2}'.",
+        Types_0_and_1_define_static_property_2_as_private: "Types '{0}' and '{1}' define static property '{2}' as private.",
+        Current_host_does_not_support_0_option: "Current host does not support '{0}' option.",
+        ECMAScript_target_version_0_not_supported_Specify_a_valid_target_version_1_default_or_2: "ECMAScript target version '{0}' not supported.  Specify a valid target version: '{1}' (default), or '{2}'",
+        Module_code_generation_0_not_supported: "Module code generation '{0}' not supported.",
+        Could_not_find_file_0: "Could not find file: '{0}'.",
+        A_file_cannot_have_a_reference_to_itself: "A file cannot have a reference to itself.",
+        Cannot_resolve_referenced_file_0: "Cannot resolve referenced file: '{0}'.",
+        Cannot_find_the_common_subdirectory_path_for_the_input_files: "Cannot find the common subdirectory path for the input files.",
+        Emit_Error_0: "Emit Error: {0}.",
+        Cannot_read_file_0_1: "Cannot read file '{0}': {1}",
+        Unsupported_file_encoding: "Unsupported file encoding.",
+        Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1: "Locale must be of the form <language> or <language>-<territory>. For example '{0}' or '{1}'.",
+        Unsupported_locale_0: "Unsupported locale: '{0}'.",
+        Execution_Failed_NL: "Execution Failed.{NL}",
+        Invalid_call_to_up: "Invalid call to 'up'",
+        Invalid_call_to_down: "Invalid call to 'down'",
+        Base64_value_0_finished_with_a_continuation_bit: "Base64 value '{0}' finished with a continuation bit.",
+        Unknown_option_0: "Unknown option '{0}'",
+        Expected_0_arguments_to_message_got_1_instead: "Expected {0} arguments to message, got {1} instead.",
+        Expected_the_message_0_to_have_1_arguments_but_it_had_2: "Expected the message '{0}' to have {1} arguments, but it had {2}",
+        Could_not_delete_file_0: "Could not delete file '{0}'",
+        Could_not_create_directory_0: "Could not create directory '{0}'",
+        Error_while_executing_file_0: "Error while executing file '{0}': ",
+        Cannot_compile_external_modules_unless_the_module_flag_is_provided: "Cannot compile external modules unless the '--module' flag is provided.",
+        Option_mapRoot_cannot_be_specified_without_specifying_sourcemap_option: "Option mapRoot cannot be specified without specifying sourcemap option.",
+        Option_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option: "Option sourceRoot cannot be specified without specifying sourcemap option.",
+        Options_mapRoot_and_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option: "Options mapRoot and sourceRoot cannot be specified without specifying sourcemap option.",
+        Option_0_specified_without_1: "Option '{0}' specified without '{1}'",
+        codepage_option_not_supported_on_current_platform: "'codepage' option not supported on current platform.",
+        Concatenate_and_emit_output_to_single_file: "Concatenate and emit output to single file.",
+        Generates_corresponding_0_file: "Generates corresponding {0} file.",
+        Specifies_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: "Specifies the location where debugger should locate map files instead of generated locations.",
+        Specifies_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations: "Specifies the location where debugger should locate TypeScript files instead of source locations.",
+        Watch_input_files: "Watch input files.",
+        Redirect_output_structure_to_the_directory: "Redirect output structure to the directory.",
+        Do_not_emit_comments_to_output: "Do not emit comments to output.",
+        Skip_resolution_and_preprocessing: "Skip resolution and preprocessing.",
+        Specify_ECMAScript_target_version_0_default_or_1: "Specify ECMAScript target version: '{0}' (default), or '{1}'",
+        Specify_module_code_generation_0_or_1: "Specify module code generation: '{0}' or '{1}'",
+        Print_this_message: "Print this message.",
+        Print_the_compiler_s_version_0: "Print the compiler's version: {0}",
+        Allow_use_of_deprecated_0_keyword_when_referencing_an_external_module: "Allow use of deprecated '{0}' keyword when referencing an external module.",
+        Specify_locale_for_errors_and_messages_For_example_0_or_1: "Specify locale for errors and messages. For example '{0}' or '{1}'",
+        Syntax_0: "Syntax:   {0}",
+        options: "options",
+        file1: "file",
+        Examples: "Examples:",
+        Options: "Options:",
+        Insert_command_line_options_and_files_from_a_file: "Insert command line options and files from a file.",
+        Version_0: "Version {0}",
+        Use_the_0_flag_to_see_options: "Use the '{0}' flag to see options.",
+        NL_Recompiling_0: "{NL}Recompiling ({0}):",
+        STRING: "STRING",
+        KIND: "KIND",
+        file2: "FILE",
+        VERSION: "VERSION",
+        LOCATION: "LOCATION",
+        DIRECTORY: "DIRECTORY",
+        NUMBER: "NUMBER",
+        Specify_the_codepage_to_use_when_opening_source_files: "Specify the codepage to use when opening source files.",
+        Additional_locations: "Additional locations:",
+        This_version_of_the_Javascript_runtime_does_not_support_the_0_function: "This version of the Javascript runtime does not support the '{0}' function.",
+        Unknown_rule: "Unknown rule.",
+        Invalid_line_number_0: "Invalid line number ({0})",
+        Warn_on_expressions_and_declarations_with_an_implied_any_type: "Warn on expressions and declarations with an implied 'any' type.",
+        Variable_0_implicitly_has_an_any_type: "Variable '{0}' implicitly has an 'any' type.",
+        Parameter_0_of_1_implicitly_has_an_any_type: "Parameter '{0}' of '{1}' implicitly has an 'any' type.",
+        Parameter_0_of_function_type_implicitly_has_an_any_type: "Parameter '{0}' of function type implicitly has an 'any' type.",
+        Member_0_of_object_type_implicitly_has_an_any_type: "Member '{0}' of object type implicitly has an 'any' type.",
+        new_expression_which_lacks_a_constructor_signature_implicitly_has_an_any_type: "'new' expression, which lacks a constructor signature, implicitly has an 'any' type.",
+        _0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "'{0}', which lacks return-type annotation, implicitly has an 'any' return type.",
+        Function_expression_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "Function expression, which lacks return-type annotation, implicitly has an 'any' return type.",
+        Parameter_0_of_lambda_function_implicitly_has_an_any_type: "Parameter '{0}' of lambda function implicitly has an 'any' type.",
+        Constructor_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "Constructor signature, which lacks return-type annotation, implicitly has an 'any' return type.",
+        Lambda_Function_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "Lambda Function, which lacks return-type annotation, implicitly has an 'any' return type.",
+        Array_Literal_implicitly_has_an_any_type_from_widening: "Array Literal implicitly has an 'any' type from widening.",
+        _0_which_lacks_get_accessor_and_parameter_type_annotation_on_set_accessor_implicitly_has_an_any_type: "'{0}', which lacks 'get' accessor and parameter type annotation on 'set' accessor, implicitly has an 'any' type.",
+        Index_signature_of_object_type_implicitly_has_an_any_type: "Index signature of object type implicitly has an 'any' type.",
+        Object_literal_s_property_0_implicitly_has_an_any_type_from_widening: "Object literal's property '{0}' implicitly has an 'any' type from widening."
+    };
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var ArrayUtilities = (function () {
+        function ArrayUtilities() {
+        }
+        ArrayUtilities.isArray = function (value) {
+            return Object.prototype.toString.apply(value, []) === '[object Array]';
+        };
+
+        ArrayUtilities.sequenceEquals = function (array1, array2, equals) {
+            if (array1 === array2) {
+                return true;
+            }
+
+            if (array1 === null || array2 === null) {
+                return false;
+            }
+
+            if (array1.length !== array2.length) {
+                return false;
+            }
+
+            for (var i = 0, n = array1.length; i < n; i++) {
+                if (!equals(array1[i], array2[i])) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        ArrayUtilities.contains = function (array, value) {
+            for (var i = 0; i < array.length; i++) {
+                if (array[i] === value) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        ArrayUtilities.groupBy = function (array, func) {
+            var result = {};
+
+            for (var i = 0, n = array.length; i < n; i++) {
+                var v = array[i];
+                var k = func(v);
+
+                var list = result[k] || [];
+                list.push(v);
+                result[k] = list;
+            }
+
+            return result;
+        };
+
+        ArrayUtilities.distinct = function (array, equalsFn) {
+            var result = [];
+
+            for (var i = 0, n = array.length; i < n; i++) {
+                var current = array[i];
+                for (var j = 0; j < result.length; j++) {
+                    if (equalsFn(result[j], current)) {
+                        break;
+                    }
+                }
+
+                if (j === result.length) {
+                    result.push(current);
+                }
+            }
+
+            return result;
+        };
+
+        ArrayUtilities.min = function (array, func) {
+            var min = func(array[0]);
+
+            for (var i = 1; i < array.length; i++) {
+                var next = func(array[i]);
+                if (next < min) {
+                    min = next;
+                }
+            }
+
+            return min;
+        };
+
+        ArrayUtilities.max = function (array, func) {
+            var max = func(array[0]);
+
+            for (var i = 1; i < array.length; i++) {
+                var next = func(array[i]);
+                if (next > max) {
+                    max = next;
+                }
+            }
+
+            return max;
+        };
+
+        ArrayUtilities.last = function (array) {
+            if (array.length === 0) {
+                throw TypeScript.Errors.argumentOutOfRange('array');
+            }
+
+            return array[array.length - 1];
+        };
+
+        ArrayUtilities.lastOrDefault = function (array, predicate) {
+            for (var i = array.length - 1; i >= 0; i--) {
+                var v = array[i];
+                if (predicate(v, i)) {
+                    return v;
+                }
+            }
+
+            return null;
+        };
+
+        ArrayUtilities.firstOrDefault = function (array, func) {
+            for (var i = 0, n = array.length; i < n; i++) {
+                var value = array[i];
+                if (func(value, i)) {
+                    return value;
+                }
+            }
+
+            return null;
+        };
+
+        ArrayUtilities.first = function (array, func) {
+            for (var i = 0, n = array.length; i < n; i++) {
+                var value = array[i];
+                if (!func || func(value, i)) {
+                    return value;
+                }
+            }
+
+            throw TypeScript.Errors.invalidOperation();
+        };
+
+        ArrayUtilities.sum = function (array, func) {
+            var result = 0;
+
+            for (var i = 0, n = array.length; i < n; i++) {
+                result += func(array[i]);
+            }
+
+            return result;
+        };
+
+        ArrayUtilities.select = function (values, func) {
+            var result = new Array(values.length);
+
+            for (var i = 0; i < values.length; i++) {
+                result[i] = func(values[i]);
+            }
+
+            return result;
+        };
+
+        ArrayUtilities.where = function (values, func) {
+            var result = new Array();
+
+            for (var i = 0; i < values.length; i++) {
+                if (func(values[i])) {
+                    result.push(values[i]);
+                }
+            }
+
+            return result;
+        };
+
+        ArrayUtilities.any = function (array, func) {
+            for (var i = 0, n = array.length; i < n; i++) {
+                if (func(array[i])) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        ArrayUtilities.all = function (array, func) {
+            for (var i = 0, n = array.length; i < n; i++) {
+                if (!func(array[i])) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        ArrayUtilities.binarySearch = function (array, value) {
+            var low = 0;
+            var high = array.length - 1;
+
+            while (low <= high) {
+                var middle = low + ((high - low) >> 1);
+                var midValue = array[middle];
+
+                if (midValue === value) {
+                    return middle;
+                } else if (midValue > value) {
+                    high = middle - 1;
+                } else {
+                    low = middle + 1;
+                }
+            }
+
+            return ~low;
+        };
+
+        ArrayUtilities.createArray = function (length, defaultValue) {
+            var result = new Array(length);
+            for (var i = 0; i < length; i++) {
+                result[i] = defaultValue;
+            }
+
+            return result;
+        };
+
+        ArrayUtilities.grow = function (array, length, defaultValue) {
+            var count = length - array.length;
+            for (var i = 0; i < count; i++) {
+                array.push(defaultValue);
+            }
+        };
+
+        ArrayUtilities.copy = function (sourceArray, sourceIndex, destinationArray, destinationIndex, length) {
+            for (var i = 0; i < length; i++) {
+                destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];
+            }
+        };
+
+        ArrayUtilities.indexOf = function (array, predicate) {
+            for (var i = 0, n = array.length; i < n; i++) {
+                if (predicate(array[i])) {
+                    return i;
+                }
+            }
+
+            return -1;
+        };
+        return ArrayUtilities;
+    })();
+    TypeScript.ArrayUtilities = ArrayUtilities;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (BitVector) {
+        var pool = [];
+        var Constants;
+        (function (Constants) {
+            Constants[Constants["MaxBitsPerEncodedNumber"] = 30] = "MaxBitsPerEncodedNumber";
+            Constants[Constants["BitsPerEncodedBiStateValue"] = 1] = "BitsPerEncodedBiStateValue";
+
+            Constants[Constants["BitsPerEncodedTriStateValue"] = 2] = "BitsPerEncodedTriStateValue";
+
+            Constants[Constants["BiStateEncodedTrue"] = 1] = "BiStateEncodedTrue";
+            Constants[Constants["BiStateClearBitsMask"] = 1] = "BiStateClearBitsMask";
+
+            Constants[Constants["TriStateEncodedFalse"] = 1] = "TriStateEncodedFalse";
+            Constants[Constants["TriStateEncodedTrue"] = 2] = "TriStateEncodedTrue";
+            Constants[Constants["TriStateClearBitsMask"] = 3] = "TriStateClearBitsMask";
+        })(Constants || (Constants = {}));
+
+        var BitVectorImpl = (function () {
+            function BitVectorImpl(allowUndefinedValues) {
+                this.allowUndefinedValues = allowUndefinedValues;
+                this.isReleased = false;
+                this.bits = [];
+            }
+            BitVectorImpl.prototype.computeTriStateArrayIndex = function (index) {
+                var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 2 /* BitsPerEncodedTriStateValue */;
+
+                return (index / encodedValuesPerNumber) >>> 0;
+            };
+
+            BitVectorImpl.prototype.computeBiStateArrayIndex = function (index) {
+                var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 1 /* BitsPerEncodedBiStateValue */;
+
+                return (index / encodedValuesPerNumber) >>> 0;
+            };
+
+            BitVectorImpl.prototype.computeTriStateEncodedValueIndex = function (index) {
+                var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 2 /* BitsPerEncodedTriStateValue */;
+
+                return (index % encodedValuesPerNumber) * 2 /* BitsPerEncodedTriStateValue */;
+            };
+
+            BitVectorImpl.prototype.computeBiStateEncodedValueIndex = function (index) {
+                var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 1 /* BitsPerEncodedBiStateValue */;
+
+                return (index % encodedValuesPerNumber) * 1 /* BitsPerEncodedBiStateValue */;
+            };
+
+            BitVectorImpl.prototype.valueAt = function (index) {
+                TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector");
+                if (this.allowUndefinedValues) {
+                    var arrayIndex = this.computeTriStateArrayIndex(index);
+                    var encoded = this.bits[arrayIndex];
+                    if (encoded === undefined) {
+                        return undefined;
+                    }
+
+                    var bitIndex = this.computeTriStateEncodedValueIndex(index);
+                    if (encoded & (2 /* TriStateEncodedTrue */ << bitIndex)) {
+                        return true;
+                    } else if (encoded & (1 /* TriStateEncodedFalse */ << bitIndex)) {
+                        return false;
+                    } else {
+                        return undefined;
+                    }
+                } else {
+                    var arrayIndex = this.computeBiStateArrayIndex(index);
+                    var encoded = this.bits[arrayIndex];
+                    if (encoded === undefined) {
+                        return false;
+                    }
+
+                    var bitIndex = this.computeBiStateEncodedValueIndex(index);
+                    if (encoded & (1 /* BiStateEncodedTrue */ << bitIndex)) {
+                        return true;
+                    } else {
+                        return false;
+                    }
+                }
+            };
+
+            BitVectorImpl.prototype.setValueAt = function (index, value) {
+                TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector");
+                if (this.allowUndefinedValues) {
+                    TypeScript.Debug.assert(value === true || value === false || value === undefined, "value must only be true, false or undefined.");
+
+                    var arrayIndex = this.computeTriStateArrayIndex(index);
+                    var encoded = this.bits[arrayIndex];
+                    if (encoded === undefined) {
+                        if (value === undefined) {
+                            return;
+                        }
+
+                        encoded = 0;
+                    }
+
+                    var bitIndex = this.computeTriStateEncodedValueIndex(index);
+
+                    var clearMask = ~(3 /* TriStateClearBitsMask */ << bitIndex);
+                    encoded = encoded & clearMask;
+
+                    if (value === true) {
+                        encoded = encoded | (2 /* TriStateEncodedTrue */ << bitIndex);
+                    } else if (value === false) {
+                        encoded = encoded | (1 /* TriStateEncodedFalse */ << bitIndex);
+                    }
+
+                    this.bits[arrayIndex] = encoded;
+                } else {
+                    TypeScript.Debug.assert(value === true || value === false, "value must only be true or false.");
+
+                    var arrayIndex = this.computeBiStateArrayIndex(index);
+                    var encoded = this.bits[arrayIndex];
+                    if (encoded === undefined) {
+                        if (value === false) {
+                            return;
+                        }
+
+                        encoded = 0;
+                    }
+
+                    var bitIndex = this.computeBiStateEncodedValueIndex(index);
+
+                    encoded = encoded & ~(1 /* BiStateClearBitsMask */ << bitIndex);
+
+                    if (value) {
+                        encoded = encoded | (1 /* BiStateEncodedTrue */ << bitIndex);
+                    }
+
+                    this.bits[arrayIndex] = encoded;
+                }
+            };
+
+            BitVectorImpl.prototype.release = function () {
+                TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector");
+                this.isReleased = true;
+                this.bits.length = 0;
+                pool.push(this);
+            };
+            return BitVectorImpl;
+        })();
+
+        function getBitVector(allowUndefinedValues) {
+            if (pool.length === 0) {
+                return new BitVectorImpl(allowUndefinedValues);
+            }
+
+            var vector = pool.pop();
+            vector.isReleased = false;
+            vector.allowUndefinedValues = allowUndefinedValues;
+
+            return vector;
+        }
+        BitVector.getBitVector = getBitVector;
+    })(TypeScript.BitVector || (TypeScript.BitVector = {}));
+    var BitVector = TypeScript.BitVector;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (BitMatrix) {
+        var pool = [];
+
+        var BitMatrixImpl = (function () {
+            function BitMatrixImpl(allowUndefinedValues) {
+                this.allowUndefinedValues = allowUndefinedValues;
+                this.isReleased = false;
+                this.vectors = [];
+            }
+            BitMatrixImpl.prototype.valueAt = function (x, y) {
+                TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector");
+                var vector = this.vectors[x];
+                if (!vector) {
+                    return this.allowUndefinedValues ? undefined : false;
+                }
+
+                return vector.valueAt(y);
+            };
+
+            BitMatrixImpl.prototype.setValueAt = function (x, y, value) {
+                TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector");
+                var vector = this.vectors[x];
+                if (!vector) {
+                    if (value === undefined) {
+                        return;
+                    }
+
+                    vector = TypeScript.BitVector.getBitVector(this.allowUndefinedValues);
+                    this.vectors[x] = vector;
+                }
+
+                vector.setValueAt(y, value);
+            };
+
+            BitMatrixImpl.prototype.release = function () {
+                TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector");
+                this.isReleased = true;
+
+                for (var name in this.vectors) {
+                    if (this.vectors.hasOwnProperty(name)) {
+                        var vector = this.vectors[name];
+                        vector.release();
+                    }
+                }
+
+                this.vectors.length = 0;
+                pool.push(this);
+            };
+            return BitMatrixImpl;
+        })();
+
+        function getBitMatrix(allowUndefinedValues) {
+            if (pool.length === 0) {
+                return new BitMatrixImpl(allowUndefinedValues);
+            }
+
+            var matrix = pool.pop();
+            matrix.isReleased = false;
+            matrix.allowUndefinedValues = allowUndefinedValues;
+
+            return matrix;
+        }
+        BitMatrix.getBitMatrix = getBitMatrix;
+    })(TypeScript.BitMatrix || (TypeScript.BitMatrix = {}));
+    var BitMatrix = TypeScript.BitMatrix;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (Constants) {
+        Constants[Constants["Max31BitInteger"] = 1073741823] = "Max31BitInteger";
+        Constants[Constants["Min31BitInteger"] = -1073741824] = "Min31BitInteger";
+    })(TypeScript.Constants || (TypeScript.Constants = {}));
+    var Constants = TypeScript.Constants;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (AssertionLevel) {
+        AssertionLevel[AssertionLevel["None"] = 0] = "None";
+        AssertionLevel[AssertionLevel["Normal"] = 1] = "Normal";
+        AssertionLevel[AssertionLevel["Aggressive"] = 2] = "Aggressive";
+        AssertionLevel[AssertionLevel["VeryAggressive"] = 3] = "VeryAggressive";
+    })(TypeScript.AssertionLevel || (TypeScript.AssertionLevel = {}));
+    var AssertionLevel = TypeScript.AssertionLevel;
+
+    var Debug = (function () {
+        function Debug() {
+        }
+        Debug.shouldAssert = function (level) {
+            return this.currentAssertionLevel >= level;
+        };
+
+        Debug.assert = function (expression, message, verboseDebugInfo) {
+            if (typeof message === "undefined") { message = ""; }
+            if (typeof verboseDebugInfo === "undefined") { verboseDebugInfo = null; }
+            if (!expression) {
+                var verboseDebugString = "";
+                if (verboseDebugInfo) {
+                    verboseDebugString = "\r\nVerbose Debug Information:" + verboseDebugInfo();
+                }
+
+                throw new Error("Debug Failure. False expression: " + message + verboseDebugString);
+            }
+        };
+
+        Debug.fail = function (message) {
+            Debug.assert(false, message);
+        };
+        Debug.currentAssertionLevel = 0 /* None */;
+        return Debug;
+    })();
+    TypeScript.Debug = Debug;
+})(TypeScript || (TypeScript = {}));
+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 TypeScript;
+(function (TypeScript) {
+    TypeScript.LocalizedDiagnosticMessages = null;
+
+    var Location = (function () {
+        function Location(fileName, lineMap, start, length) {
+            this._fileName = fileName;
+            this._lineMap = lineMap;
+            this._start = start;
+            this._length = length;
+        }
+        Location.prototype.fileName = function () {
+            return this._fileName;
+        };
+
+        Location.prototype.lineMap = function () {
+            return this._lineMap;
+        };
+
+        Location.prototype.line = function () {
+            return this._lineMap ? this._lineMap.getLineNumberFromPosition(this.start()) : 0;
+        };
+
+        Location.prototype.character = function () {
+            return this._lineMap ? this._lineMap.getLineAndCharacterFromPosition(this.start()).character() : 0;
+        };
+
+        Location.prototype.start = function () {
+            return this._start;
+        };
+
+        Location.prototype.length = function () {
+            return this._length;
+        };
+
+        Location.equals = function (location1, location2) {
+            return location1._fileName === location2._fileName && location1._start === location2._start && location1._length === location2._length;
+        };
+        return Location;
+    })();
+    TypeScript.Location = Location;
+
+    var Diagnostic = (function (_super) {
+        __extends(Diagnostic, _super);
+        function Diagnostic(fileName, lineMap, start, length, diagnosticKey, _arguments, additionalLocations) {
+            if (typeof _arguments === "undefined") { _arguments = null; }
+            if (typeof additionalLocations === "undefined") { additionalLocations = null; }
+            _super.call(this, fileName, lineMap, start, length);
+            this._diagnosticKey = diagnosticKey;
+            this._arguments = (_arguments && _arguments.length > 0) ? _arguments : null;
+            this._additionalLocations = (additionalLocations && additionalLocations.length > 0) ? additionalLocations : null;
+        }
+        Diagnostic.prototype.toJSON = function (key) {
+            var result = {};
+            result.start = this.start();
+            result.length = this.length();
+
+            result.diagnosticCode = this._diagnosticKey;
+
+            var _arguments = this.arguments();
+            if (_arguments && _arguments.length > 0) {
+                result.arguments = _arguments;
+            }
+
+            return result;
+        };
+
+        Diagnostic.prototype.diagnosticKey = function () {
+            return this._diagnosticKey;
+        };
+
+        Diagnostic.prototype.arguments = function () {
+            return this._arguments;
+        };
+
+        Diagnostic.prototype.text = function () {
+            return TypeScript.getLocalizedText(this._diagnosticKey, this._arguments);
+        };
+
+        Diagnostic.prototype.message = function () {
+            return TypeScript.getDiagnosticMessage(this._diagnosticKey, this._arguments);
+        };
+
+        Diagnostic.prototype.additionalLocations = function () {
+            return this._additionalLocations || [];
+        };
+
+        Diagnostic.equals = function (diagnostic1, diagnostic2) {
+            return Location.equals(diagnostic1, diagnostic2) && diagnostic1._diagnosticKey === diagnostic2._diagnosticKey && TypeScript.ArrayUtilities.sequenceEquals(diagnostic1._arguments, diagnostic2._arguments, function (v1, v2) {
+                return v1 === v2;
+            });
+        };
+
+        Diagnostic.prototype.info = function () {
+            return getDiagnosticInfoFromKey(this.diagnosticKey());
+        };
+        return Diagnostic;
+    })(Location);
+    TypeScript.Diagnostic = Diagnostic;
+
+    function newLine() {
+        return TypeScript.Environment ? TypeScript.Environment.newLine : "\r\n";
+    }
+    TypeScript.newLine = newLine;
+
+    function getLargestIndex(diagnostic) {
+        var largest = -1;
+        var regex = /\{(\d+)\}/g;
+
+        var match;
+        while (match = regex.exec(diagnostic)) {
+            var val = parseInt(match[1]);
+            if (!isNaN(val) && val > largest) {
+                largest = val;
+            }
+        }
+
+        return largest;
+    }
+
+    function getDiagnosticInfoFromKey(diagnosticKey) {
+        var result = TypeScript.diagnosticInformationMap[diagnosticKey];
+        TypeScript.Debug.assert(result);
+        return result;
+    }
+
+    function getLocalizedText(diagnosticKey, args) {
+        if (TypeScript.LocalizedDiagnosticMessages) {
+        }
+
+        var diagnosticMessageText = TypeScript.LocalizedDiagnosticMessages ? TypeScript.LocalizedDiagnosticMessages[diagnosticKey] : diagnosticKey;
+        TypeScript.Debug.assert(diagnosticMessageText !== undefined && diagnosticMessageText !== null);
+
+        var actualCount = args ? args.length : 0;
+
+        var expectedCount = 1 + getLargestIndex(diagnosticKey);
+
+        if (expectedCount !== actualCount) {
+            throw new Error(getLocalizedText(TypeScript.DiagnosticCode.Expected_0_arguments_to_message_got_1_instead, [expectedCount, actualCount]));
+        }
+
+        var valueCount = 1 + getLargestIndex(diagnosticMessageText);
+        if (valueCount !== expectedCount) {
+            throw new Error(getLocalizedText(TypeScript.DiagnosticCode.Expected_the_message_0_to_have_1_arguments_but_it_had_2, [diagnosticMessageText, expectedCount, valueCount]));
+        }
+
+        diagnosticMessageText = diagnosticMessageText.replace(/{(\d+)}/g, function (match, num) {
+            return typeof args[num] !== 'undefined' ? args[num] : match;
+        });
+
+        diagnosticMessageText = diagnosticMessageText.replace(/{(NL)}/g, function (match) {
+            return TypeScript.newLine();
+        });
+
+        return diagnosticMessageText;
+    }
+    TypeScript.getLocalizedText = getLocalizedText;
+
+    function getDiagnosticMessage(diagnosticKey, args) {
+        var diagnostic = getDiagnosticInfoFromKey(diagnosticKey);
+        var diagnosticMessageText = getLocalizedText(diagnosticKey, args);
+
+        var message;
+        if (diagnostic.category === 1 /* Error */) {
+            message = getLocalizedText(TypeScript.DiagnosticCode.error_TS_0_1, [diagnostic.code, diagnosticMessageText]);
+        } else if (diagnostic.category === 0 /* Warning */) {
+            message = getLocalizedText(TypeScript.DiagnosticCode.warning_TS_0_1, [diagnostic.code, diagnosticMessageText]);
+        } else {
+            message = diagnosticMessageText;
+        }
+
+        return message;
+    }
+    TypeScript.getDiagnosticMessage = getDiagnosticMessage;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var Errors = (function () {
+        function Errors() {
+        }
+        Errors.argument = function (argument, message) {
+            return new Error("Invalid argument: " + argument + ". " + message);
+        };
+
+        Errors.argumentOutOfRange = function (argument) {
+            return new Error("Argument out of range: " + argument);
+        };
+
+        Errors.argumentNull = function (argument) {
+            return new Error("Argument null: " + argument);
+        };
+
+        Errors.abstract = function () {
+            return new Error("Operation not implemented properly by subclass.");
+        };
+
+        Errors.notYetImplemented = function () {
+            return new Error("Not yet implemented.");
+        };
+
+        Errors.invalidOperation = function (message) {
+            return new Error("Invalid operation: " + message);
+        };
+        return Errors;
+    })();
+    TypeScript.Errors = Errors;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var Hash = (function () {
+        function Hash() {
+        }
+        Hash.computeFnv1aCharArrayHashCode = function (text, start, len) {
+            var hashCode = Hash.FNV_BASE;
+            var end = start + len;
+
+            for (var i = start; i < end; i++) {
+                hashCode = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(hashCode ^ text[i], Hash.FNV_PRIME);
+            }
+
+            return hashCode;
+        };
+
+        Hash.computeSimple31BitCharArrayHashCode = function (key, start, len) {
+            var hash = 0;
+
+            for (var i = 0; i < len; i++) {
+                var ch = key[start + i];
+
+                hash = ((((hash << 5) - hash) | 0) + ch) | 0;
+            }
+
+            return hash & 0x7FFFFFFF;
+        };
+
+        Hash.computeSimple31BitStringHashCode = function (key) {
+            var hash = 0;
+
+            var start = 0;
+            var len = key.length;
+
+            for (var i = 0; i < len; i++) {
+                var ch = key.charCodeAt(start + i);
+
+                hash = ((((hash << 5) - hash) | 0) + ch) | 0;
+            }
+
+            return hash & 0x7FFFFFFF;
+        };
+
+        Hash.computeMurmur2StringHashCode = function (key, seed) {
+            var m = 0x5bd1e995;
+            var r = 24;
+
+            var numberOfCharsLeft = key.length;
+            var h = Math.abs(seed ^ numberOfCharsLeft);
+
+            var index = 0;
+            while (numberOfCharsLeft >= 2) {
+                var c1 = key.charCodeAt(index);
+                var c2 = key.charCodeAt(index + 1);
+
+                var k = Math.abs(c1 | (c2 << 16));
+
+                k = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(k, m);
+                k ^= k >> r;
+                k = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(k, m);
+
+                h = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(h, m);
+                h ^= k;
+
+                index += 2;
+                numberOfCharsLeft -= 2;
+            }
+
+            if (numberOfCharsLeft === 1) {
+                h ^= key.charCodeAt(index);
+                h = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(h, m);
+            }
+
+            h ^= h >> 13;
+            h = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(h, m);
+            h ^= h >> 15;
+
+            return h;
+        };
+
+        Hash.getPrime = function (min) {
+            for (var i = 0; i < Hash.primes.length; i++) {
+                var num = Hash.primes[i];
+                if (num >= min) {
+                    return num;
+                }
+            }
+
+            throw TypeScript.Errors.notYetImplemented();
+        };
+
+        Hash.expandPrime = function (oldSize) {
+            var num = oldSize << 1;
+            if (num > 2146435069 && 2146435069 > oldSize) {
+                return 2146435069;
+            }
+            return Hash.getPrime(num);
+        };
+
+        Hash.combine = function (value, currentHash) {
+            return (((currentHash << 5) + currentHash) + value) & 0x7FFFFFFF;
+        };
+        Hash.FNV_BASE = 2166136261;
+        Hash.FNV_PRIME = 16777619;
+
+        Hash.primes = [
+            3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521,
+            631, 761, 919, 1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419,
+            10103, 12143, 14591, 17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431,
+            90523, 108631, 130363, 156437, 187751, 225307, 270371, 324449, 389357, 467237, 560689,
+            672827, 807403, 968897, 1162687, 1395263, 1674319, 2009191, 2411033, 2893249, 3471899,
+            4166287, 4999559, 5999471, 7199369];
+        return Hash;
+    })();
+    TypeScript.Hash = Hash;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (Collections) {
+        Collections.DefaultHashTableCapacity = 1024;
+
+        var HashTableEntry = (function () {
+            function HashTableEntry(Key, Value, HashCode, Next) {
+                this.Key = Key;
+                this.Value = Value;
+                this.HashCode = HashCode;
+                this.Next = Next;
+            }
+            return HashTableEntry;
+        })();
+
+        var HashTable = (function () {
+            function HashTable(capacity, hash) {
+                this.hash = hash;
+                this.count = 0;
+                var size = TypeScript.Hash.getPrime(capacity);
+                this.entries = TypeScript.ArrayUtilities.createArray(size, null);
+            }
+            HashTable.prototype.set = function (key, value) {
+                this.addOrSet(key, value, false);
+            };
+
+            HashTable.prototype.add = function (key, value) {
+                this.addOrSet(key, value, true);
+            };
+
+            HashTable.prototype.containsKey = function (key) {
+                var hashCode = this.computeHashCode(key);
+                var entry = this.findEntry(key, hashCode);
+                return entry !== null;
+            };
+
+            HashTable.prototype.get = function (key) {
+                var hashCode = this.computeHashCode(key);
+                var entry = this.findEntry(key, hashCode);
+
+                return entry === null ? null : entry.Value;
+            };
+
+            HashTable.prototype.computeHashCode = function (key) {
+                var hashCode = this.hash === null ? key.hashCode : this.hash(key);
+
+                hashCode = hashCode & 0x7FFFFFFF;
+                TypeScript.Debug.assert(hashCode >= 0);
+
+                return hashCode;
+            };
+
+            HashTable.prototype.addOrSet = function (key, value, throwOnExistingEntry) {
+                var hashCode = this.computeHashCode(key);
+
+                var entry = this.findEntry(key, hashCode);
+                if (entry !== null) {
+                    if (throwOnExistingEntry) {
+                        throw TypeScript.Errors.argument('key', "Key was already in table.");
+                    }
+
+                    entry.Key = key;
+                    entry.Value = value;
+                    return;
+                }
+
+                return this.addEntry(key, value, hashCode);
+            };
+
+            HashTable.prototype.findEntry = function (key, hashCode) {
+                for (var e = this.entries[hashCode % this.entries.length]; e !== null; e = e.Next) {
+                    if (e.HashCode === hashCode && key === e.Key) {
+                        return e;
+                    }
+                }
+
+                return null;
+            };
+
+            HashTable.prototype.addEntry = function (key, value, hashCode) {
+                var index = hashCode % this.entries.length;
+
+                var e = new HashTableEntry(key, value, hashCode, this.entries[index]);
+
+                this.entries[index] = e;
+
+                if (this.count >= (this.entries.length / 2)) {
+                    this.grow();
+                }
+
+                this.count++;
+                return e.Key;
+            };
+
+            HashTable.prototype.grow = function () {
+                var newSize = TypeScript.Hash.expandPrime(this.entries.length);
+
+                var oldEntries = this.entries;
+                var newEntries = TypeScript.ArrayUtilities.createArray(newSize, null);
+
+                this.entries = newEntries;
+
+                for (var i = 0; i < oldEntries.length; i++) {
+                    var e = oldEntries[i];
+
+                    while (e !== null) {
+                        var newIndex = e.HashCode % newSize;
+                        var tmp = e.Next;
+                        e.Next = newEntries[newIndex];
+                        newEntries[newIndex] = e;
+                        e = tmp;
+                    }
+                }
+            };
+            return HashTable;
+        })();
+        Collections.HashTable = HashTable;
+
+        function createHashTable(capacity, hash) {
+            if (typeof capacity === "undefined") { capacity = Collections.DefaultHashTableCapacity; }
+            if (typeof hash === "undefined") { hash = null; }
+            return new HashTable(capacity, hash);
+        }
+        Collections.createHashTable = createHashTable;
+
+        var currentHashCode = 1;
+        function identityHashCode(value) {
+            if (value.__hash === undefined) {
+                value.__hash = currentHashCode;
+                currentHashCode++;
+            }
+
+            return value.__hash;
+        }
+        Collections.identityHashCode = identityHashCode;
+    })(TypeScript.Collections || (TypeScript.Collections = {}));
+    var Collections = TypeScript.Collections;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    TypeScript.nodeMakeDirectoryTime = 0;
+    TypeScript.nodeCreateBufferTime = 0;
+    TypeScript.nodeWriteFileSyncTime = 0;
+
+    (function (ByteOrderMark) {
+        ByteOrderMark[ByteOrderMark["None"] = 0] = "None";
+        ByteOrderMark[ByteOrderMark["Utf8"] = 1] = "Utf8";
+        ByteOrderMark[ByteOrderMark["Utf16BigEndian"] = 2] = "Utf16BigEndian";
+        ByteOrderMark[ByteOrderMark["Utf16LittleEndian"] = 3] = "Utf16LittleEndian";
+    })(TypeScript.ByteOrderMark || (TypeScript.ByteOrderMark = {}));
+    var ByteOrderMark = TypeScript.ByteOrderMark;
+
+    var FileInformation = (function () {
+        function FileInformation(contents, byteOrderMark) {
+            this.contents = contents;
+            this.byteOrderMark = byteOrderMark;
+        }
+        return FileInformation;
+    })();
+    TypeScript.FileInformation = FileInformation;
+
+    TypeScript.Environment = (function () {
+        function getWindowsScriptHostEnvironment() {
+            try  {
+                var fso = new ActiveXObject("Scripting.FileSystemObject");
+            } catch (e) {
+                return null;
+            }
+
+            var streamObjectPool = [];
+
+            function getStreamObject() {
+                if (streamObjectPool.length > 0) {
+                    return streamObjectPool.pop();
+                } else {
+                    return new ActiveXObject("ADODB.Stream");
+                }
+            }
+
+            function releaseStreamObject(obj) {
+                streamObjectPool.push(obj);
+            }
+
+            var args = [];
+            for (var i = 0; i < WScript.Arguments.length; i++) {
+                args[i] = WScript.Arguments.Item(i);
+            }
+
+            return {
+                newLine: "\r\n",
+                currentDirectory: function () {
+                    return WScript.CreateObject("WScript.Shell").CurrentDirectory;
+                },
+                supportsCodePage: function () {
+                    return WScript.ReadFile;
+                },
+                readFile: function (path, codepage) {
+                    try  {
+                        if (codepage !== null && this.supportsCodePage()) {
+                            try  {
+                                var contents = WScript.ReadFile(path, codepage);
+                                return new FileInformation(contents, 0 /* None */);
+                            } catch (e) {
+                            }
+                        }
+
+                        var streamObj = getStreamObject();
+                        streamObj.Open();
+                        streamObj.Type = 2;
+
+                        streamObj.Charset = 'x-ansi';
+
+                        streamObj.LoadFromFile(path);
+                        var bomChar = streamObj.ReadText(2);
+
+                        streamObj.Position = 0;
+
+                        var byteOrderMark = 0 /* None */;
+
+                        if (bomChar.charCodeAt(0) === 0xFE && bomChar.charCodeAt(1) === 0xFF) {
+                            streamObj.Charset = 'unicode';
+                            byteOrderMark = 2 /* Utf16BigEndian */;
+                        } else if (bomChar.charCodeAt(0) === 0xFF && bomChar.charCodeAt(1) === 0xFE) {
+                            streamObj.Charset = 'unicode';
+                            byteOrderMark = 3 /* Utf16LittleEndian */;
+                        } else if (bomChar.charCodeAt(0) === 0xEF && bomChar.charCodeAt(1) === 0xBB) {
+                            streamObj.Charset = 'utf-8';
+                            byteOrderMark = 1 /* Utf8 */;
+                        } else {
+                            streamObj.Charset = 'utf-8';
+                        }
+
+                        var contents = streamObj.ReadText(-1);
+                        streamObj.Close();
+                        releaseStreamObject(streamObj);
+                        return new FileInformation(contents, byteOrderMark);
+                    } catch (err) {
+                        var message;
+                        if (err.number === -2147024809) {
+                            message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Unsupported_file_encoding, null);
+                        } else {
+                            message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Cannot_read_file_0_1, [path, err.message]);
+                        }
+
+                        throw new Error(message);
+                    }
+                },
+                writeFile: function (path, contents, writeByteOrderMark) {
+                    var textStream = getStreamObject();
+                    textStream.Charset = 'utf-8';
+                    textStream.Open();
+                    textStream.WriteText(contents, 0);
+
+                    if (!writeByteOrderMark) {
+                        textStream.Position = 3;
+                    } else {
+                        textStream.Position = 0;
+                    }
+
+                    var fileStream = getStreamObject();
+                    fileStream.Type = 1;
+                    fileStream.Open();
+
+                    textStream.CopyTo(fileStream);
+
+                    fileStream.Flush();
+                    fileStream.SaveToFile(path, 2);
+                    fileStream.Close();
+
+                    textStream.Flush();
+                    textStream.Close();
+                },
+                fileExists: function (path) {
+                    return fso.FileExists(path);
+                },
+                deleteFile: function (path) {
+                    if (fso.FileExists(path)) {
+                        fso.DeleteFile(path, true);
+                    }
+                },
+                directoryExists: function (path) {
+                    return fso.FolderExists(path);
+                },
+                listFiles: function (path, spec, options) {
+                    options = options || {};
+                    function filesInFolder(folder, root) {
+                        var paths = [];
+                        var fc;
+
+                        if (options.recursive) {
+                            fc = new Enumerator(folder.subfolders);
+
+                            for (; !fc.atEnd(); fc.moveNext()) {
+                                paths = paths.concat(filesInFolder(fc.item(), root + "\\" + fc.item().Name));
+                            }
+                        }
+
+                        fc = new Enumerator(folder.files);
+
+                        for (; !fc.atEnd(); fc.moveNext()) {
+                            if (!spec || fc.item().Name.match(spec)) {
+                                paths.push(root + "\\" + fc.item().Name);
+                            }
+                        }
+
+                        return paths;
+                    }
+
+                    var folder = fso.GetFolder(path);
+                    var paths = [];
+
+                    return filesInFolder(folder, path);
+                },
+                arguments: args,
+                standardOut: WScript.StdOut
+            };
+        }
+        ;
+
+        function getNodeEnvironment() {
+            var _fs = require('fs');
+            var _path = require('path');
+            var _module = require('module');
+            var _os = require('os');
+
+            return {
+                newLine: _os.EOL,
+                currentDirectory: function () {
+                    return process.cwd();
+                },
+                supportsCodePage: function () {
+                    return false;
+                },
+                readFile: function (file, codepage) {
+                    if (codepage !== null) {
+                        throw new Error(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.codepage_option_not_supported_on_current_platform, null));
+                    }
+
+                    var buffer = _fs.readFileSync(file);
+                    switch (buffer[0]) {
+                        case 0xFE:
+                            if (buffer[1] === 0xFF) {
+                                var i = 0;
+                                while ((i + 1) < buffer.length) {
+                                    var temp = buffer[i];
+                                    buffer[i] = buffer[i + 1];
+                                    buffer[i + 1] = temp;
+                                    i += 2;
+                                }
+                                return new FileInformation(buffer.toString("ucs2", 2), 2 /* Utf16BigEndian */);
+                            }
+                            break;
+                        case 0xFF:
+                            if (buffer[1] === 0xFE) {
+                                return new FileInformation(buffer.toString("ucs2", 2), 3 /* Utf16LittleEndian */);
+                            }
+                            break;
+                        case 0xEF:
+                            if (buffer[1] === 0xBB) {
+                                return new FileInformation(buffer.toString("utf8", 3), 1 /* Utf8 */);
+                            }
+                    }
+
+                    return new FileInformation(buffer.toString("utf8", 0), 0 /* None */);
+                },
+                writeFile: function (path, contents, writeByteOrderMark) {
+                    function mkdirRecursiveSync(path) {
+                        var stats = _fs.statSync(path);
+                        if (stats.isFile()) {
+                            throw "\"" + path + "\" exists but isn't a directory.";
+                        } else if (stats.isDirectory()) {
+                            return;
+                        } else {
+                            mkdirRecursiveSync(_path.dirname(path));
+                            _fs.mkdirSync(path, 509);
+                        }
+                    }
+                    var start = new Date().getTime();
+                    mkdirRecursiveSync(_path.dirname(path));
+                    TypeScript.nodeMakeDirectoryTime += new Date().getTime() - start;
+
+                    if (writeByteOrderMark) {
+                        contents = '\uFEFF' + contents;
+                    }
+
+                    var start = new Date().getTime();
+
+                    var chunkLength = 4 * 1024;
+                    var fileDescriptor = _fs.openSync(path, "w");
+                    try  {
+                        for (var index = 0; index < contents.length; index += chunkLength) {
+                            var bufferStart = new Date().getTime();
+                            var buffer = new Buffer(contents.substr(index, chunkLength), "utf8");
+                            TypeScript.nodeCreateBufferTime += new Date().getTime() - bufferStart;
+
+                            _fs.writeSync(fileDescriptor, buffer, 0, buffer.length, null);
+                        }
+                    } finally {
+                        _fs.closeSync(fileDescriptor);
+                    }
+
+                    TypeScript.nodeWriteFileSyncTime += new Date().getTime() - start;
+                },
+                fileExists: function (path) {
+                    return _fs.existsSync(path);
+                },
+                deleteFile: function (path) {
+                    try  {
+                        _fs.unlinkSync(path);
+                    } catch (e) {
+                    }
+                },
+                directoryExists: function (path) {
+                    return _fs.existsSync(path) && _fs.statSync(path).isDirectory();
+                },
+                listFiles: function dir(path, spec, options) {
+                    options = options || {};
+
+                    function filesInFolder(folder) {
+                        var paths = [];
+
+                        var files = _fs.readdirSync(folder);
+                        for (var i = 0; i < files.length; i++) {
+                            var stat = _fs.statSync(folder + "\\" + files[i]);
+                            if (options.recursive && stat.isDirectory()) {
+                                paths = paths.concat(filesInFolder(folder + "\\" + files[i]));
+                            } else if (stat.isFile() && (!spec || files[i].match(spec))) {
+                                paths.push(folder + "\\" + files[i]);
+                            }
+                        }
+
+                        return paths;
+                    }
+
+                    return filesInFolder(path);
+                },
+                arguments: process.argv.slice(2),
+                standardOut: {
+                    Write: function (str) {
+                        process.stdout.write(str);
+                    },
+                    WriteLine: function (str) {
+                        process.stdout.write(str + '\n');
+                    },
+                    Close: function () {
+                    }
+                }
+            };
+        }
+        ;
+
+        if (typeof WScript !== "undefined" && typeof ActiveXObject === "function") {
+            return getWindowsScriptHostEnvironment();
+        } else if (typeof module !== 'undefined' && module.exports) {
+            return getNodeEnvironment();
+        } else {
+            return null;
+        }
+    })();
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (IntegerUtilities) {
+        function integerDivide(numerator, denominator) {
+            return (numerator / denominator) >> 0;
+        }
+        IntegerUtilities.integerDivide = integerDivide;
+
+        function integerMultiplyLow32Bits(n1, n2) {
+            var n1Low16 = n1 & 0x0000ffff;
+            var n1High16 = n1 >>> 16;
+
+            var n2Low16 = n2 & 0x0000ffff;
+            var n2High16 = n2 >>> 16;
+
+            var resultLow32 = (((n1 & 0xffff0000) * n2) >>> 0) + (((n1 & 0x0000ffff) * n2) >>> 0) >>> 0;
+            return resultLow32;
+        }
+        IntegerUtilities.integerMultiplyLow32Bits = integerMultiplyLow32Bits;
+
+        function integerMultiplyHigh32Bits(n1, n2) {
+            var n1Low16 = n1 & 0x0000ffff;
+            var n1High16 = n1 >>> 16;
+
+            var n2Low16 = n2 & 0x0000ffff;
+            var n2High16 = n2 >>> 16;
+
+            var resultHigh32 = n1High16 * n2High16 + ((((n1Low16 * n2Low16) >>> 17) + n1Low16 * n2High16) >>> 15);
+            return resultHigh32;
+        }
+        IntegerUtilities.integerMultiplyHigh32Bits = integerMultiplyHigh32Bits;
+
+        function isInteger(text) {
+            return /^[0-9]+$/.test(text);
+        }
+        IntegerUtilities.isInteger = isInteger;
+
+        function isHexInteger(text) {
+            return /^0(x|X)[0-9a-fA-F]+$/.test(text);
+        }
+        IntegerUtilities.isHexInteger = isHexInteger;
+    })(TypeScript.IntegerUtilities || (TypeScript.IntegerUtilities = {}));
+    var IntegerUtilities = TypeScript.IntegerUtilities;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var LineMap = (function () {
+        function LineMap(_computeLineStarts, length) {
+            this._computeLineStarts = _computeLineStarts;
+            this.length = length;
+            this._lineStarts = null;
+        }
+        LineMap.prototype.toJSON = function (key) {
+            return { lineStarts: this.lineStarts(), length: this.length };
+        };
+
+        LineMap.prototype.equals = function (other) {
+            return this.length === other.length && TypeScript.ArrayUtilities.sequenceEquals(this.lineStarts(), other.lineStarts(), function (v1, v2) {
+                return v1 === v2;
+            });
+        };
+
+        LineMap.prototype.lineStarts = function () {
+            if (this._lineStarts === null) {
+                this._lineStarts = this._computeLineStarts();
+            }
+
+            return this._lineStarts;
+        };
+
+        LineMap.prototype.lineCount = function () {
+            return this.lineStarts().length;
+        };
+
+        LineMap.prototype.getPosition = function (line, character) {
+            return this.lineStarts()[line] + character;
+        };
+
+        LineMap.prototype.getLineNumberFromPosition = function (position) {
+            if (position < 0 || position > this.length) {
+                throw TypeScript.Errors.argumentOutOfRange("position");
+            }
+
+            if (position === this.length) {
+                return this.lineCount() - 1;
+            }
+
+            var lineNumber = TypeScript.ArrayUtilities.binarySearch(this.lineStarts(), position);
+            if (lineNumber < 0) {
+                lineNumber = (~lineNumber) - 1;
+            }
+
+            return lineNumber;
+        };
+
+        LineMap.prototype.getLineStartPosition = function (lineNumber) {
+            return this.lineStarts()[lineNumber];
+        };
+
+        LineMap.prototype.fillLineAndCharacterFromPosition = function (position, lineAndCharacter) {
+            if (position < 0 || position > this.length) {
+                throw TypeScript.Errors.argumentOutOfRange("position");
+            }
+
+            var lineNumber = this.getLineNumberFromPosition(position);
+            lineAndCharacter.line = lineNumber;
+            lineAndCharacter.character = position - this.lineStarts()[lineNumber];
+        };
+
+        LineMap.prototype.getLineAndCharacterFromPosition = function (position) {
+            if (position < 0 || position > this.length) {
+                throw TypeScript.Errors.argumentOutOfRange("position");
+            }
+
+            var lineNumber = this.getLineNumberFromPosition(position);
+
+            return new TypeScript.LineAndCharacter(lineNumber, position - this.lineStarts()[lineNumber]);
+        };
+        LineMap.empty = new LineMap(function () {
+            return [0];
+        }, 0);
+        return LineMap;
+    })();
+    TypeScript.LineMap = LineMap;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var LineAndCharacter = (function () {
+        function LineAndCharacter(line, character) {
+            this._line = 0;
+            this._character = 0;
+            if (line < 0) {
+                throw TypeScript.Errors.argumentOutOfRange("line");
+            }
+
+            if (character < 0) {
+                throw TypeScript.Errors.argumentOutOfRange("character");
+            }
+
+            this._line = line;
+            this._character = character;
+        }
+        LineAndCharacter.prototype.line = function () {
+            return this._line;
+        };
+
+        LineAndCharacter.prototype.character = function () {
+            return this._character;
+        };
+        return LineAndCharacter;
+    })();
+    TypeScript.LineAndCharacter = LineAndCharacter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var MathPrototype = (function () {
+        function MathPrototype() {
+        }
+        MathPrototype.max = function (a, b) {
+            return a >= b ? a : b;
+        };
+
+        MathPrototype.min = function (a, b) {
+            return a <= b ? a : b;
+        };
+        return MathPrototype;
+    })();
+    TypeScript.MathPrototype = MathPrototype;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (Collections) {
+        Collections.DefaultStringTableCapacity = 256;
+
+        var StringTableEntry = (function () {
+            function StringTableEntry(Text, HashCode, Next) {
+                this.Text = Text;
+                this.HashCode = HashCode;
+                this.Next = Next;
+            }
+            return StringTableEntry;
+        })();
+
+        var StringTable = (function () {
+            function StringTable(capacity) {
+                this.count = 0;
+                var size = TypeScript.Hash.getPrime(capacity);
+                this.entries = TypeScript.ArrayUtilities.createArray(size, null);
+            }
+            StringTable.prototype.addCharArray = function (key, start, len) {
+                var hashCode = TypeScript.Hash.computeSimple31BitCharArrayHashCode(key, start, len) & 0x7FFFFFFF;
+
+                var entry = this.findCharArrayEntry(key, start, len, hashCode);
+                if (entry !== null) {
+                    return entry.Text;
+                }
+
+                var slice = key.slice(start, start + len);
+                return this.addEntry(TypeScript.StringUtilities.fromCharCodeArray(slice), hashCode);
+            };
+
+            StringTable.prototype.findCharArrayEntry = function (key, start, len, hashCode) {
+                for (var e = this.entries[hashCode % this.entries.length]; e !== null; e = e.Next) {
+                    if (e.HashCode === hashCode && StringTable.textCharArrayEquals(e.Text, key, start, len)) {
+                        return e;
+                    }
+                }
+
+                return null;
+            };
+
+            StringTable.prototype.addEntry = function (text, hashCode) {
+                var index = hashCode % this.entries.length;
+
+                var e = new StringTableEntry(text, hashCode, this.entries[index]);
+
+                this.entries[index] = e;
+
+                if (this.count === this.entries.length) {
+                    this.grow();
+                }
+
+                this.count++;
+                return e.Text;
+            };
+
+            StringTable.prototype.grow = function () {
+                var newSize = TypeScript.Hash.expandPrime(this.entries.length);
+
+                var oldEntries = this.entries;
+                var newEntries = TypeScript.ArrayUtilities.createArray(newSize, null);
+
+                this.entries = newEntries;
+
+                for (var i = 0; i < oldEntries.length; i++) {
+                    var e = oldEntries[i];
+                    while (e !== null) {
+                        var newIndex = e.HashCode % newSize;
+                        var tmp = e.Next;
+                        e.Next = newEntries[newIndex];
+                        newEntries[newIndex] = e;
+                        e = tmp;
+                    }
+                }
+            };
+
+            StringTable.textCharArrayEquals = function (text, array, start, length) {
+                if (text.length !== length) {
+                    return false;
+                }
+
+                var s = start;
+                for (var i = 0; i < length; i++) {
+                    if (text.charCodeAt(i) !== array[s]) {
+                        return false;
+                    }
+
+                    s++;
+                }
+
+                return true;
+            };
+            return StringTable;
+        })();
+        Collections.StringTable = StringTable;
+
+        Collections.DefaultStringTable = new StringTable(Collections.DefaultStringTableCapacity);
+    })(TypeScript.Collections || (TypeScript.Collections = {}));
+    var Collections = TypeScript.Collections;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var StringUtilities = (function () {
+        function StringUtilities() {
+        }
+        StringUtilities.isString = function (value) {
+            return Object.prototype.toString.apply(value, []) === '[object String]';
+        };
+
+        StringUtilities.fromCharCodeArray = function (array) {
+            return String.fromCharCode.apply(null, array);
+        };
+
+        StringUtilities.endsWith = function (string, value) {
+            return string.substring(string.length - value.length, string.length) === value;
+        };
+
+        StringUtilities.startsWith = function (string, value) {
+            return string.substr(0, value.length) === value;
+        };
+
+        StringUtilities.copyTo = function (source, sourceIndex, destination, destinationIndex, count) {
+            for (var i = 0; i < count; i++) {
+                destination[destinationIndex + i] = source.charCodeAt(sourceIndex + i);
+            }
+        };
+
+        StringUtilities.repeat = function (value, count) {
+            return Array(count + 1).join(value);
+        };
+
+        StringUtilities.stringEquals = function (val1, val2) {
+            return val1 === val2;
+        };
+        return StringUtilities;
+    })();
+    TypeScript.StringUtilities = StringUtilities;
+})(TypeScript || (TypeScript = {}));
+var global = Function("return this").call(null);
+
+var TypeScript;
+(function (TypeScript) {
+    var Clock;
+    (function (Clock) {
+        Clock.now;
+        Clock.resolution;
+
+        if (typeof WScript !== "undefined" && typeof global['WScript'].InitializeProjection !== "undefined") {
+            global['WScript'].InitializeProjection();
+
+            Clock.now = function () {
+                return TestUtilities.QueryPerformanceCounter();
+            };
+
+            Clock.resolution = TestUtilities.QueryPerformanceFrequency();
+        } else {
+            Clock.now = function () {
+                return Date.now();
+            };
+
+            Clock.resolution = 1000;
+        }
+    })(Clock || (Clock = {}));
+
+    var Timer = (function () {
+        function Timer() {
+            this.time = 0;
+        }
+        Timer.prototype.start = function () {
+            this.time = 0;
+            this.startTime = Clock.now();
+        };
+
+        Timer.prototype.end = function () {
+            this.time = (Clock.now() - this.startTime);
+        };
+        return Timer;
+    })();
+    TypeScript.Timer = Timer;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (DiagnosticCategory) {
+        DiagnosticCategory[DiagnosticCategory["Warning"] = 0] = "Warning";
+        DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error";
+        DiagnosticCategory[DiagnosticCategory["Message"] = 2] = "Message";
+        DiagnosticCategory[DiagnosticCategory["NoPrefix"] = 3] = "NoPrefix";
+    })(TypeScript.DiagnosticCategory || (TypeScript.DiagnosticCategory = {}));
+    var DiagnosticCategory = TypeScript.DiagnosticCategory;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    TypeScript.diagnosticInformationMap = {
+        "error TS{0}: {1}": {
+            "code": 0,
+            "category": 3 /* NoPrefix */
+        },
+        "warning TS{0}: {1}": {
+            "code": 1,
+            "category": 3 /* NoPrefix */
+        },
+        "Unrecognized escape sequence.": {
+            "code": 1000,
+            "category": 1 /* Error */
+        },
+        "Unexpected character {0}.": {
+            "code": 1001,
+            "category": 1 /* Error */
+        },
+        "Missing close quote character.": {
+            "code": 1002,
+            "category": 1 /* Error */
+        },
+        "Identifier expected.": {
+            "code": 1003,
+            "category": 1 /* Error */
+        },
+        "'{0}' keyword expected.": {
+            "code": 1004,
+            "category": 1 /* Error */
+        },
+        "'{0}' expected.": {
+            "code": 1005,
+            "category": 1 /* Error */
+        },
+        "Identifier expected; '{0}' is a keyword.": {
+            "code": 1006,
+            "category": 1 /* Error */
+        },
+        "Automatic semicolon insertion not allowed.": {
+            "code": 1007,
+            "category": 1 /* Error */
+        },
+        "Unexpected token; '{0}' expected.": {
+            "code": 1008,
+            "category": 1 /* Error */
+        },
+        "Trailing separator not allowed.": {
+            "code": 1009,
+            "category": 1 /* Error */
+        },
+        "'*/' expected.": {
+            "code": 1010,
+            "category": 1 /* Error */
+        },
+        "'public' or 'private' modifier must precede 'static'.": {
+            "code": 1011,
+            "category": 1 /* Error */
+        },
+        "Unexpected token.": {
+            "code": 1012,
+            "category": 1 /* Error */
+        },
+        "Catch clause parameter cannot have a type annotation.": {
+            "code": 1013,
+            "category": 1 /* Error */
+        },
+        "Rest parameter must be last in list.": {
+            "code": 1014,
+            "category": 1 /* Error */
+        },
+        "Parameter cannot have question mark and initializer.": {
+            "code": 1015,
+            "category": 1 /* Error */
+        },
+        "Required parameter cannot follow optional parameter.": {
+            "code": 1016,
+            "category": 1 /* Error */
+        },
+        "Index signatures cannot have rest parameters.": {
+            "code": 1017,
+            "category": 1 /* Error */
+        },
+        "Index signature parameter cannot have accessibility modifiers.": {
+            "code": 1018,
+            "category": 1 /* Error */
+        },
+        "Index signature parameter cannot have a question mark.": {
+            "code": 1019,
+            "category": 1 /* Error */
+        },
+        "Index signature parameter cannot have an initializer.": {
+            "code": 1020,
+            "category": 1 /* Error */
+        },
+        "Index signature must have a type annotation.": {
+            "code": 1021,
+            "category": 1 /* Error */
+        },
+        "Index signature parameter must have a type annotation.": {
+            "code": 1022,
+            "category": 1 /* Error */
+        },
+        "Index signature parameter type must be 'string' or 'number'.": {
+            "code": 1023,
+            "category": 1 /* Error */
+        },
+        "'extends' clause already seen.": {
+            "code": 1024,
+            "category": 1 /* Error */
+        },
+        "'extends' clause must precede 'implements' clause.": {
+            "code": 1025,
+            "category": 1 /* Error */
+        },
+        "Classes can only extend a single class.": {
+            "code": 1026,
+            "category": 1 /* Error */
+        },
+        "'implements' clause already seen.": {
+            "code": 1027,
+            "category": 1 /* Error */
+        },
+        "Accessibility modifier already seen.": {
+            "code": 1028,
+            "category": 1 /* Error */
+        },
+        "'{0}' modifier must precede '{1}' modifier.": {
+            "code": 1029,
+            "category": 1 /* Error */
+        },
+        "'{0}' modifier already seen.": {
+            "code": 1030,
+            "category": 1 /* Error */
+        },
+        "'{0}' modifier cannot appear on a class element.": {
+            "code": 1031,
+            "category": 1 /* Error */
+        },
+        "Interface declaration cannot have 'implements' clause.": {
+            "code": 1032,
+            "category": 1 /* Error */
+        },
+        "'super' invocation cannot have type arguments.": {
+            "code": 1034,
+            "category": 1 /* Error */
+        },
+        "Only ambient modules can use quoted names.": {
+            "code": 1035,
+            "category": 1 /* Error */
+        },
+        "Statements are not allowed in ambient contexts.": {
+            "code": 1036,
+            "category": 1 /* Error */
+        },
+        "Implementations are not allowed in ambient contexts.": {
+            "code": 1037,
+            "category": 1 /* Error */
+        },
+        "'declare' modifier not allowed for code already in an ambient context.": {
+            "code": 1038,
+            "category": 1 /* Error */
+        },
+        "Initializers are not allowed in ambient contexts.": {
+            "code": 1039,
+            "category": 1 /* Error */
+        },
+        "Parameter property declarations can only be used in a non-ambient constructor declaration.": {
+            "code": 1040,
+            "category": 1 /* Error */
+        },
+        "Function implementation expected.": {
+            "code": 1041,
+            "category": 1 /* Error */
+        },
+        "Constructor implementation expected.": {
+            "code": 1042,
+            "category": 1 /* Error */
+        },
+        "Function overload name must be '{0}'.": {
+            "code": 1043,
+            "category": 1 /* Error */
+        },
+        "'{0}' modifier cannot appear on a module element.": {
+            "code": 1044,
+            "category": 1 /* Error */
+        },
+        "'declare' modifier cannot appear on an interface declaration.": {
+            "code": 1045,
+            "category": 1 /* Error */
+        },
+        "'declare' modifier required for top level element.": {
+            "code": 1046,
+            "category": 1 /* Error */
+        },
+        "Rest parameter cannot be optional.": {
+            "code": 1047,
+            "category": 1 /* Error */
+        },
+        "Rest parameter cannot have an initializer.": {
+            "code": 1048,
+            "category": 1 /* Error */
+        },
+        "'set' accessor must have one and only one parameter.": {
+            "code": 1049,
+            "category": 1 /* Error */
+        },
+        "'set' accessor parameter cannot be optional.": {
+            "code": 1051,
+            "category": 1 /* Error */
+        },
+        "'set' accessor parameter cannot have an initializer.": {
+            "code": 1052,
+            "category": 1 /* Error */
+        },
+        "'set' accessor cannot have rest parameter.": {
+            "code": 1053,
+            "category": 1 /* Error */
+        },
+        "'get' accessor cannot have parameters.": {
+            "code": 1054,
+            "category": 1 /* Error */
+        },
+        "Modifiers cannot appear here.": {
+            "code": 1055,
+            "category": 1 /* Error */
+        },
+        "Accessors are only available when targeting ECMAScript 5 and higher.": {
+            "code": 1056,
+            "category": 1 /* Error */
+        },
+        "Class name cannot be '{0}'.": {
+            "code": 1057,
+            "category": 1 /* Error */
+        },
+        "Interface name cannot be '{0}'.": {
+            "code": 1058,
+            "category": 1 /* Error */
+        },
+        "Enum name cannot be '{0}'.": {
+            "code": 1059,
+            "category": 1 /* Error */
+        },
+        "Module name cannot be '{0}'.": {
+            "code": 1060,
+            "category": 1 /* Error */
+        },
+        "Enum member must have initializer.": {
+            "code": 1061,
+            "category": 1 /* Error */
+        },
+        "Export assignment cannot be used in internal modules.": {
+            "code": 1063,
+            "category": 1 /* Error */
+        },
+        "Export assignment not allowed in module with exported element.": {
+            "code": 1064,
+            "category": 1 /* Error */
+        },
+        "Module cannot have multiple export assignments.": {
+            "code": 1065,
+            "category": 1 /* Error */
+        },
+        "Ambient enum elements can only have integer literal initializers.": {
+            "code": 1066,
+            "category": 1 /* Error */
+        },
+        "module, class, interface, enum, import or statement": {
+            "code": 1067,
+            "category": 3 /* NoPrefix */
+        },
+        "constructor, function, accessor or variable": {
+            "code": 1068,
+            "category": 3 /* NoPrefix */
+        },
+        "statement": {
+            "code": 1069,
+            "category": 3 /* NoPrefix */
+        },
+        "case or default clause": {
+            "code": 1070,
+            "category": 3 /* NoPrefix */
+        },
+        "identifier": {
+            "code": 1071,
+            "category": 3 /* NoPrefix */
+        },
+        "call, construct, index, property or function signature": {
+            "code": 1072,
+            "category": 3 /* NoPrefix */
+        },
+        "expression": {
+            "code": 1073,
+            "category": 3 /* NoPrefix */
+        },
+        "type name": {
+            "code": 1074,
+            "category": 3 /* NoPrefix */
+        },
+        "property or accessor": {
+            "code": 1075,
+            "category": 3 /* NoPrefix */
+        },
+        "parameter": {
+            "code": 1076,
+            "category": 3 /* NoPrefix */
+        },
+        "type": {
+            "code": 1077,
+            "category": 3 /* NoPrefix */
+        },
+        "type parameter": {
+            "code": 1078,
+            "category": 3 /* NoPrefix */
+        },
+        "'declare' modifier not allowed on import declaration.": {
+            "code": 1079,
+            "category": 1 /* Error */
+        },
+        "Function overload must be static.": {
+            "code": 1080,
+            "category": 1 /* Error */
+        },
+        "Function overload must not be static.": {
+            "code": 1081,
+            "category": 1 /* Error */
+        },
+        "Parameter property declarations cannot be used in a constructor overload.": {
+            "code": 1083,
+            "category": 1 /* Error */
+        },
+        "Invalid 'reference' directive syntax.": {
+            "code": 1084,
+            "category": 1 /* Error */
+        },
+        "Octal literals are not available when targeting ECMAScript 5 and higher.": {
+            "code": 1085,
+            "category": 1 /* Error */
+        },
+        "Accessors are not allowed in ambient contexts.": {
+            "code": 1086,
+            "category": 1 /* Error */
+        },
+        "'{0}' modifier cannot appear on a constructor declaration.": {
+            "code": 1089,
+            "category": 1 /* Error */
+        },
+        "'{0}' modifier cannot appear on a parameter.": {
+            "code": 1090,
+            "category": 1 /* Error */
+        },
+        "Only a single variable declaration is allowed in a 'for...in' statement.": {
+            "code": 1091,
+            "category": 1 /* Error */
+        },
+        "Type parameters cannot appear on a constructor declaration.": {
+            "code": 1091,
+            "category": 1 /* Error */
+        },
+        "Type annotation cannot appear on a constructor declaration.": {
+            "code": 1092,
+            "category": 1 /* Error */
+        },
+        "Duplicate identifier '{0}'.": {
+            "code": 2000,
+            "category": 1 /* Error */
+        },
+        "The name '{0}' does not exist in the current scope.": {
+            "code": 2001,
+            "category": 1 /* Error */
+        },
+        "The name '{0}' does not refer to a value.": {
+            "code": 2002,
+            "category": 1 /* Error */
+        },
+        "'super' can only be used inside a class instance method.": {
+            "code": 2003,
+            "category": 1 /* Error */
+        },
+        "The left-hand side of an assignment expression must be a variable, property or indexer.": {
+            "code": 2004,
+            "category": 1 /* Error */
+        },
+        "Value of type '{0}' is not callable. Did you mean to include 'new'?": {
+            "code": 2161,
+            "category": 1 /* Error */
+        },
+        "Value of type '{0}' is not callable.": {
+            "code": 2006,
+            "category": 1 /* Error */
+        },
+        "Value of type '{0}' is not newable.": {
+            "code": 2007,
+            "category": 1 /* Error */
+        },
+        "Value of type '{0}' is not indexable by type '{1}'.": {
+            "code": 2008,
+            "category": 1 /* Error */
+        },
+        "Operator '{0}' cannot be applied to types '{1}' and '{2}'.": {
+            "code": 2009,
+            "category": 1 /* Error */
+        },
+        "Operator '{0}' cannot be applied to types '{1}' and '{2}': {3}": {
+            "code": 2010,
+            "category": 1 /* Error */
+        },
+        "Cannot convert '{0}' to '{1}'.": {
+            "code": 2011,
+            "category": 1 /* Error */
+        },
+        "Cannot convert '{0}' to '{1}':{NL}{2}": {
+            "code": 2012,
+            "category": 1 /* Error */
+        },
+        "Expected var, class, interface, or module.": {
+            "code": 2013,
+            "category": 1 /* Error */
+        },
+        "Operator '{0}' cannot be applied to type '{1}'.": {
+            "code": 2014,
+            "category": 1 /* Error */
+        },
+        "Getter '{0}' already declared.": {
+            "code": 2015,
+            "category": 1 /* Error */
+        },
+        "Setter '{0}' already declared.": {
+            "code": 2016,
+            "category": 1 /* Error */
+        },
+        "Exported class '{0}' extends private class '{1}'.": {
+            "code": 2018,
+            "category": 1 /* Error */
+        },
+        "Exported class '{0}' implements private interface '{1}'.": {
+            "code": 2019,
+            "category": 1 /* Error */
+        },
+        "Exported interface '{0}' extends private interface '{1}'.": {
+            "code": 2020,
+            "category": 1 /* Error */
+        },
+        "Exported class '{0}' extends class from inaccessible module {1}.": {
+            "code": 2021,
+            "category": 1 /* Error */
+        },
+        "Exported class '{0}' implements interface from inaccessible module {1}.": {
+            "code": 2022,
+            "category": 1 /* Error */
+        },
+        "Exported interface '{0}' extends interface from inaccessible module {1}.": {
+            "code": 2023,
+            "category": 1 /* Error */
+        },
+        "Public static property '{0}' of exported class has or is using private type '{1}'.": {
+            "code": 2024,
+            "category": 1 /* Error */
+        },
+        "Public property '{0}' of exported class has or is using private type '{1}'.": {
+            "code": 2025,
+            "category": 1 /* Error */
+        },
+        "Property '{0}' of exported interface has or is using private type '{1}'.": {
+            "code": 2026,
+            "category": 1 /* Error */
+        },
+        "Exported variable '{0}' has or is using private type '{1}'.": {
+            "code": 2027,
+            "category": 1 /* Error */
+        },
+        "Public static property '{0}' of exported class is using inaccessible module {1}.": {
+            "code": 2028,
+            "category": 1 /* Error */
+        },
+        "Public property '{0}' of exported class is using inaccessible module {1}.": {
+            "code": 2029,
+            "category": 1 /* Error */
+        },
+        "Property '{0}' of exported interface is using inaccessible module {1}.": {
+            "code": 2030,
+            "category": 1 /* Error */
+        },
+        "Exported variable '{0}' is using inaccessible module {1}.": {
+            "code": 2031,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of constructor from exported class has or is using private type '{1}'.": {
+            "code": 2032,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public static property setter from exported class has or is using private type '{1}'.": {
+            "code": 2033,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public property setter from exported class has or is using private type '{1}'.": {
+            "code": 2034,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.": {
+            "code": 2035,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of call signature from exported interface has or is using private type '{1}'.": {
+            "code": 2036,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public static method from exported class has or is using private type '{1}'.": {
+            "code": 2037,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public method from exported class has or is using private type '{1}'.": {
+            "code": 2038,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of method from exported interface has or is using private type '{1}'.": {
+            "code": 2039,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of exported function has or is using private type '{1}'.": {
+            "code": 2040,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of constructor from exported class is using inaccessible module {1}.": {
+            "code": 2041,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public static property setter from exported class is using inaccessible module {1}.": {
+            "code": 2042,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public property setter from exported class is using inaccessible module {1}.": {
+            "code": 2043,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.": {
+            "code": 2044,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of call signature from exported interface is using inaccessible module {1}": {
+            "code": 2045,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public static method from exported class is using inaccessible module {1}.": {
+            "code": 2046,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public method from exported class is using inaccessible module {1}.": {
+            "code": 2047,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of method from exported interface is using inaccessible module {1}.": {
+            "code": 2048,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of exported function is using inaccessible module {1}.": {
+            "code": 2049,
+            "category": 1 /* Error */
+        },
+        "Return type of public static property getter from exported class has or is using private type '{0}'.": {
+            "code": 2050,
+            "category": 1 /* Error */
+        },
+        "Return type of public property getter from exported class has or is using private type '{0}'.": {
+            "code": 2051,
+            "category": 1 /* Error */
+        },
+        "Return type of constructor signature from exported interface has or is using private type '{0}'.": {
+            "code": 2052,
+            "category": 1 /* Error */
+        },
+        "Return type of call signature from exported interface has or is using private type '{0}'.": {
+            "code": 2053,
+            "category": 1 /* Error */
+        },
+        "Return type of index signature from exported interface has or is using private type '{0}'.": {
+            "code": 2054,
+            "category": 1 /* Error */
+        },
+        "Return type of public static method from exported class has or is using private type '{0}'.": {
+            "code": 2055,
+            "category": 1 /* Error */
+        },
+        "Return type of public method from exported class has or is using private type '{0}'.": {
+            "code": 2056,
+            "category": 1 /* Error */
+        },
+        "Return type of method from exported interface has or is using private type '{0}'.": {
+            "code": 2057,
+            "category": 1 /* Error */
+        },
+        "Return type of exported function has or is using private type '{0}'.": {
+            "code": 2058,
+            "category": 1 /* Error */
+        },
+        "Return type of public static property getter from exported class is using inaccessible module {0}.": {
+            "code": 2059,
+            "category": 1 /* Error */
+        },
+        "Return type of public property getter from exported class is using inaccessible module {0}.": {
+            "code": 2060,
+            "category": 1 /* Error */
+        },
+        "Return type of constructor signature from exported interface is using inaccessible module {0}.": {
+            "code": 2061,
+            "category": 1 /* Error */
+        },
+        "Return type of call signature from exported interface is using inaccessible module {0}.": {
+            "code": 2062,
+            "category": 1 /* Error */
+        },
+        "Return type of index signature from exported interface is using inaccessible module {0}.": {
+            "code": 2063,
+            "category": 1 /* Error */
+        },
+        "Return type of public static method from exported class is using inaccessible module {0}.": {
+            "code": 2064,
+            "category": 1 /* Error */
+        },
+        "Return type of public method from exported class is using inaccessible module {0}.": {
+            "code": 2065,
+            "category": 1 /* Error */
+        },
+        "Return type of method from exported interface is using inaccessible module {0}.": {
+            "code": 2066,
+            "category": 1 /* Error */
+        },
+        "Return type of exported function is using inaccessible module {0}.": {
+            "code": 2067,
+            "category": 1 /* Error */
+        },
+        "'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.": {
+            "code": 2068,
+            "category": 1 /* Error */
+        },
+        "A parameter list must follow a generic type argument list. '(' expected.": {
+            "code": 2069,
+            "category": 1 /* Error */
+        },
+        "Multiple constructor implementations are not allowed.": {
+            "code": 2070,
+            "category": 1 /* Error */
+        },
+        "Unable to resolve external module '{0}'.": {
+            "code": 2071,
+            "category": 1 /* Error */
+        },
+        "Module cannot be aliased to a non-module type.": {
+            "code": 2072,
+            "category": 1 /* Error */
+        },
+        "A class may only extend another class.": {
+            "code": 2073,
+            "category": 1 /* Error */
+        },
+        "A class may only implement another class or interface.": {
+            "code": 2074,
+            "category": 1 /* Error */
+        },
+        "An interface may only extend another class or interface.": {
+            "code": 2075,
+            "category": 1 /* Error */
+        },
+        "Unable to resolve type.": {
+            "code": 2077,
+            "category": 1 /* Error */
+        },
+        "Unable to resolve type of '{0}'.": {
+            "code": 2078,
+            "category": 1 /* Error */
+        },
+        "Unable to resolve type parameter constraint.": {
+            "code": 2079,
+            "category": 1 /* Error */
+        },
+        "Type parameter constraint cannot be a primitive type.": {
+            "code": 2080,
+            "category": 1 /* Error */
+        },
+        "Supplied parameters do not match any signature of call target.": {
+            "code": 2081,
+            "category": 1 /* Error */
+        },
+        "Supplied parameters do not match any signature of call target:{NL}{0}": {
+            "code": 2082,
+            "category": 1 /* Error */
+        },
+        "Invalid 'new' expression.": {
+            "code": 2083,
+            "category": 1 /* Error */
+        },
+        "Call signatures used in a 'new' expression must have a 'void' return type.": {
+            "code": 2084,
+            "category": 1 /* Error */
+        },
+        "Could not select overload for 'new' expression.": {
+            "code": 2085,
+            "category": 1 /* Error */
+        },
+        "Type '{0}' does not satisfy the constraint '{1}' for type parameter '{2}'.": {
+            "code": 2086,
+            "category": 1 /* Error */
+        },
+        "Could not select overload for 'call' expression.": {
+            "code": 2087,
+            "category": 1 /* Error */
+        },
+        "Cannot invoke an expression whose type lacks a call signature.": {
+            "code": 2088,
+            "category": 1 /* Error */
+        },
+        "Calls to 'super' are only valid inside a class.": {
+            "code": 2089,
+            "category": 1 /* Error */
+        },
+        "Generic type '{0}' requires {1} type argument(s).": {
+            "code": 2090,
+            "category": 1 /* Error */
+        },
+        "Type of array literal cannot be determined. Best common type could not be found for array elements.": {
+            "code": 2092,
+            "category": 1 /* Error */
+        },
+        "Could not find enclosing symbol for dotted name '{0}'.": {
+            "code": 2093,
+            "category": 1 /* Error */
+        },
+        "The property '{0}' does not exist on value of type '{1}'.": {
+            "code": 2094,
+            "category": 1 /* Error */
+        },
+        "Could not find symbol '{0}'.": {
+            "code": 2095,
+            "category": 1 /* Error */
+        },
+        "'get' and 'set' accessor must have the same type.": {
+            "code": 2096,
+            "category": 1 /* Error */
+        },
+        "'this' cannot be referenced in current location.": {
+            "code": 2097,
+            "category": 1 /* Error */
+        },
+        "Static members cannot reference class type parameters.": {
+            "code": 2099,
+            "category": 1 /* Error */
+        },
+        "Class '{0}' is recursively referenced as a base type of itself.": {
+            "code": 2100,
+            "category": 1 /* Error */
+        },
+        "Interface '{0}' is recursively referenced as a base type of itself.": {
+            "code": 2101,
+            "category": 1 /* Error */
+        },
+        "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.": {
+            "code": 2102,
+            "category": 1 /* Error */
+        },
+        "'super' cannot be referenced in non-derived classes.": {
+            "code": 2103,
+            "category": 1 /* Error */
+        },
+        "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties.": {
+            "code": 2104,
+            "category": 1 /* Error */
+        },
+        "Constructors for derived classes must contain a 'super' call.": {
+            "code": 2105,
+            "category": 1 /* Error */
+        },
+        "Super calls are not permitted outside constructors or in nested functions inside constructors.": {
+            "code": 2106,
+            "category": 1 /* Error */
+        },
+        "'{0}.{1}' is inaccessible.": {
+            "code": 2107,
+            "category": 1 /* Error */
+        },
+        "'this' cannot be referenced within module bodies.": {
+            "code": 2108,
+            "category": 1 /* Error */
+        },
+        "Invalid '+' expression - types not known to support the addition operator.": {
+            "code": 2111,
+            "category": 1 /* Error */
+        },
+        "The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.": {
+            "code": 2112,
+            "category": 1 /* Error */
+        },
+        "The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.": {
+            "code": 2113,
+            "category": 1 /* Error */
+        },
+        "The type of a unary arithmetic operation operand must be of type 'any', 'number' or an enum type.": {
+            "code": 2114,
+            "category": 1 /* Error */
+        },
+        "Variable declarations of a 'for' statement cannot use a type annotation.": {
+            "code": 2115,
+            "category": 1 /* Error */
+        },
+        "Variable declarations of a 'for' statement must be of types 'string' or 'any'.": {
+            "code": 2116,
+            "category": 1 /* Error */
+        },
+        "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter.": {
+            "code": 2117,
+            "category": 1 /* Error */
+        },
+        "The left-hand side of an 'in' expression must be of types 'any', 'string' or 'number'.": {
+            "code": 2118,
+            "category": 1 /* Error */
+        },
+        "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter.": {
+            "code": 2119,
+            "category": 1 /* Error */
+        },
+        "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.": {
+            "code": 2120,
+            "category": 1 /* Error */
+        },
+        "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type.": {
+            "code": 2121,
+            "category": 1 /* Error */
+        },
+        "Setters cannot return a value.": {
+            "code": 2122,
+            "category": 1 /* Error */
+        },
+        "Tried to query type of uninitialized module '{0}'.": {
+            "code": 2123,
+            "category": 1 /* Error */
+        },
+        "Tried to set variable type to uninitialized module type '{0}'.": {
+            "code": 2124,
+            "category": 1 /* Error */
+        },
+        "Type '{0}' does not have type parameters.": {
+            "code": 2125,
+            "category": 1 /* Error */
+        },
+        "Getters must return a value.": {
+            "code": 2126,
+            "category": 1 /* Error */
+        },
+        "Getter and setter accessors do not agree in visibility.": {
+            "code": 2127,
+            "category": 1 /* Error */
+        },
+        "Invalid left-hand side of assignment expression.": {
+            "code": 2130,
+            "category": 1 /* Error */
+        },
+        "Function declared a non-void return type, but has no return expression.": {
+            "code": 2131,
+            "category": 1 /* Error */
+        },
+        "Cannot resolve return type reference.": {
+            "code": 2132,
+            "category": 1 /* Error */
+        },
+        "Constructors cannot have a return type of 'void'.": {
+            "code": 2133,
+            "category": 1 /* Error */
+        },
+        "Subsequent variable declarations must have the same type.  Variable '{0}' must be of type '{1}', but here has type '{2}'.": {
+            "code": 2134,
+            "category": 1 /* Error */
+        },
+        "All symbols within a with block will be resolved to 'any'.": {
+            "code": 2135,
+            "category": 1 /* Error */
+        },
+        "Import declarations in an internal module cannot reference an external module.": {
+            "code": 2136,
+            "category": 1 /* Error */
+        },
+        "Class {0} declares interface {1} but does not implement it:{NL}{2}": {
+            "code": 2137,
+            "category": 1 /* Error */
+        },
+        "Class {0} declares class {1} as an interface but does not implement it:{NL}{2}": {
+            "code": 2138,
+            "category": 1 /* Error */
+        },
+        "The operand of an increment or decrement operator must be a variable, property or indexer.": {
+            "code": 2139,
+            "category": 1 /* Error */
+        },
+        "'this' cannot be referenced in static initializers in a class body.": {
+            "code": 2140,
+            "category": 1 /* Error */
+        },
+        "Class '{0}' cannot extend class '{1}':{NL}{2}": {
+            "code": 2141,
+            "category": 1 /* Error */
+        },
+        "Interface '{0}' cannot extend class '{1}':{NL}{2}": {
+            "code": 2142,
+            "category": 1 /* Error */
+        },
+        "Interface '{0}' cannot extend interface '{1}':{NL}{2}": {
+            "code": 2143,
+            "category": 1 /* Error */
+        },
+        "Duplicate overload signature for '{0}'.": {
+            "code": 2144,
+            "category": 1 /* Error */
+        },
+        "Duplicate constructor overload signature.": {
+            "code": 2145,
+            "category": 1 /* Error */
+        },
+        "Duplicate overload call signature.": {
+            "code": 2146,
+            "category": 1 /* Error */
+        },
+        "Duplicate overload construct signature.": {
+            "code": 2147,
+            "category": 1 /* Error */
+        },
+        "Overload signature is not compatible with function definition.": {
+            "code": 2148,
+            "category": 1 /* Error */
+        },
+        "Overload signature is not compatible with function definition:{NL}{0}": {
+            "code": 2149,
+            "category": 1 /* Error */
+        },
+        "Overload signatures must all be public or private.": {
+            "code": 2150,
+            "category": 1 /* Error */
+        },
+        "Overload signatures must all be exported or not exported.": {
+            "code": 2151,
+            "category": 1 /* Error */
+        },
+        "Overload signatures must all be ambient or non-ambient.": {
+            "code": 2152,
+            "category": 1 /* Error */
+        },
+        "Overload signatures must all be optional or required.": {
+            "code": 2153,
+            "category": 1 /* Error */
+        },
+        "Specialized overload signature is not assignable to any non-specialized signature.": {
+            "code": 2154,
+            "category": 1 /* Error */
+        },
+        "'this' cannot be referenced in constructor arguments.": {
+            "code": 2155,
+            "category": 1 /* Error */
+        },
+        "Instance member cannot be accessed off a class.": {
+            "code": 2157,
+            "category": 1 /* Error */
+        },
+        "Untyped function calls may not accept type arguments.": {
+            "code": 2158,
+            "category": 1 /* Error */
+        },
+        "Non-generic functions may not accept type arguments.": {
+            "code": 2159,
+            "category": 1 /* Error */
+        },
+        "A generic type may not reference itself with a wrapped form of its own type parameters.": {
+            "code": 2160,
+            "category": 1 /* Error */
+        },
+        "Rest parameters must be array types.": {
+            "code": 2162,
+            "category": 1 /* Error */
+        },
+        "Overload signature implementation cannot use specialized type.": {
+            "code": 2163,
+            "category": 1 /* Error */
+        },
+        "Export assignments may only be used at the top-level of external modules.": {
+            "code": 2164,
+            "category": 1 /* Error */
+        },
+        "Export assignments may only be made with variables, functions, classes, interfaces, enums and internal modules.": {
+            "code": 2165,
+            "category": 1 /* Error */
+        },
+        "Only public methods of the base class are accessible via the 'super' keyword.": {
+            "code": 2166,
+            "category": 1 /* Error */
+        },
+        "Numeric indexer type '{0}' must be assignable to string indexer type '{1}'.": {
+            "code": 2167,
+            "category": 1 /* Error */
+        },
+        "Numeric indexer type '{0}' must be assignable to string indexer type '{1}':{NL}{2}": {
+            "code": 2168,
+            "category": 1 /* Error */
+        },
+        "All numerically named properties must be assignable to numeric indexer type '{0}'.": {
+            "code": 2169,
+            "category": 1 /* Error */
+        },
+        "All numerically named properties must be assignable to numeric indexer type '{0}':{NL}{1}": {
+            "code": 2170,
+            "category": 1 /* Error */
+        },
+        "All named properties must be assignable to string indexer type '{0}'.": {
+            "code": 2171,
+            "category": 1 /* Error */
+        },
+        "All named properties must be assignable to string indexer type '{0}':{NL}{1}": {
+            "code": 2172,
+            "category": 1 /* Error */
+        },
+        "Generic type references must include all type arguments.": {
+            "code": 2173,
+            "category": 1 /* Error */
+        },
+        "Default arguments are only allowed in implementation.": {
+            "code": 2174,
+            "category": 1 /* Error */
+        },
+        "Overloads cannot differ only by return type.": {
+            "code": 2175,
+            "category": 1 /* Error */
+        },
+        "Function expression declared a non-void return type, but has no return expression.": {
+            "code": 2176,
+            "category": 1 /* Error */
+        },
+        "Import declaration referencing identifier from internal module can only be made with variables, functions, classes, interfaces, enums and internal modules.": {
+            "code": 2177,
+            "category": 1 /* Error */
+        },
+        "Could not find symbol '{0}' in module '{1}'.": {
+            "code": 2178,
+            "category": 1 /* Error */
+        },
+        "Unable to resolve module reference '{0}'.": {
+            "code": 2179,
+            "category": 1 /* Error */
+        },
+        "Could not find module '{0}' in module '{1}'.": {
+            "code": 2180,
+            "category": 1 /* Error */
+        },
+        "Exported import declaration '{0}' is assigned value with type that has or is using private type '{1}'.": {
+            "code": 2181,
+            "category": 1 /* Error */
+        },
+        "Exported import declaration '{0}' is assigned value with type that is using inaccessible module '{1}'.": {
+            "code": 2182,
+            "category": 1 /* Error */
+        },
+        "Exported import declaration '{0}' is assigned type that has or is using private type '{1}'.": {
+            "code": 2183,
+            "category": 1 /* Error */
+        },
+        "Exported import declaration '{0}' is assigned type that is using inaccessible module '{1}'.": {
+            "code": 2184,
+            "category": 1 /* Error */
+        },
+        "Exported import declaration '{0}' is assigned container that is or is using inaccessible module '{1}'.": {
+            "code": 2185,
+            "category": 1 /* Error */
+        },
+        "Type name '{0}' in extends clause does not reference constructor function for '{1}'.": {
+            "code": 2186,
+            "category": 1 /* Error */
+        },
+        "Internal module reference '{0}' in import declaration does not reference module instance for '{1}'.": {
+            "code": 2187,
+            "category": 1 /* Error */
+        },
+        "Module '{0}' cannot merge with previous declaration of '{1}' in a different file '{2}'.": {
+            "code": 2188,
+            "category": 1 /* Error */
+        },
+        "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}':{NL}{3}": {
+            "code": 2189,
+            "category": 1 /* Error */
+        },
+        "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it.": {
+            "code": 2190,
+            "category": 1 /* Error */
+        },
+        "Ambient external module declaration cannot be reopened.": {
+            "code": 2191,
+            "category": 1 /* Error */
+        },
+        "All declarations of merged declaration '{0}' must be exported or not exported.": {
+            "code": 2192,
+            "category": 1 /* Error */
+        },
+        "'super' cannot be referenced in constructor arguments.": {
+            "code": 2193,
+            "category": 1 /* Error */
+        },
+        "Return type of constructor signature must be assignable to the instance type of the class.": {
+            "code": 2194,
+            "category": 1 /* Error */
+        },
+        "Ambient external module declaration must be defined in global context.": {
+            "code": 2195,
+            "category": 1 /* Error */
+        },
+        "Ambient external module declaration cannot specify relative module name.": {
+            "code": 2196,
+            "category": 1 /* Error */
+        },
+        "Import declaration in an ambient external module declaration cannot reference external module through relative external module name.": {
+            "code": 2197,
+            "category": 1 /* Error */
+        },
+        "Could not find the best common type of types of all return statement expressions.": {
+            "code": 2198,
+            "category": 1 /* Error */
+        },
+        "Import declaration cannot refer to external module reference when --noResolve option is set.": {
+            "code": 2199,
+            "category": 1 /* Error */
+        },
+        "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference.": {
+            "code": 2200,
+            "category": 1 /* Error */
+        },
+        "'continue' statement can only be used within an enclosing iteration statement.": {
+            "code": 2201,
+            "category": 1 /* Error */
+        },
+        "'break' statement can only be used within an enclosing iteration or switch statement.": {
+            "code": 2202,
+            "category": 1 /* Error */
+        },
+        "Jump target not found.": {
+            "code": 2203,
+            "category": 1 /* Error */
+        },
+        "Jump target cannot cross function boundary.": {
+            "code": 2204,
+            "category": 1 /* Error */
+        },
+        "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference.": {
+            "code": 2205,
+            "category": 1 /* Error */
+        },
+        "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference.": {
+            "code": 2206,
+            "category": 1 /* Error */
+        },
+        "Expression resolves to '_super' that compiler uses to capture base class reference.": {
+            "code": 2207,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.": {
+            "code": 2208,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of call signature from exported interface has or is using private type '{1}'.": {
+            "code": 2209,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of public static method from exported class has or is using private type '{1}'.": {
+            "code": 2210,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of public method from exported class has or is using private type '{1}'.": {
+            "code": 2211,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of method from exported interface has or is using private type '{1}'.": {
+            "code": 2212,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of exported function has or is using private type '{1}'.": {
+            "code": 2213,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.": {
+            "code": 2214,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of call signature from exported interface is using inaccessible module {1}": {
+            "code": 2215,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of public static method from exported class is using inaccessible module {1}.": {
+            "code": 2216,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of public method from exported class is using inaccessible module {1}.": {
+            "code": 2217,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of method from exported interface is using inaccessible module {1}.": {
+            "code": 2218,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of exported function is using inaccessible module {1}.": {
+            "code": 2219,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of exported class has or is using private type '{1}'.": {
+            "code": 2220,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of exported interface has or is using private type '{1}'.": {
+            "code": 2221,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of exported class is using inaccessible module {1}.": {
+            "code": 2222,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of exported interface is using inaccessible module {1}.": {
+            "code": 2223,
+            "category": 1 /* Error */
+        },
+        "Duplicate identifier '_i'. Compiler uses '_i' to initialize rest parameter.": {
+            "code": 2224,
+            "category": 1 /* Error */
+        },
+        "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.": {
+            "code": 2225,
+            "category": 1 /* Error */
+        },
+        "Type of conditional '{0}' must be identical to '{1}' or '{2}'.": {
+            "code": 2226,
+            "category": 1 /* Error */
+        },
+        "Type of conditional '{0}' must be identical to '{1}', '{2}' or '{3}'.": {
+            "code": 2227,
+            "category": 1 /* Error */
+        },
+        "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of an external module.": {
+            "code": 2228,
+            "category": 1 /* Error */
+        },
+        "Constraint of a type parameter cannot reference any type parameter from the same type parameter list.": {
+            "code": 2229,
+            "category": 1 /* Error */
+        },
+        "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor.": {
+            "code": 2230,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' cannot be referenced in its initializer.": {
+            "code": 2231,
+            "category": 1 /* Error */
+        },
+        "Duplicate string index signature.": {
+            "code": 2232,
+            "category": 1 /* Error */
+        },
+        "Duplicate number index signature.": {
+            "code": 2233,
+            "category": 1 /* Error */
+        },
+        "All declarations of an interface must have identical type parameters.": {
+            "code": 2234,
+            "category": 1 /* Error */
+        },
+        "Expression resolves to variable declaration '_i' that compiler uses to initialize rest parameter.": {
+            "code": 2235,
+            "category": 1 /* Error */
+        },
+        "Type '{0}' is missing property '{1}' from type '{2}'.": {
+            "code": 4000,
+            "category": 3 /* NoPrefix */
+        },
+        "Types of property '{0}' of types '{1}' and '{2}' are incompatible.": {
+            "code": 4001,
+            "category": 3 /* NoPrefix */
+        },
+        "Types of property '{0}' of types '{1}' and '{2}' are incompatible:{NL}{3}": {
+            "code": 4002,
+            "category": 3 /* NoPrefix */
+        },
+        "Property '{0}' defined as private in type '{1}' is defined as public in type '{2}'.": {
+            "code": 4003,
+            "category": 3 /* NoPrefix */
+        },
+        "Property '{0}' defined as public in type '{1}' is defined as private in type '{2}'.": {
+            "code": 4004,
+            "category": 3 /* NoPrefix */
+        },
+        "Types '{0}' and '{1}' define property '{2}' as private.": {
+            "code": 4005,
+            "category": 3 /* NoPrefix */
+        },
+        "Call signatures of types '{0}' and '{1}' are incompatible.": {
+            "code": 4006,
+            "category": 3 /* NoPrefix */
+        },
+        "Call signatures of types '{0}' and '{1}' are incompatible:{NL}{2}": {
+            "code": 4007,
+            "category": 3 /* NoPrefix */
+        },
+        "Type '{0}' requires a call signature, but type '{1}' lacks one.": {
+            "code": 4008,
+            "category": 3 /* NoPrefix */
+        },
+        "Construct signatures of types '{0}' and '{1}' are incompatible.": {
+            "code": 4009,
+            "category": 3 /* NoPrefix */
+        },
+        "Construct signatures of types '{0}' and '{1}' are incompatible:{NL}{2}": {
+            "code": 4010,
+            "category": 3 /* NoPrefix */
+        },
+        "Type '{0}' requires a construct signature, but type '{1}' lacks one.": {
+            "code": 4011,
+            "category": 3 /* NoPrefix */
+        },
+        "Index signatures of types '{0}' and '{1}' are incompatible.": {
+            "code": 4012,
+            "category": 3 /* NoPrefix */
+        },
+        "Index signatures of types '{0}' and '{1}' are incompatible:{NL}{2}": {
+            "code": 4013,
+            "category": 3 /* NoPrefix */
+        },
+        "Call signature expects {0} or fewer parameters.": {
+            "code": 4014,
+            "category": 3 /* NoPrefix */
+        },
+        "Could not apply type '{0}' to argument {1} which is of type '{2}'.": {
+            "code": 4015,
+            "category": 3 /* NoPrefix */
+        },
+        "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function.": {
+            "code": 4016,
+            "category": 3 /* NoPrefix */
+        },
+        "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function.": {
+            "code": 4017,
+            "category": 3 /* NoPrefix */
+        },
+        "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor.": {
+            "code": 4018,
+            "category": 3 /* NoPrefix */
+        },
+        "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property.": {
+            "code": 4019,
+            "category": 3 /* NoPrefix */
+        },
+        "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible.": {
+            "code": 4020,
+            "category": 3 /* NoPrefix */
+        },
+        "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible:{NL}{3}": {
+            "code": 4021,
+            "category": 3 /* NoPrefix */
+        },
+        "Type reference cannot refer to container '{0}'.": {
+            "code": 4022,
+            "category": 1 /* Error */
+        },
+        "Type reference must refer to type.": {
+            "code": 4023,
+            "category": 1 /* Error */
+        },
+        "In enums with multiple declarations only one declaration can omit an initializer for the first enum element.": {
+            "code": 4024,
+            "category": 1 /* Error */
+        },
+        " (+ {0} overload(s))": {
+            "code": 4025,
+            "category": 2 /* Message */
+        },
+        "Variable declaration cannot have the same name as an import declaration.": {
+            "code": 4026,
+            "category": 1 /* Error */
+        },
+        "Signature expected {0} type arguments, got {1} instead.": {
+            "code": 4027,
+            "category": 1 /* Error */
+        },
+        "Property '{0}' defined as optional in type '{1}', but is required in type '{2}'.": {
+            "code": 4028,
+            "category": 3 /* NoPrefix */
+        },
+        "Types '{0}' and '{1}' originating in infinitely expanding type reference do not refer to same named type.": {
+            "code": 4029,
+            "category": 3 /* NoPrefix */
+        },
+        "Types '{0}' and '{1}' originating in infinitely expanding type reference have incompatible type arguments.": {
+            "code": 4030,
+            "category": 3 /* NoPrefix */
+        },
+        "Types '{0}' and '{1}' originating in infinitely expanding type reference have incompatible type arguments:{NL}{2}": {
+            "code": 4031,
+            "category": 3 /* NoPrefix */
+        },
+        "Named properties '{0}' of types '{1}' and '{2}' are not identical.": {
+            "code": 4032,
+            "category": 3 /* NoPrefix */
+        },
+        "Types of string indexer of types '{0}' and '{1}' are not identical.": {
+            "code": 4033,
+            "category": 3 /* NoPrefix */
+        },
+        "Types of number indexer of types '{0}' and '{1}' are not identical.": {
+            "code": 4034,
+            "category": 3 /* NoPrefix */
+        },
+        "Type of number indexer in type '{0}' is not assignable to string indexer type in type '{1}'.{NL}{2}": {
+            "code": 4035,
+            "category": 3 /* NoPrefix */
+        },
+        "Type of property '{0}' in type '{1}' is not assignable to string indexer type in type '{2}'.{NL}{3}": {
+            "code": 4036,
+            "category": 3 /* NoPrefix */
+        },
+        "Type of property '{0}' in type '{1}' is not assignable to number indexer type in type '{2}'.{NL}{3}": {
+            "code": 4037,
+            "category": 3 /* NoPrefix */
+        },
+        "Static property '{0}' defined as private in type '{1}' is defined as public in type '{2}'.": {
+            "code": 4038,
+            "category": 3 /* NoPrefix */
+        },
+        "Static property '{0}' defined as public in type '{1}' is defined as private in type '{2}'.": {
+            "code": 4039,
+            "category": 3 /* NoPrefix */
+        },
+        "Types '{0}' and '{1}' define static property '{2}' as private.": {
+            "code": 4040,
+            "category": 3 /* NoPrefix */
+        },
+        "Current host does not support '{0}' option.": {
+            "code": 5001,
+            "category": 1 /* Error */
+        },
+        "ECMAScript target version '{0}' not supported.  Specify a valid target version: '{1}' (default), or '{2}'": {
+            "code": 5002,
+            "category": 1 /* Error */
+        },
+        "Module code generation '{0}' not supported.": {
+            "code": 5003,
+            "category": 1 /* Error */
+        },
+        "Could not find file: '{0}'.": {
+            "code": 5004,
+            "category": 1 /* Error */
+        },
+        "A file cannot have a reference to itself.": {
+            "code": 5006,
+            "category": 1 /* Error */
+        },
+        "Cannot resolve referenced file: '{0}'.": {
+            "code": 5007,
+            "category": 1 /* Error */
+        },
+        "Cannot find the common subdirectory path for the input files.": {
+            "code": 5009,
+            "category": 1 /* Error */
+        },
+        "Emit Error: {0}.": {
+            "code": 5011,
+            "category": 1 /* Error */
+        },
+        "Cannot read file '{0}': {1}": {
+            "code": 5012,
+            "category": 1 /* Error */
+        },
+        "Unsupported file encoding.": {
+            "code": 5013,
+            "category": 3 /* NoPrefix */
+        },
+        "Locale must be of the form <language> or <language>-<territory>. For example '{0}' or '{1}'.": {
+            "code": 5014,
+            "category": 1 /* Error */
+        },
+        "Unsupported locale: '{0}'.": {
+            "code": 5015,
+            "category": 1 /* Error */
+        },
+        "Execution Failed.{NL}": {
+            "code": 5016,
+            "category": 1 /* Error */
+        },
+        "Invalid call to 'up'": {
+            "code": 5019,
+            "category": 1 /* Error */
+        },
+        "Invalid call to 'down'": {
+            "code": 5020,
+            "category": 1 /* Error */
+        },
+        "Base64 value '{0}' finished with a continuation bit.": {
+            "code": 5021,
+            "category": 1 /* Error */
+        },
+        "Unknown option '{0}'": {
+            "code": 5023,
+            "category": 1 /* Error */
+        },
+        "Expected {0} arguments to message, got {1} instead.": {
+            "code": 5024,
+            "category": 1 /* Error */
+        },
+        "Expected the message '{0}' to have {1} arguments, but it had {2}": {
+            "code": 5025,
+            "category": 1 /* Error */
+        },
+        "Could not delete file '{0}'": {
+            "code": 5034,
+            "category": 1 /* Error */
+        },
+        "Could not create directory '{0}'": {
+            "code": 5035,
+            "category": 1 /* Error */
+        },
+        "Error while executing file '{0}': ": {
+            "code": 5036,
+            "category": 1 /* Error */
+        },
+        "Cannot compile external modules unless the '--module' flag is provided.": {
+            "code": 5037,
+            "category": 1 /* Error */
+        },
+        "Option mapRoot cannot be specified without specifying sourcemap option.": {
+            "code": 5038,
+            "category": 1 /* Error */
+        },
+        "Option sourceRoot cannot be specified without specifying sourcemap option.": {
+            "code": 5039,
+            "category": 1 /* Error */
+        },
+        "Options mapRoot and sourceRoot cannot be specified without specifying sourcemap option.": {
+            "code": 5040,
+            "category": 1 /* Error */
+        },
+        "Option '{0}' specified without '{1}'": {
+            "code": 5041,
+            "category": 1 /* Error */
+        },
+        "'codepage' option not supported on current platform.": {
+            "code": 5042,
+            "category": 1 /* Error */
+        },
+        "Concatenate and emit output to single file.": {
+            "code": 6001,
+            "category": 2 /* Message */
+        },
+        "Generates corresponding {0} file.": {
+            "code": 6002,
+            "category": 2 /* Message */
+        },
+        "Specifies the location where debugger should locate map files instead of generated locations.": {
+            "code": 6003,
+            "category": 2 /* Message */
+        },
+        "Specifies the location where debugger should locate TypeScript files instead of source locations.": {
+            "code": 6004,
+            "category": 2 /* Message */
+        },
+        "Watch input files.": {
+            "code": 6005,
+            "category": 2 /* Message */
+        },
+        "Redirect output structure to the directory.": {
+            "code": 6006,
+            "category": 2 /* Message */
+        },
+        "Do not emit comments to output.": {
+            "code": 6009,
+            "category": 2 /* Message */
+        },
+        "Skip resolution and preprocessing.": {
+            "code": 6010,
+            "category": 2 /* Message */
+        },
+        "Specify ECMAScript target version: '{0}' (default), or '{1}'": {
+            "code": 6015,
+            "category": 2 /* Message */
+        },
+        "Specify module code generation: '{0}' or '{1}'": {
+            "code": 6016,
+            "category": 2 /* Message */
+        },
+        "Print this message.": {
+            "code": 6017,
+            "category": 2 /* Message */
+        },
+        "Print the compiler's version: {0}": {
+            "code": 6019,
+            "category": 2 /* Message */
+        },
+        "Allow use of deprecated '{0}' keyword when referencing an external module.": {
+            "code": 6021,
+            "category": 2 /* Message */
+        },
+        "Specify locale for errors and messages. For example '{0}' or '{1}'": {
+            "code": 6022,
+            "category": 2 /* Message */
+        },
+        "Syntax:   {0}": {
+            "code": 6023,
+            "category": 2 /* Message */
+        },
+        "options": {
+            "code": 6024,
+            "category": 2 /* Message */
+        },
+        "file1": {
+            "code": 6025,
+            "category": 2 /* Message */
+        },
+        "Examples:": {
+            "code": 6026,
+            "category": 2 /* Message */
+        },
+        "Options:": {
+            "code": 6027,
+            "category": 2 /* Message */
+        },
+        "Insert command line options and files from a file.": {
+            "code": 6030,
+            "category": 2 /* Message */
+        },
+        "Version {0}": {
+            "code": 6029,
+            "category": 2 /* Message */
+        },
+        "Use the '{0}' flag to see options.": {
+            "code": 6031,
+            "category": 2 /* Message */
+        },
+        "{NL}Recompiling ({0}):": {
+            "code": 6032,
+            "category": 2 /* Message */
+        },
+        "STRING": {
+            "code": 6033,
+            "category": 2 /* Message */
+        },
+        "KIND": {
+            "code": 6034,
+            "category": 2 /* Message */
+        },
+        "file2": {
+            "code": 6035,
+            "category": 2 /* Message */
+        },
+        "VERSION": {
+            "code": 6036,
+            "category": 2 /* Message */
+        },
+        "LOCATION": {
+            "code": 6037,
+            "category": 2 /* Message */
+        },
+        "DIRECTORY": {
+            "code": 6038,
+            "category": 2 /* Message */
+        },
+        "NUMBER": {
+            "code": 6039,
+            "category": 2 /* Message */
+        },
+        "Specify the codepage to use when opening source files.": {
+            "code": 6040,
+            "category": 2 /* Message */
+        },
+        "Additional locations:": {
+            "code": 6041,
+            "category": 2 /* Message */
+        },
+        "This version of the Javascript runtime does not support the '{0}' function.": {
+            "code": 7000,
+            "category": 1 /* Error */
+        },
+        "Unknown rule.": {
+            "code": 7002,
+            "category": 1 /* Error */
+        },
+        "Invalid line number ({0})": {
+            "code": 7003,
+            "category": 1 /* Error */
+        },
+        "Warn on expressions and declarations with an implied 'any' type.": {
+            "code": 7004,
+            "category": 2 /* Message */
+        },
+        "Variable '{0}' implicitly has an 'any' type.": {
+            "code": 7005,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of '{1}' implicitly has an 'any' type.": {
+            "code": 7006,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of function type implicitly has an 'any' type.": {
+            "code": 7007,
+            "category": 1 /* Error */
+        },
+        "Member '{0}' of object type implicitly has an 'any' type.": {
+            "code": 7008,
+            "category": 1 /* Error */
+        },
+        "'new' expression, which lacks a constructor signature, implicitly has an 'any' type.": {
+            "code": 7009,
+            "category": 1 /* Error */
+        },
+        "'{0}', which lacks return-type annotation, implicitly has an 'any' return type.": {
+            "code": 7010,
+            "category": 1 /* Error */
+        },
+        "Function expression, which lacks return-type annotation, implicitly has an 'any' return type.": {
+            "code": 7011,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of lambda function implicitly has an 'any' type.": {
+            "code": 7012,
+            "category": 1 /* Error */
+        },
+        "Constructor signature, which lacks return-type annotation, implicitly has an 'any' return type.": {
+            "code": 7013,
+            "category": 1 /* Error */
+        },
+        "Lambda Function, which lacks return-type annotation, implicitly has an 'any' return type.": {
+            "code": 7014,
+            "category": 1 /* Error */
+        },
+        "Array Literal implicitly has an 'any' type from widening.": {
+            "code": 7015,
+            "category": 1 /* Error */
+        },
+        "'{0}', which lacks 'get' accessor and parameter type annotation on 'set' accessor, implicitly has an 'any' type.": {
+            "code": 7016,
+            "category": 1 /* Error */
+        },
+        "Index signature of object type implicitly has an 'any' type.": {
+            "code": 7017,
+            "category": 1 /* Error */
+        },
+        "Object literal's property '{0}' implicitly has an 'any' type from widening.": {
+            "code": 7018,
+            "category": 1 /* Error */
+        }
+    };
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (CharacterCodes) {
+        CharacterCodes[CharacterCodes["nullCharacter"] = 0] = "nullCharacter";
+        CharacterCodes[CharacterCodes["maxAsciiCharacter"] = 127] = "maxAsciiCharacter";
+
+        CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
+        CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
+        CharacterCodes[CharacterCodes["lineSeparator"] = 0x2028] = "lineSeparator";
+        CharacterCodes[CharacterCodes["paragraphSeparator"] = 0x2029] = "paragraphSeparator";
+
+        CharacterCodes[CharacterCodes["nextLine"] = 0x0085] = "nextLine";
+
+        CharacterCodes[CharacterCodes["space"] = 0x0020] = "space";
+        CharacterCodes[CharacterCodes["nonBreakingSpace"] = 0x00A0] = "nonBreakingSpace";
+        CharacterCodes[CharacterCodes["enQuad"] = 0x2000] = "enQuad";
+        CharacterCodes[CharacterCodes["emQuad"] = 0x2001] = "emQuad";
+        CharacterCodes[CharacterCodes["enSpace"] = 0x2002] = "enSpace";
+        CharacterCodes[CharacterCodes["emSpace"] = 0x2003] = "emSpace";
+        CharacterCodes[CharacterCodes["threePerEmSpace"] = 0x2004] = "threePerEmSpace";
+        CharacterCodes[CharacterCodes["fourPerEmSpace"] = 0x2005] = "fourPerEmSpace";
+        CharacterCodes[CharacterCodes["sixPerEmSpace"] = 0x2006] = "sixPerEmSpace";
+        CharacterCodes[CharacterCodes["figureSpace"] = 0x2007] = "figureSpace";
+        CharacterCodes[CharacterCodes["punctuationSpace"] = 0x2008] = "punctuationSpace";
+        CharacterCodes[CharacterCodes["thinSpace"] = 0x2009] = "thinSpace";
+        CharacterCodes[CharacterCodes["hairSpace"] = 0x200A] = "hairSpace";
+        CharacterCodes[CharacterCodes["zeroWidthSpace"] = 0x200B] = "zeroWidthSpace";
+        CharacterCodes[CharacterCodes["narrowNoBreakSpace"] = 0x202F] = "narrowNoBreakSpace";
+        CharacterCodes[CharacterCodes["ideographicSpace"] = 0x3000] = "ideographicSpace";
+
+        CharacterCodes[CharacterCodes["_"] = 95] = "_";
+        CharacterCodes[CharacterCodes["$"] = 36] = "$";
+
+        CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
+        CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
+        CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
+
+        CharacterCodes[CharacterCodes["a"] = 97] = "a";
+        CharacterCodes[CharacterCodes["b"] = 98] = "b";
+        CharacterCodes[CharacterCodes["c"] = 99] = "c";
+        CharacterCodes[CharacterCodes["d"] = 100] = "d";
+        CharacterCodes[CharacterCodes["e"] = 101] = "e";
+        CharacterCodes[CharacterCodes["f"] = 102] = "f";
+        CharacterCodes[CharacterCodes["g"] = 103] = "g";
+        CharacterCodes[CharacterCodes["h"] = 104] = "h";
+        CharacterCodes[CharacterCodes["i"] = 105] = "i";
+        CharacterCodes[CharacterCodes["k"] = 107] = "k";
+        CharacterCodes[CharacterCodes["l"] = 108] = "l";
+        CharacterCodes[CharacterCodes["m"] = 109] = "m";
+        CharacterCodes[CharacterCodes["n"] = 110] = "n";
+        CharacterCodes[CharacterCodes["o"] = 111] = "o";
+        CharacterCodes[CharacterCodes["p"] = 112] = "p";
+        CharacterCodes[CharacterCodes["q"] = 113] = "q";
+        CharacterCodes[CharacterCodes["r"] = 114] = "r";
+        CharacterCodes[CharacterCodes["s"] = 115] = "s";
+        CharacterCodes[CharacterCodes["t"] = 116] = "t";
+        CharacterCodes[CharacterCodes["u"] = 117] = "u";
+        CharacterCodes[CharacterCodes["v"] = 118] = "v";
+        CharacterCodes[CharacterCodes["w"] = 119] = "w";
+        CharacterCodes[CharacterCodes["x"] = 120] = "x";
+        CharacterCodes[CharacterCodes["y"] = 121] = "y";
+        CharacterCodes[CharacterCodes["z"] = 122] = "z";
+
+        CharacterCodes[CharacterCodes["A"] = 65] = "A";
+        CharacterCodes[CharacterCodes["E"] = 69] = "E";
+        CharacterCodes[CharacterCodes["F"] = 70] = "F";
+        CharacterCodes[CharacterCodes["X"] = 88] = "X";
+        CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
+
+        CharacterCodes[CharacterCodes["ampersand"] = 38] = "ampersand";
+        CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
+        CharacterCodes[CharacterCodes["at"] = 64] = "at";
+        CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
+        CharacterCodes[CharacterCodes["bar"] = 124] = "bar";
+        CharacterCodes[CharacterCodes["caret"] = 94] = "caret";
+        CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
+        CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
+        CharacterCodes[CharacterCodes["closeParen"] = 41] = "closeParen";
+        CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
+        CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
+        CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
+        CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
+        CharacterCodes[CharacterCodes["equals"] = 61] = "equals";
+        CharacterCodes[CharacterCodes["exclamation"] = 33] = "exclamation";
+        CharacterCodes[CharacterCodes["greaterThan"] = 62] = "greaterThan";
+        CharacterCodes[CharacterCodes["lessThan"] = 60] = "lessThan";
+        CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
+        CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
+        CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
+        CharacterCodes[CharacterCodes["openParen"] = 40] = "openParen";
+        CharacterCodes[CharacterCodes["percent"] = 37] = "percent";
+        CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
+        CharacterCodes[CharacterCodes["question"] = 63] = "question";
+        CharacterCodes[CharacterCodes["semicolon"] = 59] = "semicolon";
+        CharacterCodes[CharacterCodes["singleQuote"] = 39] = "singleQuote";
+        CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
+        CharacterCodes[CharacterCodes["tilde"] = 126] = "tilde";
+
+        CharacterCodes[CharacterCodes["backspace"] = 8] = "backspace";
+        CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
+        CharacterCodes[CharacterCodes["byteOrderMark"] = 0xFEFF] = "byteOrderMark";
+        CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
+        CharacterCodes[CharacterCodes["verticalTab"] = 11] = "verticalTab";
+    })(TypeScript.CharacterCodes || (TypeScript.CharacterCodes = {}));
+    var CharacterCodes = TypeScript.CharacterCodes;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    
+
+    (function (ScriptSnapshot) {
+        var StringScriptSnapshot = (function () {
+            function StringScriptSnapshot(text) {
+                this.text = text;
+                this._lineStartPositions = null;
+            }
+            StringScriptSnapshot.prototype.getText = function (start, end) {
+                return this.text.substring(start, end);
+            };
+
+            StringScriptSnapshot.prototype.getLength = function () {
+                return this.text.length;
+            };
+
+            StringScriptSnapshot.prototype.getLineStartPositions = function () {
+                if (!this._lineStartPositions) {
+                    this._lineStartPositions = TypeScript.TextUtilities.parseLineStarts(this.text);
+                }
+
+                return this._lineStartPositions;
+            };
+
+            StringScriptSnapshot.prototype.getTextChangeRangeSinceVersion = function (scriptVersion) {
+                throw TypeScript.Errors.notYetImplemented();
+            };
+            return StringScriptSnapshot;
+        })();
+
+        function fromString(text) {
+            return new StringScriptSnapshot(text);
+        }
+        ScriptSnapshot.fromString = fromString;
+    })(TypeScript.ScriptSnapshot || (TypeScript.ScriptSnapshot = {}));
+    var ScriptSnapshot = TypeScript.ScriptSnapshot;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (LineMap1) {
+        function fromSimpleText(text) {
+            return new TypeScript.LineMap(function () {
+                return TypeScript.TextUtilities.parseLineStarts({ charCodeAt: function (index) {
+                        return text.charCodeAt(index);
+                    }, length: text.length() });
+            }, text.length());
+        }
+        LineMap1.fromSimpleText = fromSimpleText;
+
+        function fromScriptSnapshot(scriptSnapshot) {
+            return new TypeScript.LineMap(function () {
+                return scriptSnapshot.getLineStartPositions();
+            }, scriptSnapshot.getLength());
+        }
+        LineMap1.fromScriptSnapshot = fromScriptSnapshot;
+
+        function fromString(text) {
+            return new TypeScript.LineMap(function () {
+                return TypeScript.TextUtilities.parseLineStarts(text);
+            }, text.length);
+        }
+        LineMap1.fromString = fromString;
+    })(TypeScript.LineMap1 || (TypeScript.LineMap1 = {}));
+    var LineMap1 = TypeScript.LineMap1;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (TextFactory) {
+        function getStartAndLengthOfLineBreakEndingAt(text, index, info) {
+            var c = text.charCodeAt(index);
+            if (c === 10 /* lineFeed */) {
+                if (index > 0 && text.charCodeAt(index - 1) === 13 /* carriageReturn */) {
+                    info.startPosition = index - 1;
+                    info.length = 2;
+                } else {
+                    info.startPosition = index;
+                    info.length = 1;
+                }
+            } else if (TypeScript.TextUtilities.isAnyLineBreakCharacter(c)) {
+                info.startPosition = index;
+                info.length = 1;
+            } else {
+                info.startPosition = index + 1;
+                info.length = 0;
+            }
+        }
+
+        var LinebreakInfo = (function () {
+            function LinebreakInfo(startPosition, length) {
+                this.startPosition = startPosition;
+                this.length = length;
+            }
+            return LinebreakInfo;
+        })();
+
+        var TextLine = (function () {
+            function TextLine(text, body, lineBreakLength, lineNumber) {
+                this._text = null;
+                this._textSpan = null;
+                if (text === null) {
+                    throw TypeScript.Errors.argumentNull('text');
+                }
+                TypeScript.Debug.assert(lineBreakLength >= 0);
+                TypeScript.Debug.assert(lineNumber >= 0);
+                this._text = text;
+                this._textSpan = body;
+                this._lineBreakLength = lineBreakLength;
+                this._lineNumber = lineNumber;
+            }
+            TextLine.prototype.start = function () {
+                return this._textSpan.start();
+            };
+
+            TextLine.prototype.end = function () {
+                return this._textSpan.end();
+            };
+
+            TextLine.prototype.endIncludingLineBreak = function () {
+                return this.end() + this._lineBreakLength;
+            };
+
+            TextLine.prototype.extent = function () {
+                return this._textSpan;
+            };
+
+            TextLine.prototype.extentIncludingLineBreak = function () {
+                return TypeScript.TextSpan.fromBounds(this.start(), this.endIncludingLineBreak());
+            };
+
+            TextLine.prototype.toString = function () {
+                return this._text.toString(this._textSpan);
+            };
+
+            TextLine.prototype.lineNumber = function () {
+                return this._lineNumber;
+            };
+            return TextLine;
+        })();
+
+        var TextBase = (function () {
+            function TextBase() {
+                this.linebreakInfo = new LinebreakInfo(0, 0);
+                this.lastLineFoundForPosition = null;
+            }
+            TextBase.prototype.length = function () {
+                throw TypeScript.Errors.abstract();
+            };
+
+            TextBase.prototype.charCodeAt = function (position) {
+                throw TypeScript.Errors.abstract();
+            };
+
+            TextBase.prototype.checkSubSpan = function (span) {
+                if (span.start() < 0 || span.start() > this.length() || span.end() > this.length()) {
+                    throw TypeScript.Errors.argumentOutOfRange("span");
+                }
+            };
+
+            TextBase.prototype.toString = function (span) {
+                if (typeof span === "undefined") { span = null; }
+                throw TypeScript.Errors.abstract();
+            };
+
+            TextBase.prototype.subText = function (span) {
+                this.checkSubSpan(span);
+
+                return new SubText(this, span);
+            };
+
+            TextBase.prototype.substr = function (start, length, intern) {
+                throw TypeScript.Errors.abstract();
+            };
+
+            TextBase.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) {
+                throw TypeScript.Errors.abstract();
+            };
+
+            TextBase.prototype.lineCount = function () {
+                return this._lineStarts().length;
+            };
+
+            TextBase.prototype.lines = function () {
+                var lines = [];
+
+                var length = this.lineCount();
+                for (var i = 0; i < length; ++i) {
+                    lines[i] = this.getLineFromLineNumber(i);
+                }
+
+                return lines;
+            };
+
+            TextBase.prototype.lineMap = function () {
+                var _this = this;
+                return new TypeScript.LineMap(function () {
+                    return _this._lineStarts();
+                }, this.length());
+            };
+
+            TextBase.prototype._lineStarts = function () {
+                throw TypeScript.Errors.abstract();
+            };
+
+            TextBase.prototype.getLineFromLineNumber = function (lineNumber) {
+                var lineStarts = this._lineStarts();
+
+                if (lineNumber < 0 || lineNumber >= lineStarts.length) {
+                    throw TypeScript.Errors.argumentOutOfRange("lineNumber");
+                }
+
+                var first = lineStarts[lineNumber];
+                if (lineNumber === lineStarts.length - 1) {
+                    return new TextLine(this, new TypeScript.TextSpan(first, this.length() - first), 0, lineNumber);
+                } else {
+                    getStartAndLengthOfLineBreakEndingAt(this, lineStarts[lineNumber + 1] - 1, this.linebreakInfo);
+                    return new TextLine(this, new TypeScript.TextSpan(first, this.linebreakInfo.startPosition - first), this.linebreakInfo.length, lineNumber);
+                }
+            };
+
+            TextBase.prototype.getLineFromPosition = function (position) {
+                var lastFound = this.lastLineFoundForPosition;
+                if (lastFound !== null && lastFound.start() <= position && lastFound.endIncludingLineBreak() > position) {
+                    return lastFound;
+                }
+
+                var lineNumber = this.getLineNumberFromPosition(position);
+
+                var result = this.getLineFromLineNumber(lineNumber);
+                this.lastLineFoundForPosition = result;
+                return result;
+            };
+
+            TextBase.prototype.getLineNumberFromPosition = function (position) {
+                if (position < 0 || position > this.length()) {
+                    throw TypeScript.Errors.argumentOutOfRange("position");
+                }
+
+                if (position === this.length()) {
+                    return this.lineCount() - 1;
+                }
+
+                var lineNumber = TypeScript.ArrayUtilities.binarySearch(this._lineStarts(), position);
+                if (lineNumber < 0) {
+                    lineNumber = (~lineNumber) - 1;
+                }
+
+                return lineNumber;
+            };
+
+            TextBase.prototype.getLinePosition = function (position) {
+                if (position < 0 || position > this.length()) {
+                    throw TypeScript.Errors.argumentOutOfRange("position");
+                }
+
+                var lineNumber = this.getLineNumberFromPosition(position);
+
+                return new TypeScript.LineAndCharacter(lineNumber, position - this._lineStarts()[lineNumber]);
+            };
+            return TextBase;
+        })();
+
+        var SubText = (function (_super) {
+            __extends(SubText, _super);
+            function SubText(text, span) {
+                _super.call(this);
+                this._lazyLineStarts = null;
+
+                if (text === null) {
+                    throw TypeScript.Errors.argumentNull("text");
+                }
+
+                if (span.start() < 0 || span.start() >= text.length() || span.end() < 0 || span.end() > text.length()) {
+                    throw TypeScript.Errors.argument("span");
+                }
+
+                this.text = text;
+                this.span = span;
+            }
+            SubText.prototype.length = function () {
+                return this.span.length();
+            };
+
+            SubText.prototype.charCodeAt = function (position) {
+                if (position < 0 || position > this.length()) {
+                    throw TypeScript.Errors.argumentOutOfRange("position");
+                }
+
+                return this.text.charCodeAt(this.span.start() + position);
+            };
+
+            SubText.prototype.subText = function (span) {
+                this.checkSubSpan(span);
+
+                return new SubText(this.text, this.getCompositeSpan(span.start(), span.length()));
+            };
+
+            SubText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) {
+                var span = this.getCompositeSpan(sourceIndex, count);
+                this.text.copyTo(span.start(), destination, destinationIndex, span.length());
+            };
+
+            SubText.prototype.substr = function (start, length, intern) {
+                var startInOriginalText = this.span.start() + start;
+                return this.text.substr(startInOriginalText, length, intern);
+            };
+
+            SubText.prototype.getCompositeSpan = function (start, length) {
+                var compositeStart = TypeScript.MathPrototype.min(this.text.length(), this.span.start() + start);
+                var compositeEnd = TypeScript.MathPrototype.min(this.text.length(), compositeStart + length);
+                return new TypeScript.TextSpan(compositeStart, compositeEnd - compositeStart);
+            };
+
+            SubText.prototype._lineStarts = function () {
+                var _this = this;
+                if (!this._lazyLineStarts) {
+                    this._lazyLineStarts = TypeScript.TextUtilities.parseLineStarts({ charCodeAt: function (index) {
+                            return _this.charCodeAt(index);
+                        }, length: this.length() });
+                }
+
+                return this._lazyLineStarts;
+            };
+            return SubText;
+        })(TextBase);
+
+        var StringText = (function (_super) {
+            __extends(StringText, _super);
+            function StringText(data) {
+                _super.call(this);
+                this.source = null;
+                this._lazyLineStarts = null;
+
+                if (data === null) {
+                    throw TypeScript.Errors.argumentNull("data");
+                }
+
+                this.source = data;
+            }
+            StringText.prototype.length = function () {
+                return this.source.length;
+            };
+
+            StringText.prototype.charCodeAt = function (position) {
+                if (position < 0 || position >= this.source.length) {
+                    throw TypeScript.Errors.argumentOutOfRange("position");
+                }
+
+                return this.source.charCodeAt(position);
+            };
+
+            StringText.prototype.substr = function (start, length, intern) {
+                return this.source.substr(start, length);
+            };
+
+            StringText.prototype.toString = function (span) {
+                if (typeof span === "undefined") { span = null; }
+                if (span === null) {
+                    span = new TypeScript.TextSpan(0, this.length());
+                }
+
+                this.checkSubSpan(span);
+
+                if (span.start() === 0 && span.length() === this.length()) {
+                    return this.source;
+                }
+
+                return this.source.substr(span.start(), span.length());
+            };
+
+            StringText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) {
+                TypeScript.StringUtilities.copyTo(this.source, sourceIndex, destination, destinationIndex, count);
+            };
+
+            StringText.prototype._lineStarts = function () {
+                if (this._lazyLineStarts === null) {
+                    this._lazyLineStarts = TypeScript.TextUtilities.parseLineStarts(this.source);
+                }
+
+                return this._lazyLineStarts;
+            };
+            return StringText;
+        })(TextBase);
+
+        function createText(value) {
+            return new StringText(value);
+        }
+        TextFactory.createText = createText;
+    })(TypeScript.TextFactory || (TypeScript.TextFactory = {}));
+    var TextFactory = TypeScript.TextFactory;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    (function (SimpleText) {
+        var SimpleSubText = (function () {
+            function SimpleSubText(text, span) {
+                this.text = null;
+                this.span = null;
+                if (text === null) {
+                    throw TypeScript.Errors.argumentNull("text");
+                }
+
+                if (span.start() < 0 || span.start() >= text.length() || span.end() < 0 || span.end() > text.length()) {
+                    throw TypeScript.Errors.argument("span");
+                }
+
+                this.text = text;
+                this.span = span;
+            }
+            SimpleSubText.prototype.checkSubSpan = function (span) {
+                if (span.start() < 0 || span.start() > this.length() || span.end() > this.length()) {
+                    throw TypeScript.Errors.argumentOutOfRange("span");
+                }
+            };
+
+            SimpleSubText.prototype.checkSubPosition = function (position) {
+                if (position < 0 || position >= this.length()) {
+                    throw TypeScript.Errors.argumentOutOfRange("position");
+                }
+            };
+
+            SimpleSubText.prototype.length = function () {
+                return this.span.length();
+            };
+
+            SimpleSubText.prototype.subText = function (span) {
+                this.checkSubSpan(span);
+
+                return new SimpleSubText(this.text, this.getCompositeSpan(span.start(), span.length()));
+            };
+
+            SimpleSubText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) {
+                var span = this.getCompositeSpan(sourceIndex, count);
+                this.text.copyTo(span.start(), destination, destinationIndex, span.length());
+            };
+
+            SimpleSubText.prototype.substr = function (start, length, intern) {
+                var span = this.getCompositeSpan(start, length);
+                return this.text.substr(span.start(), span.length(), intern);
+            };
+
+            SimpleSubText.prototype.getCompositeSpan = function (start, length) {
+                var compositeStart = TypeScript.MathPrototype.min(this.text.length(), this.span.start() + start);
+                var compositeEnd = TypeScript.MathPrototype.min(this.text.length(), compositeStart + length);
+                return new TypeScript.TextSpan(compositeStart, compositeEnd - compositeStart);
+            };
+
+            SimpleSubText.prototype.charCodeAt = function (index) {
+                this.checkSubPosition(index);
+                return this.text.charCodeAt(this.span.start() + index);
+            };
+
+            SimpleSubText.prototype.lineMap = function () {
+                return TypeScript.LineMap1.fromSimpleText(this);
+            };
+            return SimpleSubText;
+        })();
+
+        var SimpleStringText = (function () {
+            function SimpleStringText(value) {
+                this.value = value;
+                this._lineMap = null;
+            }
+            SimpleStringText.prototype.length = function () {
+                return this.value.length;
+            };
+
+            SimpleStringText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) {
+                TypeScript.StringUtilities.copyTo(this.value, sourceIndex, destination, destinationIndex, count);
+            };
+
+            SimpleStringText.prototype.substr = function (start, length, intern) {
+                if (intern) {
+                    var array = length <= SimpleStringText.charArray.length ? SimpleStringText.charArray : TypeScript.ArrayUtilities.createArray(length, 0);
+                    this.copyTo(start, array, 0, length);
+                    return TypeScript.Collections.DefaultStringTable.addCharArray(array, 0, length);
+                }
+
+                return this.value.substr(start, length);
+            };
+
+            SimpleStringText.prototype.subText = function (span) {
+                return new SimpleSubText(this, span);
+            };
+
+            SimpleStringText.prototype.charCodeAt = function (index) {
+                return this.value.charCodeAt(index);
+            };
+
+            SimpleStringText.prototype.lineMap = function () {
+                if (!this._lineMap) {
+                    this._lineMap = TypeScript.LineMap1.fromString(this.value);
+                }
+
+                return this._lineMap;
+            };
+            SimpleStringText.charArray = TypeScript.ArrayUtilities.createArray(1024, 0);
+            return SimpleStringText;
+        })();
+
+        var SimpleScriptSnapshotText = (function () {
+            function SimpleScriptSnapshotText(scriptSnapshot) {
+                this.scriptSnapshot = scriptSnapshot;
+            }
+            SimpleScriptSnapshotText.prototype.charCodeAt = function (index) {
+                return this.scriptSnapshot.getText(index, index + 1).charCodeAt(0);
+            };
+
+            SimpleScriptSnapshotText.prototype.length = function () {
+                return this.scriptSnapshot.getLength();
+            };
+
+            SimpleScriptSnapshotText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) {
+                var text = this.scriptSnapshot.getText(sourceIndex, sourceIndex + count);
+                TypeScript.StringUtilities.copyTo(text, 0, destination, destinationIndex, count);
+            };
+
+            SimpleScriptSnapshotText.prototype.substr = function (start, length, intern) {
+                return this.scriptSnapshot.getText(start, start + length);
+            };
+
+            SimpleScriptSnapshotText.prototype.subText = function (span) {
+                return new SimpleSubText(this, span);
+            };
+
+            SimpleScriptSnapshotText.prototype.lineMap = function () {
+                var _this = this;
+                return new TypeScript.LineMap(function () {
+                    return _this.scriptSnapshot.getLineStartPositions();
+                }, this.length());
+            };
+            return SimpleScriptSnapshotText;
+        })();
+
+        function fromString(value) {
+            return new SimpleStringText(value);
+        }
+        SimpleText.fromString = fromString;
+
+        function fromScriptSnapshot(scriptSnapshot) {
+            return new SimpleScriptSnapshotText(scriptSnapshot);
+        }
+        SimpleText.fromScriptSnapshot = fromScriptSnapshot;
+    })(TypeScript.SimpleText || (TypeScript.SimpleText = {}));
+    var SimpleText = TypeScript.SimpleText;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (TextUtilities) {
+        function parseLineStarts(text) {
+            var length = text.length;
+
+            if (0 === length) {
+                var result = new Array();
+                result.push(0);
+                return result;
+            }
+
+            var position = 0;
+            var index = 0;
+            var arrayBuilder = new Array();
+            var lineNumber = 0;
+
+            while (index < length) {
+                var c = text.charCodeAt(index);
+                var lineBreakLength;
+
+                if (c > 13 /* carriageReturn */ && c <= 127) {
+                    index++;
+                    continue;
+                } else if (c === 13 /* carriageReturn */ && index + 1 < length && text.charCodeAt(index + 1) === 10 /* lineFeed */) {
+                    lineBreakLength = 2;
+                } else if (c === 10 /* lineFeed */) {
+                    lineBreakLength = 1;
+                } else {
+                    lineBreakLength = TextUtilities.getLengthOfLineBreak(text, index);
+                }
+
+                if (0 === lineBreakLength) {
+                    index++;
+                } else {
+                    arrayBuilder.push(position);
+                    index += lineBreakLength;
+                    position = index;
+                    lineNumber++;
+                }
+            }
+
+            arrayBuilder.push(position);
+
+            return arrayBuilder;
+        }
+        TextUtilities.parseLineStarts = parseLineStarts;
+
+        function getLengthOfLineBreakSlow(text, index, c) {
+            if (c === 13 /* carriageReturn */) {
+                var next = index + 1;
+                return (next < text.length) && 10 /* lineFeed */ === text.charCodeAt(next) ? 2 : 1;
+            } else if (isAnyLineBreakCharacter(c)) {
+                return 1;
+            } else {
+                return 0;
+            }
+        }
+        TextUtilities.getLengthOfLineBreakSlow = getLengthOfLineBreakSlow;
+
+        function getLengthOfLineBreak(text, index) {
+            var c = text.charCodeAt(index);
+
+            if (c > 13 /* carriageReturn */ && c <= 127) {
+                return 0;
+            }
+
+            return getLengthOfLineBreakSlow(text, index, c);
+        }
+        TextUtilities.getLengthOfLineBreak = getLengthOfLineBreak;
+
+        function isAnyLineBreakCharacter(c) {
+            return c === 10 /* lineFeed */ || c === 13 /* carriageReturn */ || c === 133 /* nextLine */ || c === 8232 /* lineSeparator */ || c === 8233 /* paragraphSeparator */;
+        }
+        TextUtilities.isAnyLineBreakCharacter = isAnyLineBreakCharacter;
+    })(TypeScript.TextUtilities || (TypeScript.TextUtilities = {}));
+    var TextUtilities = TypeScript.TextUtilities;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var TextSpan = (function () {
+        function TextSpan(start, length) {
+            if (start < 0) {
+                TypeScript.Errors.argument("start");
+            }
+
+            if (length < 0) {
+                TypeScript.Errors.argument("length");
+            }
+
+            this._start = start;
+            this._length = length;
+        }
+        TextSpan.prototype.start = function () {
+            return this._start;
+        };
+
+        TextSpan.prototype.length = function () {
+            return this._length;
+        };
+
+        TextSpan.prototype.end = function () {
+            return this._start + this._length;
+        };
+
+        TextSpan.prototype.isEmpty = function () {
+            return this._length === 0;
+        };
+
+        TextSpan.prototype.containsPosition = function (position) {
+            return position >= this._start && position < this.end();
+        };
+
+        TextSpan.prototype.containsTextSpan = function (span) {
+            return span._start >= this._start && span.end() <= this.end();
+        };
+
+        TextSpan.prototype.overlapsWith = function (span) {
+            var overlapStart = TypeScript.MathPrototype.max(this._start, span._start);
+            var overlapEnd = TypeScript.MathPrototype.min(this.end(), span.end());
+
+            return overlapStart < overlapEnd;
+        };
+
+        TextSpan.prototype.overlap = function (span) {
+            var overlapStart = TypeScript.MathPrototype.max(this._start, span._start);
+            var overlapEnd = TypeScript.MathPrototype.min(this.end(), span.end());
+
+            if (overlapStart < overlapEnd) {
+                return TextSpan.fromBounds(overlapStart, overlapEnd);
+            }
+
+            return null;
+        };
+
+        TextSpan.prototype.intersectsWithTextSpan = function (span) {
+            return span._start <= this.end() && span.end() >= this._start;
+        };
+
+        TextSpan.prototype.intersectsWith = function (start, length) {
+            var end = start + length;
+            return start <= this.end() && end >= this._start;
+        };
+
+        TextSpan.prototype.intersectsWithPosition = function (position) {
+            return position <= this.end() && position >= this._start;
+        };
+
+        TextSpan.prototype.intersection = function (span) {
+            var intersectStart = TypeScript.MathPrototype.max(this._start, span._start);
+            var intersectEnd = TypeScript.MathPrototype.min(this.end(), span.end());
+
+            if (intersectStart <= intersectEnd) {
+                return TextSpan.fromBounds(intersectStart, intersectEnd);
+            }
+
+            return null;
+        };
+
+        TextSpan.fromBounds = function (start, end) {
+            TypeScript.Debug.assert(start >= 0);
+            TypeScript.Debug.assert(end - start >= 0);
+            return new TextSpan(start, end - start);
+        };
+        return TextSpan;
+    })();
+    TypeScript.TextSpan = TextSpan;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var TextChangeRange = (function () {
+        function TextChangeRange(span, newLength) {
+            if (newLength < 0) {
+                throw TypeScript.Errors.argumentOutOfRange("newLength");
+            }
+
+            this._span = span;
+            this._newLength = newLength;
+        }
+        TextChangeRange.prototype.span = function () {
+            return this._span;
+        };
+
+        TextChangeRange.prototype.newLength = function () {
+            return this._newLength;
+        };
+
+        TextChangeRange.prototype.newSpan = function () {
+            return new TypeScript.TextSpan(this.span().start(), this.newLength());
+        };
+
+        TextChangeRange.prototype.isUnchanged = function () {
+            return this.span().isEmpty() && this.newLength() === 0;
+        };
+
+        TextChangeRange.collapseChangesFromSingleVersion = function (changes) {
+            var diff = 0;
+            var start = 1073741823 /* Max31BitInteger */;
+            var end = 0;
+
+            for (var i = 0; i < changes.length; i++) {
+                var change = changes[i];
+                diff += change.newLength() - change.span().length();
+
+                if (change.span().start() < start) {
+                    start = change.span().start();
+                }
+
+                if (change.span().end() > end) {
+                    end = change.span().end();
+                }
+            }
+
+            if (start > end) {
+                return null;
+            }
+
+            var combined = TypeScript.TextSpan.fromBounds(start, end);
+            var newLen = combined.length() + diff;
+
+            return new TextChangeRange(combined, newLen);
+        };
+
+        TextChangeRange.collapseChangesAcrossMultipleVersions = function (changes) {
+            if (changes.length === 0) {
+                return TextChangeRange.unchanged;
+            }
+
+            if (changes.length === 1) {
+                return changes[0];
+            }
+
+            var change0 = changes[0];
+
+            var oldStartN = change0.span().start();
+            var oldEndN = change0.span().end();
+            var newEndN = oldStartN + change0.newLength();
+
+            for (var i = 1; i < changes.length; i++) {
+                var nextChange = changes[i];
+
+                var oldStart1 = oldStartN;
+                var oldEnd1 = oldEndN;
+                var newEnd1 = newEndN;
+
+                var oldStart2 = nextChange.span().start();
+                var oldEnd2 = nextChange.span().end();
+                var newEnd2 = oldStart2 + nextChange.newLength();
+
+                oldStartN = TypeScript.MathPrototype.min(oldStart1, oldStart2);
+                oldEndN = TypeScript.MathPrototype.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1));
+                newEndN = TypeScript.MathPrototype.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2));
+            }
+
+            return new TextChangeRange(TypeScript.TextSpan.fromBounds(oldStartN, oldEndN), newEndN - oldStartN);
+        };
+        TextChangeRange.unchanged = new TextChangeRange(new TypeScript.TextSpan(0, 0), 0);
+        return TextChangeRange;
+    })();
+    TypeScript.TextChangeRange = TextChangeRange;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var CharacterInfo = (function () {
+        function CharacterInfo() {
+        }
+        CharacterInfo.isDecimalDigit = function (c) {
+            return c >= 48 /* _0 */ && c <= 57 /* _9 */;
+        };
+        CharacterInfo.isOctalDigit = function (c) {
+            return c >= 48 /* _0 */ && c <= 55 /* _7 */;
+        };
+
+        CharacterInfo.isHexDigit = function (c) {
+            return CharacterInfo.isDecimalDigit(c) || (c >= 65 /* A */ && c <= 70 /* F */) || (c >= 97 /* a */ && c <= 102 /* f */);
+        };
+
+        CharacterInfo.hexValue = function (c) {
+            return CharacterInfo.isDecimalDigit(c) ? (c - 48 /* _0 */) : (c >= 65 /* A */ && c <= 70 /* F */) ? c - 65 /* A */ + 10 : c - 97 /* a */ + 10;
+        };
+
+        CharacterInfo.isWhitespace = function (ch) {
+            switch (ch) {
+                case 32 /* space */:
+                case 160 /* nonBreakingSpace */:
+                case 8192 /* enQuad */:
+                case 8193 /* emQuad */:
+                case 8194 /* enSpace */:
+                case 8195 /* emSpace */:
+                case 8196 /* threePerEmSpace */:
+                case 8197 /* fourPerEmSpace */:
+                case 8198 /* sixPerEmSpace */:
+                case 8199 /* figureSpace */:
+                case 8200 /* punctuationSpace */:
+                case 8201 /* thinSpace */:
+                case 8202 /* hairSpace */:
+                case 8203 /* zeroWidthSpace */:
+                case 8239 /* narrowNoBreakSpace */:
+                case 12288 /* ideographicSpace */:
+
+                case 9 /* tab */:
+                case 11 /* verticalTab */:
+                case 12 /* formFeed */:
+                case 65279 /* byteOrderMark */:
+                    return true;
+            }
+
+            return false;
+        };
+
+        CharacterInfo.isLineTerminator = function (ch) {
+            switch (ch) {
+                case 13 /* carriageReturn */:
+                case 10 /* lineFeed */:
+                case 8233 /* paragraphSeparator */:
+                case 8232 /* lineSeparator */:
+                    return true;
+            }
+
+            return false;
+        };
+        return CharacterInfo;
+    })();
+    TypeScript.CharacterInfo = CharacterInfo;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (SyntaxConstants) {
+        SyntaxConstants[SyntaxConstants["TriviaNewLineMask"] = 0x00000001] = "TriviaNewLineMask";
+        SyntaxConstants[SyntaxConstants["TriviaCommentMask"] = 0x00000002] = "TriviaCommentMask";
+        SyntaxConstants[SyntaxConstants["TriviaFullWidthShift"] = 2] = "TriviaFullWidthShift";
+
+        SyntaxConstants[SyntaxConstants["NodeDataComputed"] = 0x00000001] = "NodeDataComputed";
+        SyntaxConstants[SyntaxConstants["NodeIncrementallyUnusableMask"] = 0x00000002] = "NodeIncrementallyUnusableMask";
+        SyntaxConstants[SyntaxConstants["NodeParsedInStrictModeMask"] = 0x00000004] = "NodeParsedInStrictModeMask";
+        SyntaxConstants[SyntaxConstants["NodeFullWidthShift"] = 3] = "NodeFullWidthShift";
+
+        SyntaxConstants[SyntaxConstants["IsVariableWidthKeyword"] = 1 << 31] = "IsVariableWidthKeyword";
+    })(TypeScript.SyntaxConstants || (TypeScript.SyntaxConstants = {}));
+    var SyntaxConstants = TypeScript.SyntaxConstants;
+})(TypeScript || (TypeScript = {}));
+var FormattingOptions = (function () {
+    function FormattingOptions(useTabs, spacesPerTab, indentSpaces, newLineCharacter) {
+        this.useTabs = useTabs;
+        this.spacesPerTab = spacesPerTab;
+        this.indentSpaces = indentSpaces;
+        this.newLineCharacter = newLineCharacter;
+    }
+    FormattingOptions.defaultOptions = new FormattingOptions(false, 4, 4, "\r\n");
+    return FormattingOptions;
+})();
+var TypeScript;
+(function (TypeScript) {
+    (function (Indentation) {
+        function columnForEndOfToken(token, syntaxInformationMap, options) {
+            return columnForStartOfToken(token, syntaxInformationMap, options) + token.width();
+        }
+        Indentation.columnForEndOfToken = columnForEndOfToken;
+
+        function columnForStartOfToken(token, syntaxInformationMap, options) {
+            var firstTokenInLine = syntaxInformationMap.firstTokenInLineContainingToken(token);
+            var leadingTextInReverse = [];
+
+            var current = token;
+            while (current !== firstTokenInLine) {
+                current = syntaxInformationMap.previousToken(current);
+
+                if (current === firstTokenInLine) {
+                    leadingTextInReverse.push(current.trailingTrivia().fullText());
+                    leadingTextInReverse.push(current.text());
+                } else {
+                    leadingTextInReverse.push(current.fullText());
+                }
+            }
+
+            collectLeadingTriviaTextToStartOfLine(firstTokenInLine, leadingTextInReverse);
+
+            return columnForLeadingTextInReverse(leadingTextInReverse, options);
+        }
+        Indentation.columnForStartOfToken = columnForStartOfToken;
+
+        function columnForStartOfFirstTokenInLineContainingToken(token, syntaxInformationMap, options) {
+            var firstTokenInLine = syntaxInformationMap.firstTokenInLineContainingToken(token);
+            var leadingTextInReverse = [];
+
+            collectLeadingTriviaTextToStartOfLine(firstTokenInLine, leadingTextInReverse);
+
+            return columnForLeadingTextInReverse(leadingTextInReverse, options);
+        }
+        Indentation.columnForStartOfFirstTokenInLineContainingToken = columnForStartOfFirstTokenInLineContainingToken;
+
+        function collectLeadingTriviaTextToStartOfLine(firstTokenInLine, leadingTextInReverse) {
+            var leadingTrivia = firstTokenInLine.leadingTrivia();
+
+            for (var i = leadingTrivia.count() - 1; i >= 0; i--) {
+                var trivia = leadingTrivia.syntaxTriviaAt(i);
+                if (trivia.kind() === 5 /* NewLineTrivia */) {
+                    break;
+                }
+
+                if (trivia.kind() === 6 /* MultiLineCommentTrivia */) {
+                    var lineSegments = TypeScript.Syntax.splitMultiLineCommentTriviaIntoMultipleLines(trivia);
+                    leadingTextInReverse.push(TypeScript.ArrayUtilities.last(lineSegments));
+
+                    if (lineSegments.length > 0) {
+                        break;
+                    }
+                }
+
+                leadingTextInReverse.push(trivia.fullText());
+            }
+        }
+
+        function columnForLeadingTextInReverse(leadingTextInReverse, options) {
+            var column = 0;
+
+            for (var i = leadingTextInReverse.length - 1; i >= 0; i--) {
+                var text = leadingTextInReverse[i];
+                column = columnForPositionInStringWorker(text, text.length, column, options);
+            }
+
+            return column;
+        }
+
+        function columnForPositionInString(input, position, options) {
+            return columnForPositionInStringWorker(input, position, 0, options);
+        }
+        Indentation.columnForPositionInString = columnForPositionInString;
+
+        function columnForPositionInStringWorker(input, position, startColumn, options) {
+            var column = startColumn;
+            var spacesPerTab = options.spacesPerTab;
+
+            for (var j = 0; j < position; j++) {
+                var ch = input.charCodeAt(j);
+
+                if (ch === 9 /* tab */) {
+                    column += spacesPerTab - column % spacesPerTab;
+                } else {
+                    column++;
+                }
+            }
+
+            return column;
+        }
+
+        function indentationString(column, options) {
+            var numberOfTabs = 0;
+            var numberOfSpaces = TypeScript.MathPrototype.max(0, column);
+
+            if (options.useTabs) {
+                numberOfTabs = Math.floor(column / options.spacesPerTab);
+                numberOfSpaces -= numberOfTabs * options.spacesPerTab;
+            }
+
+            return TypeScript.StringUtilities.repeat('\t', numberOfTabs) + TypeScript.StringUtilities.repeat(' ', numberOfSpaces);
+        }
+        Indentation.indentationString = indentationString;
+
+        function indentationTrivia(column, options) {
+            return TypeScript.Syntax.whitespace(this.indentationString(column, options));
+        }
+        Indentation.indentationTrivia = indentationTrivia;
+
+        function firstNonWhitespacePosition(value) {
+            for (var i = 0; i < value.length; i++) {
+                var ch = value.charCodeAt(i);
+                if (!TypeScript.CharacterInfo.isWhitespace(ch)) {
+                    return i;
+                }
+            }
+
+            return value.length;
+        }
+        Indentation.firstNonWhitespacePosition = firstNonWhitespacePosition;
+    })(TypeScript.Indentation || (TypeScript.Indentation = {}));
+    var Indentation = TypeScript.Indentation;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (LanguageVersion) {
+        LanguageVersion[LanguageVersion["EcmaScript3"] = 0] = "EcmaScript3";
+        LanguageVersion[LanguageVersion["EcmaScript5"] = 1] = "EcmaScript5";
+    })(TypeScript.LanguageVersion || (TypeScript.LanguageVersion = {}));
+    var LanguageVersion = TypeScript.LanguageVersion;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var ParseOptions = (function () {
+        function ParseOptions(languageVersion, allowAutomaticSemicolonInsertion) {
+            this._languageVersion = languageVersion;
+            this._allowAutomaticSemicolonInsertion = allowAutomaticSemicolonInsertion;
+        }
+        ParseOptions.prototype.toJSON = function (key) {
+            return { allowAutomaticSemicolonInsertion: this._allowAutomaticSemicolonInsertion };
+        };
+
+        ParseOptions.prototype.languageVersion = function () {
+            return this._languageVersion;
+        };
+
+        ParseOptions.prototype.allowAutomaticSemicolonInsertion = function () {
+            return this._allowAutomaticSemicolonInsertion;
+        };
+        return ParseOptions;
+    })();
+    TypeScript.ParseOptions = ParseOptions;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var PositionedElement = (function () {
+        function PositionedElement(parent, element, fullStart) {
+            this._parent = parent;
+            this._element = element;
+            this._fullStart = fullStart;
+        }
+        PositionedElement.create = function (parent, element, fullStart) {
+            if (element === null) {
+                return null;
+            }
+
+            if (element.isNode()) {
+                return new PositionedNode(parent, element, fullStart);
+            } else if (element.isToken()) {
+                return new PositionedToken(parent, element, fullStart);
+            } else if (element.isList()) {
+                return new PositionedList(parent, element, fullStart);
+            } else if (element.isSeparatedList()) {
+                return new PositionedSeparatedList(parent, element, fullStart);
+            } else {
+                throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        PositionedElement.prototype.parent = function () {
+            return this._parent;
+        };
+
+        PositionedElement.prototype.parentElement = function () {
+            return this._parent && this._parent._element;
+        };
+
+        PositionedElement.prototype.element = function () {
+            return this._element;
+        };
+
+        PositionedElement.prototype.kind = function () {
+            return this.element().kind();
+        };
+
+        PositionedElement.prototype.childIndex = function (child) {
+            return TypeScript.Syntax.childIndex(this.element(), child);
+        };
+
+        PositionedElement.prototype.childCount = function () {
+            return this.element().childCount();
+        };
+
+        PositionedElement.prototype.childAt = function (index) {
+            var offset = TypeScript.Syntax.childOffsetAt(this.element(), index);
+            return PositionedElement.create(this, this.element().childAt(index), this.fullStart() + offset);
+        };
+
+        PositionedElement.prototype.childStart = function (child) {
+            var offset = TypeScript.Syntax.childOffset(this.element(), child);
+            return this.fullStart() + offset + child.leadingTriviaWidth();
+        };
+
+        PositionedElement.prototype.childEnd = function (child) {
+            var offset = TypeScript.Syntax.childOffset(this.element(), child);
+            return this.fullStart() + offset + child.leadingTriviaWidth() + child.width();
+        };
+
+        PositionedElement.prototype.childStartAt = function (index) {
+            var offset = TypeScript.Syntax.childOffsetAt(this.element(), index);
+            var child = this.element().childAt(index);
+            return this.fullStart() + offset + child.leadingTriviaWidth();
+        };
+
+        PositionedElement.prototype.childEndAt = function (index) {
+            var offset = TypeScript.Syntax.childOffsetAt(this.element(), index);
+            var child = this.element().childAt(index);
+            return this.fullStart() + offset + child.leadingTriviaWidth() + child.width();
+        };
+
+        PositionedElement.prototype.getPositionedChild = function (child) {
+            var offset = TypeScript.Syntax.childOffset(this.element(), child);
+            return PositionedElement.create(this, child, this.fullStart() + offset);
+        };
+
+        PositionedElement.prototype.fullStart = function () {
+            return this._fullStart;
+        };
+
+        PositionedElement.prototype.fullEnd = function () {
+            return this.fullStart() + this.element().fullWidth();
+        };
+
+        PositionedElement.prototype.fullWidth = function () {
+            return this.element().fullWidth();
+        };
+
+        PositionedElement.prototype.start = function () {
+            return this.fullStart() + this.element().leadingTriviaWidth();
+        };
+
+        PositionedElement.prototype.end = function () {
+            return this.fullStart() + this.element().leadingTriviaWidth() + this.element().width();
+        };
+
+        PositionedElement.prototype.root = function () {
+            var current = this;
+            while (current.parent() !== null) {
+                current = current.parent();
+            }
+
+            return current;
+        };
+
+        PositionedElement.prototype.containingNode = function () {
+            var current = this.parent();
+
+            while (current !== null && !current.element().isNode()) {
+                current = current.parent();
+            }
+
+            return current;
+        };
+        return PositionedElement;
+    })();
+    TypeScript.PositionedElement = PositionedElement;
+
+    var PositionedNodeOrToken = (function (_super) {
+        __extends(PositionedNodeOrToken, _super);
+        function PositionedNodeOrToken(parent, nodeOrToken, fullStart) {
+            _super.call(this, parent, nodeOrToken, fullStart);
+        }
+        PositionedNodeOrToken.prototype.nodeOrToken = function () {
+            return this.element();
+        };
+        return PositionedNodeOrToken;
+    })(PositionedElement);
+    TypeScript.PositionedNodeOrToken = PositionedNodeOrToken;
+
+    var PositionedNode = (function (_super) {
+        __extends(PositionedNode, _super);
+        function PositionedNode(parent, node, fullStart) {
+            _super.call(this, parent, node, fullStart);
+        }
+        PositionedNode.prototype.node = function () {
+            return this.element();
+        };
+        return PositionedNode;
+    })(PositionedNodeOrToken);
+    TypeScript.PositionedNode = PositionedNode;
+
+    var PositionedToken = (function (_super) {
+        __extends(PositionedToken, _super);
+        function PositionedToken(parent, token, fullStart) {
+            _super.call(this, parent, token, fullStart);
+        }
+        PositionedToken.prototype.token = function () {
+            return this.element();
+        };
+
+        PositionedToken.prototype.previousToken = function (includeSkippedTokens) {
+            if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; }
+            var triviaList = this.token().leadingTrivia();
+            if (includeSkippedTokens && triviaList && triviaList.hasSkippedToken()) {
+                var currentTriviaEndPosition = this.start();
+                for (var i = triviaList.count() - 1; i >= 0; i--) {
+                    var trivia = triviaList.syntaxTriviaAt(i);
+                    if (trivia.isSkippedToken()) {
+                        return new PositionedSkippedToken(this, trivia.skippedToken(), currentTriviaEndPosition - trivia.fullWidth());
+                    }
+
+                    currentTriviaEndPosition -= trivia.fullWidth();
+                }
+            }
+
+            var start = this.fullStart();
+            if (start === 0) {
+                return null;
+            }
+
+            return this.root().node().findToken(start - 1, includeSkippedTokens);
+        };
+
+        PositionedToken.prototype.nextToken = function (includeSkippedTokens) {
+            if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; }
+            if (this.token().tokenKind === 10 /* EndOfFileToken */) {
+                return null;
+            }
+
+            var triviaList = this.token().trailingTrivia();
+            if (includeSkippedTokens && triviaList && triviaList.hasSkippedToken()) {
+                var fullStart = this.end();
+                for (var i = 0, n = triviaList.count(); i < n; i++) {
+                    var trivia = triviaList.syntaxTriviaAt(i);
+                    if (trivia.isSkippedToken()) {
+                        return new PositionedSkippedToken(this, trivia.skippedToken(), fullStart);
+                    }
+
+                    fullStart += trivia.fullWidth();
+                }
+            }
+
+            return this.root().node().findToken(this.fullEnd(), includeSkippedTokens);
+        };
+        return PositionedToken;
+    })(PositionedNodeOrToken);
+    TypeScript.PositionedToken = PositionedToken;
+
+    var PositionedList = (function (_super) {
+        __extends(PositionedList, _super);
+        function PositionedList(parent, list, fullStart) {
+            _super.call(this, parent, list, fullStart);
+        }
+        PositionedList.prototype.list = function () {
+            return this.element();
+        };
+        return PositionedList;
+    })(PositionedElement);
+    TypeScript.PositionedList = PositionedList;
+
+    var PositionedSeparatedList = (function (_super) {
+        __extends(PositionedSeparatedList, _super);
+        function PositionedSeparatedList(parent, list, fullStart) {
+            _super.call(this, parent, list, fullStart);
+        }
+        PositionedSeparatedList.prototype.list = function () {
+            return this.element();
+        };
+        return PositionedSeparatedList;
+    })(PositionedElement);
+    TypeScript.PositionedSeparatedList = PositionedSeparatedList;
+
+    var PositionedSkippedToken = (function (_super) {
+        __extends(PositionedSkippedToken, _super);
+        function PositionedSkippedToken(parentToken, token, fullStart) {
+            _super.call(this, parentToken.parent(), token, fullStart);
+            this._parentToken = parentToken;
+        }
+        PositionedSkippedToken.prototype.parentToken = function () {
+            return this._parentToken;
+        };
+
+        PositionedSkippedToken.prototype.previousToken = function (includeSkippedTokens) {
+            if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; }
+            var start = this.fullStart();
+
+            if (includeSkippedTokens) {
+                var previousToken;
+
+                if (start >= this.parentToken().end()) {
+                    previousToken = TypeScript.Syntax.findSkippedTokenInTrailingTriviaList(this.parentToken(), start - 1);
+
+                    if (previousToken) {
+                        return previousToken;
+                    }
+
+                    return this.parentToken();
+                } else {
+                    previousToken = TypeScript.Syntax.findSkippedTokenInLeadingTriviaList(this.parentToken(), start - 1);
+
+                    if (previousToken) {
+                        return previousToken;
+                    }
+                }
+            }
+
+            var start = this.parentToken().fullStart();
+            if (start === 0) {
+                return null;
+            }
+
+            return this.root().node().findToken(start - 1, includeSkippedTokens);
+        };
+
+        PositionedSkippedToken.prototype.nextToken = function (includeSkippedTokens) {
+            if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; }
+            if (this.token().tokenKind === 10 /* EndOfFileToken */) {
+                return null;
+            }
+
+            if (includeSkippedTokens) {
+                var end = this.end();
+                var nextToken;
+
+                if (end <= this.parentToken().start()) {
+                    nextToken = TypeScript.Syntax.findSkippedTokenInLeadingTriviaList(this.parentToken(), end);
+
+                    if (nextToken) {
+                        return nextToken;
+                    }
+
+                    return this.parentToken();
+                } else {
+                    nextToken = TypeScript.Syntax.findSkippedTokenInTrailingTriviaList(this.parentToken(), end);
+
+                    if (nextToken) {
+                        return nextToken;
+                    }
+                }
+            }
+
+            return this.root().node().findToken(this.parentToken().fullEnd(), includeSkippedTokens);
+        };
+        return PositionedSkippedToken;
+    })(PositionedToken);
+    TypeScript.PositionedSkippedToken = PositionedSkippedToken;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (SyntaxKind) {
+        SyntaxKind[SyntaxKind["None"] = 0] = "None";
+        SyntaxKind[SyntaxKind["List"] = 1] = "List";
+        SyntaxKind[SyntaxKind["SeparatedList"] = 2] = "SeparatedList";
+        SyntaxKind[SyntaxKind["TriviaList"] = 3] = "TriviaList";
+
+        SyntaxKind[SyntaxKind["WhitespaceTrivia"] = 4] = "WhitespaceTrivia";
+        SyntaxKind[SyntaxKind["NewLineTrivia"] = 5] = "NewLineTrivia";
+        SyntaxKind[SyntaxKind["MultiLineCommentTrivia"] = 6] = "MultiLineCommentTrivia";
+        SyntaxKind[SyntaxKind["SingleLineCommentTrivia"] = 7] = "SingleLineCommentTrivia";
+        SyntaxKind[SyntaxKind["SkippedTokenTrivia"] = 8] = "SkippedTokenTrivia";
+
+        SyntaxKind[SyntaxKind["ErrorToken"] = 9] = "ErrorToken";
+        SyntaxKind[SyntaxKind["EndOfFileToken"] = 10] = "EndOfFileToken";
+
+        SyntaxKind[SyntaxKind["IdentifierName"] = 11] = "IdentifierName";
+
+        SyntaxKind[SyntaxKind["RegularExpressionLiteral"] = 12] = "RegularExpressionLiteral";
+        SyntaxKind[SyntaxKind["NumericLiteral"] = 13] = "NumericLiteral";
+        SyntaxKind[SyntaxKind["StringLiteral"] = 14] = "StringLiteral";
+
+        SyntaxKind[SyntaxKind["BreakKeyword"] = 15] = "BreakKeyword";
+        SyntaxKind[SyntaxKind["CaseKeyword"] = 16] = "CaseKeyword";
+        SyntaxKind[SyntaxKind["CatchKeyword"] = 17] = "CatchKeyword";
+        SyntaxKind[SyntaxKind["ContinueKeyword"] = 18] = "ContinueKeyword";
+        SyntaxKind[SyntaxKind["DebuggerKeyword"] = 19] = "DebuggerKeyword";
+        SyntaxKind[SyntaxKind["DefaultKeyword"] = 20] = "DefaultKeyword";
+        SyntaxKind[SyntaxKind["DeleteKeyword"] = 21] = "DeleteKeyword";
+        SyntaxKind[SyntaxKind["DoKeyword"] = 22] = "DoKeyword";
+        SyntaxKind[SyntaxKind["ElseKeyword"] = 23] = "ElseKeyword";
+        SyntaxKind[SyntaxKind["FalseKeyword"] = 24] = "FalseKeyword";
+        SyntaxKind[SyntaxKind["FinallyKeyword"] = 25] = "FinallyKeyword";
+        SyntaxKind[SyntaxKind["ForKeyword"] = 26] = "ForKeyword";
+        SyntaxKind[SyntaxKind["FunctionKeyword"] = 27] = "FunctionKeyword";
+        SyntaxKind[SyntaxKind["IfKeyword"] = 28] = "IfKeyword";
+        SyntaxKind[SyntaxKind["InKeyword"] = 29] = "InKeyword";
+        SyntaxKind[SyntaxKind["InstanceOfKeyword"] = 30] = "InstanceOfKeyword";
+        SyntaxKind[SyntaxKind["NewKeyword"] = 31] = "NewKeyword";
+        SyntaxKind[SyntaxKind["NullKeyword"] = 32] = "NullKeyword";
+        SyntaxKind[SyntaxKind["ReturnKeyword"] = 33] = "ReturnKeyword";
+        SyntaxKind[SyntaxKind["SwitchKeyword"] = 34] = "SwitchKeyword";
+        SyntaxKind[SyntaxKind["ThisKeyword"] = 35] = "ThisKeyword";
+        SyntaxKind[SyntaxKind["ThrowKeyword"] = 36] = "ThrowKeyword";
+        SyntaxKind[SyntaxKind["TrueKeyword"] = 37] = "TrueKeyword";
+        SyntaxKind[SyntaxKind["TryKeyword"] = 38] = "TryKeyword";
+        SyntaxKind[SyntaxKind["TypeOfKeyword"] = 39] = "TypeOfKeyword";
+        SyntaxKind[SyntaxKind["VarKeyword"] = 40] = "VarKeyword";
+        SyntaxKind[SyntaxKind["VoidKeyword"] = 41] = "VoidKeyword";
+        SyntaxKind[SyntaxKind["WhileKeyword"] = 42] = "WhileKeyword";
+        SyntaxKind[SyntaxKind["WithKeyword"] = 43] = "WithKeyword";
+
+        SyntaxKind[SyntaxKind["ClassKeyword"] = 44] = "ClassKeyword";
+        SyntaxKind[SyntaxKind["ConstKeyword"] = 45] = "ConstKeyword";
+        SyntaxKind[SyntaxKind["EnumKeyword"] = 46] = "EnumKeyword";
+        SyntaxKind[SyntaxKind["ExportKeyword"] = 47] = "ExportKeyword";
+        SyntaxKind[SyntaxKind["ExtendsKeyword"] = 48] = "ExtendsKeyword";
+        SyntaxKind[SyntaxKind["ImportKeyword"] = 49] = "ImportKeyword";
+        SyntaxKind[SyntaxKind["SuperKeyword"] = 50] = "SuperKeyword";
+
+        SyntaxKind[SyntaxKind["ImplementsKeyword"] = 51] = "ImplementsKeyword";
+        SyntaxKind[SyntaxKind["InterfaceKeyword"] = 52] = "InterfaceKeyword";
+        SyntaxKind[SyntaxKind["LetKeyword"] = 53] = "LetKeyword";
+        SyntaxKind[SyntaxKind["PackageKeyword"] = 54] = "PackageKeyword";
+        SyntaxKind[SyntaxKind["PrivateKeyword"] = 55] = "PrivateKeyword";
+        SyntaxKind[SyntaxKind["ProtectedKeyword"] = 56] = "ProtectedKeyword";
+        SyntaxKind[SyntaxKind["PublicKeyword"] = 57] = "PublicKeyword";
+        SyntaxKind[SyntaxKind["StaticKeyword"] = 58] = "StaticKeyword";
+        SyntaxKind[SyntaxKind["YieldKeyword"] = 59] = "YieldKeyword";
+
+        SyntaxKind[SyntaxKind["AnyKeyword"] = 60] = "AnyKeyword";
+        SyntaxKind[SyntaxKind["BooleanKeyword"] = 61] = "BooleanKeyword";
+        SyntaxKind[SyntaxKind["ConstructorKeyword"] = 62] = "ConstructorKeyword";
+        SyntaxKind[SyntaxKind["DeclareKeyword"] = 63] = "DeclareKeyword";
+        SyntaxKind[SyntaxKind["GetKeyword"] = 64] = "GetKeyword";
+        SyntaxKind[SyntaxKind["ModuleKeyword"] = 65] = "ModuleKeyword";
+        SyntaxKind[SyntaxKind["RequireKeyword"] = 66] = "RequireKeyword";
+        SyntaxKind[SyntaxKind["NumberKeyword"] = 67] = "NumberKeyword";
+        SyntaxKind[SyntaxKind["SetKeyword"] = 68] = "SetKeyword";
+        SyntaxKind[SyntaxKind["StringKeyword"] = 69] = "StringKeyword";
+
+        SyntaxKind[SyntaxKind["OpenBraceToken"] = 70] = "OpenBraceToken";
+        SyntaxKind[SyntaxKind["CloseBraceToken"] = 71] = "CloseBraceToken";
+        SyntaxKind[SyntaxKind["OpenParenToken"] = 72] = "OpenParenToken";
+        SyntaxKind[SyntaxKind["CloseParenToken"] = 73] = "CloseParenToken";
+        SyntaxKind[SyntaxKind["OpenBracketToken"] = 74] = "OpenBracketToken";
+        SyntaxKind[SyntaxKind["CloseBracketToken"] = 75] = "CloseBracketToken";
+        SyntaxKind[SyntaxKind["DotToken"] = 76] = "DotToken";
+        SyntaxKind[SyntaxKind["DotDotDotToken"] = 77] = "DotDotDotToken";
+        SyntaxKind[SyntaxKind["SemicolonToken"] = 78] = "SemicolonToken";
+        SyntaxKind[SyntaxKind["CommaToken"] = 79] = "CommaToken";
+        SyntaxKind[SyntaxKind["LessThanToken"] = 80] = "LessThanToken";
+        SyntaxKind[SyntaxKind["GreaterThanToken"] = 81] = "GreaterThanToken";
+        SyntaxKind[SyntaxKind["LessThanEqualsToken"] = 82] = "LessThanEqualsToken";
+        SyntaxKind[SyntaxKind["GreaterThanEqualsToken"] = 83] = "GreaterThanEqualsToken";
+        SyntaxKind[SyntaxKind["EqualsEqualsToken"] = 84] = "EqualsEqualsToken";
+        SyntaxKind[SyntaxKind["EqualsGreaterThanToken"] = 85] = "EqualsGreaterThanToken";
+        SyntaxKind[SyntaxKind["ExclamationEqualsToken"] = 86] = "ExclamationEqualsToken";
+        SyntaxKind[SyntaxKind["EqualsEqualsEqualsToken"] = 87] = "EqualsEqualsEqualsToken";
+        SyntaxKind[SyntaxKind["ExclamationEqualsEqualsToken"] = 88] = "ExclamationEqualsEqualsToken";
+        SyntaxKind[SyntaxKind["PlusToken"] = 89] = "PlusToken";
+        SyntaxKind[SyntaxKind["MinusToken"] = 90] = "MinusToken";
+        SyntaxKind[SyntaxKind["AsteriskToken"] = 91] = "AsteriskToken";
+        SyntaxKind[SyntaxKind["PercentToken"] = 92] = "PercentToken";
+        SyntaxKind[SyntaxKind["PlusPlusToken"] = 93] = "PlusPlusToken";
+        SyntaxKind[SyntaxKind["MinusMinusToken"] = 94] = "MinusMinusToken";
+        SyntaxKind[SyntaxKind["LessThanLessThanToken"] = 95] = "LessThanLessThanToken";
+        SyntaxKind[SyntaxKind["GreaterThanGreaterThanToken"] = 96] = "GreaterThanGreaterThanToken";
+        SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanToken"] = 97] = "GreaterThanGreaterThanGreaterThanToken";
+        SyntaxKind[SyntaxKind["AmpersandToken"] = 98] = "AmpersandToken";
+        SyntaxKind[SyntaxKind["BarToken"] = 99] = "BarToken";
+        SyntaxKind[SyntaxKind["CaretToken"] = 100] = "CaretToken";
+        SyntaxKind[SyntaxKind["ExclamationToken"] = 101] = "ExclamationToken";
+        SyntaxKind[SyntaxKind["TildeToken"] = 102] = "TildeToken";
+        SyntaxKind[SyntaxKind["AmpersandAmpersandToken"] = 103] = "AmpersandAmpersandToken";
+        SyntaxKind[SyntaxKind["BarBarToken"] = 104] = "BarBarToken";
+        SyntaxKind[SyntaxKind["QuestionToken"] = 105] = "QuestionToken";
+        SyntaxKind[SyntaxKind["ColonToken"] = 106] = "ColonToken";
+        SyntaxKind[SyntaxKind["EqualsToken"] = 107] = "EqualsToken";
+        SyntaxKind[SyntaxKind["PlusEqualsToken"] = 108] = "PlusEqualsToken";
+        SyntaxKind[SyntaxKind["MinusEqualsToken"] = 109] = "MinusEqualsToken";
+        SyntaxKind[SyntaxKind["AsteriskEqualsToken"] = 110] = "AsteriskEqualsToken";
+        SyntaxKind[SyntaxKind["PercentEqualsToken"] = 111] = "PercentEqualsToken";
+        SyntaxKind[SyntaxKind["LessThanLessThanEqualsToken"] = 112] = "LessThanLessThanEqualsToken";
+        SyntaxKind[SyntaxKind["GreaterThanGreaterThanEqualsToken"] = 113] = "GreaterThanGreaterThanEqualsToken";
+        SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanEqualsToken"] = 114] = "GreaterThanGreaterThanGreaterThanEqualsToken";
+        SyntaxKind[SyntaxKind["AmpersandEqualsToken"] = 115] = "AmpersandEqualsToken";
+        SyntaxKind[SyntaxKind["BarEqualsToken"] = 116] = "BarEqualsToken";
+        SyntaxKind[SyntaxKind["CaretEqualsToken"] = 117] = "CaretEqualsToken";
+        SyntaxKind[SyntaxKind["SlashToken"] = 118] = "SlashToken";
+        SyntaxKind[SyntaxKind["SlashEqualsToken"] = 119] = "SlashEqualsToken";
+
+        SyntaxKind[SyntaxKind["SourceUnit"] = 120] = "SourceUnit";
+
+        SyntaxKind[SyntaxKind["QualifiedName"] = 121] = "QualifiedName";
+
+        SyntaxKind[SyntaxKind["ObjectType"] = 122] = "ObjectType";
+        SyntaxKind[SyntaxKind["FunctionType"] = 123] = "FunctionType";
+        SyntaxKind[SyntaxKind["ArrayType"] = 124] = "ArrayType";
+        SyntaxKind[SyntaxKind["ConstructorType"] = 125] = "ConstructorType";
+        SyntaxKind[SyntaxKind["GenericType"] = 126] = "GenericType";
+        SyntaxKind[SyntaxKind["TypeQuery"] = 127] = "TypeQuery";
+
+        SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 128] = "InterfaceDeclaration";
+        SyntaxKind[SyntaxKind["FunctionDeclaration"] = 129] = "FunctionDeclaration";
+        SyntaxKind[SyntaxKind["ModuleDeclaration"] = 130] = "ModuleDeclaration";
+        SyntaxKind[SyntaxKind["ClassDeclaration"] = 131] = "ClassDeclaration";
+        SyntaxKind[SyntaxKind["EnumDeclaration"] = 132] = "EnumDeclaration";
+        SyntaxKind[SyntaxKind["ImportDeclaration"] = 133] = "ImportDeclaration";
+        SyntaxKind[SyntaxKind["ExportAssignment"] = 134] = "ExportAssignment";
+
+        SyntaxKind[SyntaxKind["MemberFunctionDeclaration"] = 135] = "MemberFunctionDeclaration";
+        SyntaxKind[SyntaxKind["MemberVariableDeclaration"] = 136] = "MemberVariableDeclaration";
+        SyntaxKind[SyntaxKind["ConstructorDeclaration"] = 137] = "ConstructorDeclaration";
+        SyntaxKind[SyntaxKind["IndexMemberDeclaration"] = 138] = "IndexMemberDeclaration";
+
+        SyntaxKind[SyntaxKind["GetAccessor"] = 139] = "GetAccessor";
+        SyntaxKind[SyntaxKind["SetAccessor"] = 140] = "SetAccessor";
+
+        SyntaxKind[SyntaxKind["PropertySignature"] = 141] = "PropertySignature";
+        SyntaxKind[SyntaxKind["CallSignature"] = 142] = "CallSignature";
+        SyntaxKind[SyntaxKind["ConstructSignature"] = 143] = "ConstructSignature";
+        SyntaxKind[SyntaxKind["IndexSignature"] = 144] = "IndexSignature";
+        SyntaxKind[SyntaxKind["MethodSignature"] = 145] = "MethodSignature";
+
+        SyntaxKind[SyntaxKind["Block"] = 146] = "Block";
+        SyntaxKind[SyntaxKind["IfStatement"] = 147] = "IfStatement";
+        SyntaxKind[SyntaxKind["VariableStatement"] = 148] = "VariableStatement";
+        SyntaxKind[SyntaxKind["ExpressionStatement"] = 149] = "ExpressionStatement";
+        SyntaxKind[SyntaxKind["ReturnStatement"] = 150] = "ReturnStatement";
+        SyntaxKind[SyntaxKind["SwitchStatement"] = 151] = "SwitchStatement";
+        SyntaxKind[SyntaxKind["BreakStatement"] = 152] = "BreakStatement";
+        SyntaxKind[SyntaxKind["ContinueStatement"] = 153] = "ContinueStatement";
+        SyntaxKind[SyntaxKind["ForStatement"] = 154] = "ForStatement";
+        SyntaxKind[SyntaxKind["ForInStatement"] = 155] = "ForInStatement";
+        SyntaxKind[SyntaxKind["EmptyStatement"] = 156] = "EmptyStatement";
+        SyntaxKind[SyntaxKind["ThrowStatement"] = 157] = "ThrowStatement";
+        SyntaxKind[SyntaxKind["WhileStatement"] = 158] = "WhileStatement";
+        SyntaxKind[SyntaxKind["TryStatement"] = 159] = "TryStatement";
+        SyntaxKind[SyntaxKind["LabeledStatement"] = 160] = "LabeledStatement";
+        SyntaxKind[SyntaxKind["DoStatement"] = 161] = "DoStatement";
+        SyntaxKind[SyntaxKind["DebuggerStatement"] = 162] = "DebuggerStatement";
+        SyntaxKind[SyntaxKind["WithStatement"] = 163] = "WithStatement";
+
+        SyntaxKind[SyntaxKind["PlusExpression"] = 164] = "PlusExpression";
+        SyntaxKind[SyntaxKind["NegateExpression"] = 165] = "NegateExpression";
+        SyntaxKind[SyntaxKind["BitwiseNotExpression"] = 166] = "BitwiseNotExpression";
+        SyntaxKind[SyntaxKind["LogicalNotExpression"] = 167] = "LogicalNotExpression";
+        SyntaxKind[SyntaxKind["PreIncrementExpression"] = 168] = "PreIncrementExpression";
+        SyntaxKind[SyntaxKind["PreDecrementExpression"] = 169] = "PreDecrementExpression";
+        SyntaxKind[SyntaxKind["DeleteExpression"] = 170] = "DeleteExpression";
+        SyntaxKind[SyntaxKind["TypeOfExpression"] = 171] = "TypeOfExpression";
+        SyntaxKind[SyntaxKind["VoidExpression"] = 172] = "VoidExpression";
+        SyntaxKind[SyntaxKind["CommaExpression"] = 173] = "CommaExpression";
+        SyntaxKind[SyntaxKind["AssignmentExpression"] = 174] = "AssignmentExpression";
+        SyntaxKind[SyntaxKind["AddAssignmentExpression"] = 175] = "AddAssignmentExpression";
+        SyntaxKind[SyntaxKind["SubtractAssignmentExpression"] = 176] = "SubtractAssignmentExpression";
+        SyntaxKind[SyntaxKind["MultiplyAssignmentExpression"] = 177] = "MultiplyAssignmentExpression";
+        SyntaxKind[SyntaxKind["DivideAssignmentExpression"] = 178] = "DivideAssignmentExpression";
+        SyntaxKind[SyntaxKind["ModuloAssignmentExpression"] = 179] = "ModuloAssignmentExpression";
+        SyntaxKind[SyntaxKind["AndAssignmentExpression"] = 180] = "AndAssignmentExpression";
+        SyntaxKind[SyntaxKind["ExclusiveOrAssignmentExpression"] = 181] = "ExclusiveOrAssignmentExpression";
+        SyntaxKind[SyntaxKind["OrAssignmentExpression"] = 182] = "OrAssignmentExpression";
+        SyntaxKind[SyntaxKind["LeftShiftAssignmentExpression"] = 183] = "LeftShiftAssignmentExpression";
+        SyntaxKind[SyntaxKind["SignedRightShiftAssignmentExpression"] = 184] = "SignedRightShiftAssignmentExpression";
+        SyntaxKind[SyntaxKind["UnsignedRightShiftAssignmentExpression"] = 185] = "UnsignedRightShiftAssignmentExpression";
+        SyntaxKind[SyntaxKind["ConditionalExpression"] = 186] = "ConditionalExpression";
+        SyntaxKind[SyntaxKind["LogicalOrExpression"] = 187] = "LogicalOrExpression";
+        SyntaxKind[SyntaxKind["LogicalAndExpression"] = 188] = "LogicalAndExpression";
+        SyntaxKind[SyntaxKind["BitwiseOrExpression"] = 189] = "BitwiseOrExpression";
+        SyntaxKind[SyntaxKind["BitwiseExclusiveOrExpression"] = 190] = "BitwiseExclusiveOrExpression";
+        SyntaxKind[SyntaxKind["BitwiseAndExpression"] = 191] = "BitwiseAndExpression";
+        SyntaxKind[SyntaxKind["EqualsWithTypeConversionExpression"] = 192] = "EqualsWithTypeConversionExpression";
+        SyntaxKind[SyntaxKind["NotEqualsWithTypeConversionExpression"] = 193] = "NotEqualsWithTypeConversionExpression";
+        SyntaxKind[SyntaxKind["EqualsExpression"] = 194] = "EqualsExpression";
+        SyntaxKind[SyntaxKind["NotEqualsExpression"] = 195] = "NotEqualsExpression";
+        SyntaxKind[SyntaxKind["LessThanExpression"] = 196] = "LessThanExpression";
+        SyntaxKind[SyntaxKind["GreaterThanExpression"] = 197] = "GreaterThanExpression";
+        SyntaxKind[SyntaxKind["LessThanOrEqualExpression"] = 198] = "LessThanOrEqualExpression";
+        SyntaxKind[SyntaxKind["GreaterThanOrEqualExpression"] = 199] = "GreaterThanOrEqualExpression";
+        SyntaxKind[SyntaxKind["InstanceOfExpression"] = 200] = "InstanceOfExpression";
+        SyntaxKind[SyntaxKind["InExpression"] = 201] = "InExpression";
+        SyntaxKind[SyntaxKind["LeftShiftExpression"] = 202] = "LeftShiftExpression";
+        SyntaxKind[SyntaxKind["SignedRightShiftExpression"] = 203] = "SignedRightShiftExpression";
+        SyntaxKind[SyntaxKind["UnsignedRightShiftExpression"] = 204] = "UnsignedRightShiftExpression";
+        SyntaxKind[SyntaxKind["MultiplyExpression"] = 205] = "MultiplyExpression";
+        SyntaxKind[SyntaxKind["DivideExpression"] = 206] = "DivideExpression";
+        SyntaxKind[SyntaxKind["ModuloExpression"] = 207] = "ModuloExpression";
+        SyntaxKind[SyntaxKind["AddExpression"] = 208] = "AddExpression";
+        SyntaxKind[SyntaxKind["SubtractExpression"] = 209] = "SubtractExpression";
+        SyntaxKind[SyntaxKind["PostIncrementExpression"] = 210] = "PostIncrementExpression";
+        SyntaxKind[SyntaxKind["PostDecrementExpression"] = 211] = "PostDecrementExpression";
+        SyntaxKind[SyntaxKind["MemberAccessExpression"] = 212] = "MemberAccessExpression";
+        SyntaxKind[SyntaxKind["InvocationExpression"] = 213] = "InvocationExpression";
+        SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 214] = "ArrayLiteralExpression";
+        SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 215] = "ObjectLiteralExpression";
+        SyntaxKind[SyntaxKind["ObjectCreationExpression"] = 216] = "ObjectCreationExpression";
+        SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 217] = "ParenthesizedExpression";
+        SyntaxKind[SyntaxKind["ParenthesizedArrowFunctionExpression"] = 218] = "ParenthesizedArrowFunctionExpression";
+        SyntaxKind[SyntaxKind["SimpleArrowFunctionExpression"] = 219] = "SimpleArrowFunctionExpression";
+        SyntaxKind[SyntaxKind["CastExpression"] = 220] = "CastExpression";
+        SyntaxKind[SyntaxKind["ElementAccessExpression"] = 221] = "ElementAccessExpression";
+        SyntaxKind[SyntaxKind["FunctionExpression"] = 222] = "FunctionExpression";
+        SyntaxKind[SyntaxKind["OmittedExpression"] = 223] = "OmittedExpression";
+
+        SyntaxKind[SyntaxKind["VariableDeclaration"] = 224] = "VariableDeclaration";
+        SyntaxKind[SyntaxKind["VariableDeclarator"] = 225] = "VariableDeclarator";
+
+        SyntaxKind[SyntaxKind["ArgumentList"] = 226] = "ArgumentList";
+        SyntaxKind[SyntaxKind["ParameterList"] = 227] = "ParameterList";
+        SyntaxKind[SyntaxKind["TypeArgumentList"] = 228] = "TypeArgumentList";
+        SyntaxKind[SyntaxKind["TypeParameterList"] = 229] = "TypeParameterList";
+
+        SyntaxKind[SyntaxKind["ExtendsHeritageClause"] = 230] = "ExtendsHeritageClause";
+        SyntaxKind[SyntaxKind["ImplementsHeritageClause"] = 231] = "ImplementsHeritageClause";
+        SyntaxKind[SyntaxKind["EqualsValueClause"] = 232] = "EqualsValueClause";
+        SyntaxKind[SyntaxKind["CaseSwitchClause"] = 233] = "CaseSwitchClause";
+        SyntaxKind[SyntaxKind["DefaultSwitchClause"] = 234] = "DefaultSwitchClause";
+        SyntaxKind[SyntaxKind["ElseClause"] = 235] = "ElseClause";
+        SyntaxKind[SyntaxKind["CatchClause"] = 236] = "CatchClause";
+        SyntaxKind[SyntaxKind["FinallyClause"] = 237] = "FinallyClause";
+
+        SyntaxKind[SyntaxKind["TypeParameter"] = 238] = "TypeParameter";
+        SyntaxKind[SyntaxKind["Constraint"] = 239] = "Constraint";
+
+        SyntaxKind[SyntaxKind["SimplePropertyAssignment"] = 240] = "SimplePropertyAssignment";
+
+        SyntaxKind[SyntaxKind["FunctionPropertyAssignment"] = 241] = "FunctionPropertyAssignment";
+
+        SyntaxKind[SyntaxKind["Parameter"] = 242] = "Parameter";
+        SyntaxKind[SyntaxKind["EnumElement"] = 243] = "EnumElement";
+        SyntaxKind[SyntaxKind["TypeAnnotation"] = 244] = "TypeAnnotation";
+        SyntaxKind[SyntaxKind["ExternalModuleReference"] = 245] = "ExternalModuleReference";
+        SyntaxKind[SyntaxKind["ModuleNameModuleReference"] = 246] = "ModuleNameModuleReference";
+        SyntaxKind[SyntaxKind["Last"] = SyntaxKind.ModuleNameModuleReference] = "Last";
+
+        SyntaxKind[SyntaxKind["FirstStandardKeyword"] = SyntaxKind.BreakKeyword] = "FirstStandardKeyword";
+        SyntaxKind[SyntaxKind["LastStandardKeyword"] = SyntaxKind.WithKeyword] = "LastStandardKeyword";
+
+        SyntaxKind[SyntaxKind["FirstFutureReservedKeyword"] = SyntaxKind.ClassKeyword] = "FirstFutureReservedKeyword";
+        SyntaxKind[SyntaxKind["LastFutureReservedKeyword"] = SyntaxKind.SuperKeyword] = "LastFutureReservedKeyword";
+
+        SyntaxKind[SyntaxKind["FirstFutureReservedStrictKeyword"] = SyntaxKind.ImplementsKeyword] = "FirstFutureReservedStrictKeyword";
+        SyntaxKind[SyntaxKind["LastFutureReservedStrictKeyword"] = SyntaxKind.YieldKeyword] = "LastFutureReservedStrictKeyword";
+
+        SyntaxKind[SyntaxKind["FirstTypeScriptKeyword"] = SyntaxKind.AnyKeyword] = "FirstTypeScriptKeyword";
+        SyntaxKind[SyntaxKind["LastTypeScriptKeyword"] = SyntaxKind.StringKeyword] = "LastTypeScriptKeyword";
+
+        SyntaxKind[SyntaxKind["FirstKeyword"] = SyntaxKind.FirstStandardKeyword] = "FirstKeyword";
+        SyntaxKind[SyntaxKind["LastKeyword"] = SyntaxKind.LastTypeScriptKeyword] = "LastKeyword";
+
+        SyntaxKind[SyntaxKind["FirstToken"] = SyntaxKind.ErrorToken] = "FirstToken";
+        SyntaxKind[SyntaxKind["LastToken"] = SyntaxKind.SlashEqualsToken] = "LastToken";
+
+        SyntaxKind[SyntaxKind["FirstPunctuation"] = SyntaxKind.OpenBraceToken] = "FirstPunctuation";
+        SyntaxKind[SyntaxKind["LastPunctuation"] = SyntaxKind.SlashEqualsToken] = "LastPunctuation";
+
+        SyntaxKind[SyntaxKind["FirstFixedWidth"] = SyntaxKind.FirstKeyword] = "FirstFixedWidth";
+        SyntaxKind[SyntaxKind["LastFixedWidth"] = SyntaxKind.LastPunctuation] = "LastFixedWidth";
+
+        SyntaxKind[SyntaxKind["FirstTrivia"] = SyntaxKind.WhitespaceTrivia] = "FirstTrivia";
+        SyntaxKind[SyntaxKind["LastTrivia"] = SyntaxKind.SkippedTokenTrivia] = "LastTrivia";
+    })(TypeScript.SyntaxKind || (TypeScript.SyntaxKind = {}));
+    var SyntaxKind = TypeScript.SyntaxKind;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (SyntaxFacts) {
+        var textToKeywordKind = {
+            "any": 60 /* AnyKeyword */,
+            "boolean": 61 /* BooleanKeyword */,
+            "break": 15 /* BreakKeyword */,
+            "case": 16 /* CaseKeyword */,
+            "catch": 17 /* CatchKeyword */,
+            "class": 44 /* ClassKeyword */,
+            "continue": 18 /* ContinueKeyword */,
+            "const": 45 /* ConstKeyword */,
+            "constructor": 62 /* ConstructorKeyword */,
+            "debugger": 19 /* DebuggerKeyword */,
+            "declare": 63 /* DeclareKeyword */,
+            "default": 20 /* DefaultKeyword */,
+            "delete": 21 /* DeleteKeyword */,
+            "do": 22 /* DoKeyword */,
+            "else": 23 /* ElseKeyword */,
+            "enum": 46 /* EnumKeyword */,
+            "export": 47 /* ExportKeyword */,
+            "extends": 48 /* ExtendsKeyword */,
+            "false": 24 /* FalseKeyword */,
+            "finally": 25 /* FinallyKeyword */,
+            "for": 26 /* ForKeyword */,
+            "function": 27 /* FunctionKeyword */,
+            "get": 64 /* GetKeyword */,
+            "if": 28 /* IfKeyword */,
+            "implements": 51 /* ImplementsKeyword */,
+            "import": 49 /* ImportKeyword */,
+            "in": 29 /* InKeyword */,
+            "instanceof": 30 /* InstanceOfKeyword */,
+            "interface": 52 /* InterfaceKeyword */,
+            "let": 53 /* LetKeyword */,
+            "module": 65 /* ModuleKeyword */,
+            "new": 31 /* NewKeyword */,
+            "null": 32 /* NullKeyword */,
+            "number": 67 /* NumberKeyword */,
+            "package": 54 /* PackageKeyword */,
+            "private": 55 /* PrivateKeyword */,
+            "protected": 56 /* ProtectedKeyword */,
+            "public": 57 /* PublicKeyword */,
+            "require": 66 /* RequireKeyword */,
+            "return": 33 /* ReturnKeyword */,
+            "set": 68 /* SetKeyword */,
+            "static": 58 /* StaticKeyword */,
+            "string": 69 /* StringKeyword */,
+            "super": 50 /* SuperKeyword */,
+            "switch": 34 /* SwitchKeyword */,
+            "this": 35 /* ThisKeyword */,
+            "throw": 36 /* ThrowKeyword */,
+            "true": 37 /* TrueKeyword */,
+            "try": 38 /* TryKeyword */,
+            "typeof": 39 /* TypeOfKeyword */,
+            "var": 40 /* VarKeyword */,
+            "void": 41 /* VoidKeyword */,
+            "while": 42 /* WhileKeyword */,
+            "with": 43 /* WithKeyword */,
+            "yield": 59 /* YieldKeyword */,
+            "{": 70 /* OpenBraceToken */,
+            "}": 71 /* CloseBraceToken */,
+            "(": 72 /* OpenParenToken */,
+            ")": 73 /* CloseParenToken */,
+            "[": 74 /* OpenBracketToken */,
+            "]": 75 /* CloseBracketToken */,
+            ".": 76 /* DotToken */,
+            "...": 77 /* DotDotDotToken */,
+            ";": 78 /* SemicolonToken */,
+            ",": 79 /* CommaToken */,
+            "<": 80 /* LessThanToken */,
+            ">": 81 /* GreaterThanToken */,
+            "<=": 82 /* LessThanEqualsToken */,
+            ">=": 83 /* GreaterThanEqualsToken */,
+            "==": 84 /* EqualsEqualsToken */,
+            "=>": 85 /* EqualsGreaterThanToken */,
+            "!=": 86 /* ExclamationEqualsToken */,
+            "===": 87 /* EqualsEqualsEqualsToken */,
+            "!==": 88 /* ExclamationEqualsEqualsToken */,
+            "+": 89 /* PlusToken */,
+            "-": 90 /* MinusToken */,
+            "*": 91 /* AsteriskToken */,
+            "%": 92 /* PercentToken */,
+            "++": 93 /* PlusPlusToken */,
+            "--": 94 /* MinusMinusToken */,
+            "<<": 95 /* LessThanLessThanToken */,
+            ">>": 96 /* GreaterThanGreaterThanToken */,
+            ">>>": 97 /* GreaterThanGreaterThanGreaterThanToken */,
+            "&": 98 /* AmpersandToken */,
+            "|": 99 /* BarToken */,
+            "^": 100 /* CaretToken */,
+            "!": 101 /* ExclamationToken */,
+            "~": 102 /* TildeToken */,
+            "&&": 103 /* AmpersandAmpersandToken */,
+            "||": 104 /* BarBarToken */,
+            "?": 105 /* QuestionToken */,
+            ":": 106 /* ColonToken */,
+            "=": 107 /* EqualsToken */,
+            "+=": 108 /* PlusEqualsToken */,
+            "-=": 109 /* MinusEqualsToken */,
+            "*=": 110 /* AsteriskEqualsToken */,
+            "%=": 111 /* PercentEqualsToken */,
+            "<<=": 112 /* LessThanLessThanEqualsToken */,
+            ">>=": 113 /* GreaterThanGreaterThanEqualsToken */,
+            ">>>=": 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */,
+            "&=": 115 /* AmpersandEqualsToken */,
+            "|=": 116 /* BarEqualsToken */,
+            "^=": 117 /* CaretEqualsToken */,
+            "/": 118 /* SlashToken */,
+            "/=": 119 /* SlashEqualsToken */
+        };
+
+        var kindToText = new Array();
+
+        for (var name in textToKeywordKind) {
+            if (textToKeywordKind.hasOwnProperty(name)) {
+                kindToText[textToKeywordKind[name]] = name;
+            }
+        }
+
+        kindToText[62 /* ConstructorKeyword */] = "constructor";
+
+        function getTokenKind(text) {
+            if (textToKeywordKind.hasOwnProperty(text)) {
+                return textToKeywordKind[text];
+            }
+
+            return 0 /* None */;
+        }
+        SyntaxFacts.getTokenKind = getTokenKind;
+
+        function getText(kind) {
+            var result = kindToText[kind];
+            return result !== undefined ? result : null;
+        }
+        SyntaxFacts.getText = getText;
+
+        function isTokenKind(kind) {
+            return kind >= 9 /* FirstToken */ && kind <= 119 /* LastToken */;
+        }
+        SyntaxFacts.isTokenKind = isTokenKind;
+
+        function isAnyKeyword(kind) {
+            return kind >= 15 /* FirstKeyword */ && kind <= 69 /* LastKeyword */;
+        }
+        SyntaxFacts.isAnyKeyword = isAnyKeyword;
+
+        function isStandardKeyword(kind) {
+            return kind >= 15 /* FirstStandardKeyword */ && kind <= 43 /* LastStandardKeyword */;
+        }
+        SyntaxFacts.isStandardKeyword = isStandardKeyword;
+
+        function isFutureReservedKeyword(kind) {
+            return kind >= 44 /* FirstFutureReservedKeyword */ && kind <= 50 /* LastFutureReservedKeyword */;
+        }
+        SyntaxFacts.isFutureReservedKeyword = isFutureReservedKeyword;
+
+        function isFutureReservedStrictKeyword(kind) {
+            return kind >= 51 /* FirstFutureReservedStrictKeyword */ && kind <= 59 /* LastFutureReservedStrictKeyword */;
+        }
+        SyntaxFacts.isFutureReservedStrictKeyword = isFutureReservedStrictKeyword;
+
+        function isAnyPunctuation(kind) {
+            return kind >= 70 /* FirstPunctuation */ && kind <= 119 /* LastPunctuation */;
+        }
+        SyntaxFacts.isAnyPunctuation = isAnyPunctuation;
+
+        function isPrefixUnaryExpressionOperatorToken(tokenKind) {
+            return getPrefixUnaryExpressionFromOperatorToken(tokenKind) !== 0 /* None */;
+        }
+        SyntaxFacts.isPrefixUnaryExpressionOperatorToken = isPrefixUnaryExpressionOperatorToken;
+
+        function isBinaryExpressionOperatorToken(tokenKind) {
+            return getBinaryExpressionFromOperatorToken(tokenKind) !== 0 /* None */;
+        }
+        SyntaxFacts.isBinaryExpressionOperatorToken = isBinaryExpressionOperatorToken;
+
+        function getPrefixUnaryExpressionFromOperatorToken(tokenKind) {
+            switch (tokenKind) {
+                case 89 /* PlusToken */:
+                    return 164 /* PlusExpression */;
+                case 90 /* MinusToken */:
+                    return 165 /* NegateExpression */;
+                case 102 /* TildeToken */:
+                    return 166 /* BitwiseNotExpression */;
+                case 101 /* ExclamationToken */:
+                    return 167 /* LogicalNotExpression */;
+                case 93 /* PlusPlusToken */:
+                    return 168 /* PreIncrementExpression */;
+                case 94 /* MinusMinusToken */:
+                    return 169 /* PreDecrementExpression */;
+
+                default:
+                    return 0 /* None */;
+            }
+        }
+        SyntaxFacts.getPrefixUnaryExpressionFromOperatorToken = getPrefixUnaryExpressionFromOperatorToken;
+
+        function getPostfixUnaryExpressionFromOperatorToken(tokenKind) {
+            switch (tokenKind) {
+                case 93 /* PlusPlusToken */:
+                    return 210 /* PostIncrementExpression */;
+                case 94 /* MinusMinusToken */:
+                    return 211 /* PostDecrementExpression */;
+                default:
+                    return 0 /* None */;
+            }
+        }
+        SyntaxFacts.getPostfixUnaryExpressionFromOperatorToken = getPostfixUnaryExpressionFromOperatorToken;
+
+        function getBinaryExpressionFromOperatorToken(tokenKind) {
+            switch (tokenKind) {
+                case 91 /* AsteriskToken */:
+                    return 205 /* MultiplyExpression */;
+
+                case 118 /* SlashToken */:
+                    return 206 /* DivideExpression */;
+
+                case 92 /* PercentToken */:
+                    return 207 /* ModuloExpression */;
+
+                case 89 /* PlusToken */:
+                    return 208 /* AddExpression */;
+
+                case 90 /* MinusToken */:
+                    return 209 /* SubtractExpression */;
+
+                case 95 /* LessThanLessThanToken */:
+                    return 202 /* LeftShiftExpression */;
+
+                case 96 /* GreaterThanGreaterThanToken */:
+                    return 203 /* SignedRightShiftExpression */;
+
+                case 97 /* GreaterThanGreaterThanGreaterThanToken */:
+                    return 204 /* UnsignedRightShiftExpression */;
+
+                case 80 /* LessThanToken */:
+                    return 196 /* LessThanExpression */;
+
+                case 81 /* GreaterThanToken */:
+                    return 197 /* GreaterThanExpression */;
+
+                case 82 /* LessThanEqualsToken */:
+                    return 198 /* LessThanOrEqualExpression */;
+
+                case 83 /* GreaterThanEqualsToken */:
+                    return 199 /* GreaterThanOrEqualExpression */;
+
+                case 30 /* InstanceOfKeyword */:
+                    return 200 /* InstanceOfExpression */;
+
+                case 29 /* InKeyword */:
+                    return 201 /* InExpression */;
+
+                case 84 /* EqualsEqualsToken */:
+                    return 192 /* EqualsWithTypeConversionExpression */;
+
+                case 86 /* ExclamationEqualsToken */:
+                    return 193 /* NotEqualsWithTypeConversionExpression */;
+
+                case 87 /* EqualsEqualsEqualsToken */:
+                    return 194 /* EqualsExpression */;
+
+                case 88 /* ExclamationEqualsEqualsToken */:
+                    return 195 /* NotEqualsExpression */;
+
+                case 98 /* AmpersandToken */:
+                    return 191 /* BitwiseAndExpression */;
+
+                case 100 /* CaretToken */:
+                    return 190 /* BitwiseExclusiveOrExpression */;
+
+                case 99 /* BarToken */:
+                    return 189 /* BitwiseOrExpression */;
+
+                case 103 /* AmpersandAmpersandToken */:
+                    return 188 /* LogicalAndExpression */;
+
+                case 104 /* BarBarToken */:
+                    return 187 /* LogicalOrExpression */;
+
+                case 116 /* BarEqualsToken */:
+                    return 182 /* OrAssignmentExpression */;
+
+                case 115 /* AmpersandEqualsToken */:
+                    return 180 /* AndAssignmentExpression */;
+
+                case 117 /* CaretEqualsToken */:
+                    return 181 /* ExclusiveOrAssignmentExpression */;
+
+                case 112 /* LessThanLessThanEqualsToken */:
+                    return 183 /* LeftShiftAssignmentExpression */;
+
+                case 113 /* GreaterThanGreaterThanEqualsToken */:
+                    return 184 /* SignedRightShiftAssignmentExpression */;
+
+                case 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
+                    return 185 /* UnsignedRightShiftAssignmentExpression */;
+
+                case 108 /* PlusEqualsToken */:
+                    return 175 /* AddAssignmentExpression */;
+
+                case 109 /* MinusEqualsToken */:
+                    return 176 /* SubtractAssignmentExpression */;
+
+                case 110 /* AsteriskEqualsToken */:
+                    return 177 /* MultiplyAssignmentExpression */;
+
+                case 119 /* SlashEqualsToken */:
+                    return 178 /* DivideAssignmentExpression */;
+
+                case 111 /* PercentEqualsToken */:
+                    return 179 /* ModuloAssignmentExpression */;
+
+                case 107 /* EqualsToken */:
+                    return 174 /* AssignmentExpression */;
+
+                case 79 /* CommaToken */:
+                    return 173 /* CommaExpression */;
+
+                default:
+                    return 0 /* None */;
+            }
+        }
+        SyntaxFacts.getBinaryExpressionFromOperatorToken = getBinaryExpressionFromOperatorToken;
+
+        function getOperatorTokenFromBinaryExpression(tokenKind) {
+            switch (tokenKind) {
+                case 205 /* MultiplyExpression */:
+                    return 91 /* AsteriskToken */;
+
+                case 206 /* DivideExpression */:
+                    return 118 /* SlashToken */;
+
+                case 207 /* ModuloExpression */:
+                    return 92 /* PercentToken */;
+
+                case 208 /* AddExpression */:
+                    return 89 /* PlusToken */;
+
+                case 209 /* SubtractExpression */:
+                    return 90 /* MinusToken */;
+
+                case 202 /* LeftShiftExpression */:
+                    return 95 /* LessThanLessThanToken */;
+
+                case 203 /* SignedRightShiftExpression */:
+                    return 96 /* GreaterThanGreaterThanToken */;
+
+                case 204 /* UnsignedRightShiftExpression */:
+                    return 97 /* GreaterThanGreaterThanGreaterThanToken */;
+
+                case 196 /* LessThanExpression */:
+                    return 80 /* LessThanToken */;
+
+                case 197 /* GreaterThanExpression */:
+                    return 81 /* GreaterThanToken */;
+
+                case 198 /* LessThanOrEqualExpression */:
+                    return 82 /* LessThanEqualsToken */;
+
+                case 199 /* GreaterThanOrEqualExpression */:
+                    return 83 /* GreaterThanEqualsToken */;
+
+                case 200 /* InstanceOfExpression */:
+                    return 30 /* InstanceOfKeyword */;
+
+                case 201 /* InExpression */:
+                    return 29 /* InKeyword */;
+
+                case 192 /* EqualsWithTypeConversionExpression */:
+                    return 84 /* EqualsEqualsToken */;
+
+                case 193 /* NotEqualsWithTypeConversionExpression */:
+                    return 86 /* ExclamationEqualsToken */;
+
+                case 194 /* EqualsExpression */:
+                    return 87 /* EqualsEqualsEqualsToken */;
+
+                case 195 /* NotEqualsExpression */:
+                    return 88 /* ExclamationEqualsEqualsToken */;
+
+                case 191 /* BitwiseAndExpression */:
+                    return 98 /* AmpersandToken */;
+
+                case 190 /* BitwiseExclusiveOrExpression */:
+                    return 100 /* CaretToken */;
+
+                case 189 /* BitwiseOrExpression */:
+                    return 99 /* BarToken */;
+
+                case 188 /* LogicalAndExpression */:
+                    return 103 /* AmpersandAmpersandToken */;
+
+                case 187 /* LogicalOrExpression */:
+                    return 104 /* BarBarToken */;
+
+                case 182 /* OrAssignmentExpression */:
+                    return 116 /* BarEqualsToken */;
+
+                case 180 /* AndAssignmentExpression */:
+                    return 115 /* AmpersandEqualsToken */;
+
+                case 181 /* ExclusiveOrAssignmentExpression */:
+                    return 117 /* CaretEqualsToken */;
+
+                case 183 /* LeftShiftAssignmentExpression */:
+                    return 112 /* LessThanLessThanEqualsToken */;
+
+                case 184 /* SignedRightShiftAssignmentExpression */:
+                    return 113 /* GreaterThanGreaterThanEqualsToken */;
+
+                case 185 /* UnsignedRightShiftAssignmentExpression */:
+                    return 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */;
+
+                case 175 /* AddAssignmentExpression */:
+                    return 108 /* PlusEqualsToken */;
+
+                case 176 /* SubtractAssignmentExpression */:
+                    return 109 /* MinusEqualsToken */;
+
+                case 177 /* MultiplyAssignmentExpression */:
+                    return 110 /* AsteriskEqualsToken */;
+
+                case 178 /* DivideAssignmentExpression */:
+                    return 119 /* SlashEqualsToken */;
+
+                case 179 /* ModuloAssignmentExpression */:
+                    return 111 /* PercentEqualsToken */;
+
+                case 174 /* AssignmentExpression */:
+                    return 107 /* EqualsToken */;
+
+                case 173 /* CommaExpression */:
+                    return 79 /* CommaToken */;
+
+                default:
+                    return 0 /* None */;
+            }
+        }
+        SyntaxFacts.getOperatorTokenFromBinaryExpression = getOperatorTokenFromBinaryExpression;
+
+        function isAnyDivideToken(kind) {
+            switch (kind) {
+                case 118 /* SlashToken */:
+                case 119 /* SlashEqualsToken */:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        SyntaxFacts.isAnyDivideToken = isAnyDivideToken;
+
+        function isAnyDivideOrRegularExpressionToken(kind) {
+            switch (kind) {
+                case 118 /* SlashToken */:
+                case 119 /* SlashEqualsToken */:
+                case 12 /* RegularExpressionLiteral */:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        SyntaxFacts.isAnyDivideOrRegularExpressionToken = isAnyDivideOrRegularExpressionToken;
+    })(TypeScript.SyntaxFacts || (TypeScript.SyntaxFacts = {}));
+    var SyntaxFacts = TypeScript.SyntaxFacts;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var isKeywordStartCharacter = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false);
+    var isIdentifierStartCharacter = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false);
+    var isIdentifierPartCharacter = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false);
+    var isNumericLiteralStart = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false);
+
+    for (var character = 0; character < 127 /* maxAsciiCharacter */; character++) {
+        if (character >= 97 /* a */ && character <= 122 /* z */) {
+            isIdentifierStartCharacter[character] = true;
+            isIdentifierPartCharacter[character] = true;
+        } else if ((character >= 65 /* A */ && character <= 90 /* Z */) || character === 95 /* _ */ || character === 36 /* $ */) {
+            isIdentifierStartCharacter[character] = true;
+            isIdentifierPartCharacter[character] = true;
+        } else if (character >= 48 /* _0 */ && character <= 57 /* _9 */) {
+            isIdentifierPartCharacter[character] = true;
+            isNumericLiteralStart[character] = true;
+        }
+    }
+
+    isNumericLiteralStart[46 /* dot */] = true;
+
+    for (var keywordKind = 15 /* FirstKeyword */; keywordKind <= 69 /* LastKeyword */; keywordKind++) {
+        var keyword = TypeScript.SyntaxFacts.getText(keywordKind);
+        isKeywordStartCharacter[keyword.charCodeAt(0)] = true;
+    }
+
+    var Scanner = (function () {
+        function Scanner(fileName, text, languageVersion, window) {
+            if (typeof window === "undefined") { window = TypeScript.ArrayUtilities.createArray(2048, 0); }
+            this.slidingWindow = new TypeScript.SlidingWindow(this, window, 0, text.length());
+            this.fileName = fileName;
+            this.text = text;
+            this._languageVersion = languageVersion;
+        }
+        Scanner.prototype.languageVersion = function () {
+            return this._languageVersion;
+        };
+
+        Scanner.prototype.fetchMoreItems = function (argument, sourceIndex, window, destinationIndex, spaceAvailable) {
+            var charactersRemaining = this.text.length() - sourceIndex;
+            var amountToRead = TypeScript.MathPrototype.min(charactersRemaining, spaceAvailable);
+            this.text.copyTo(sourceIndex, window, destinationIndex, amountToRead);
+            return amountToRead;
+        };
+
+        Scanner.prototype.currentCharCode = function () {
+            return this.slidingWindow.currentItem(null);
+        };
+
+        Scanner.prototype.absoluteIndex = function () {
+            return this.slidingWindow.absoluteIndex();
+        };
+
+        Scanner.prototype.setAbsoluteIndex = function (index) {
+            this.slidingWindow.setAbsoluteIndex(index);
+        };
+
+        Scanner.prototype.scan = function (diagnostics, allowRegularExpression) {
+            var diagnosticsLength = diagnostics.length;
+            var fullStart = this.slidingWindow.absoluteIndex();
+            var leadingTriviaInfo = this.scanTriviaInfo(diagnostics, false);
+
+            var start = this.slidingWindow.absoluteIndex();
+            var kindAndFlags = this.scanSyntaxToken(diagnostics, allowRegularExpression);
+            var end = this.slidingWindow.absoluteIndex();
+
+            var trailingTriviaInfo = this.scanTriviaInfo(diagnostics, true);
+            var fullEnd = this.slidingWindow.absoluteIndex();
+
+            var isVariableWidthKeyword = (kindAndFlags & -2147483648 /* IsVariableWidthKeyword */) !== 0;
+            var kind = kindAndFlags & ~-2147483648 /* IsVariableWidthKeyword */;
+
+            var token = this.createToken(fullStart, leadingTriviaInfo, start, kind, end, fullEnd, trailingTriviaInfo, isVariableWidthKeyword);
+
+            return diagnosticsLength !== diagnostics.length ? TypeScript.Syntax.realizeToken(token) : token;
+        };
+
+        Scanner.prototype.createToken = function (fullStart, leadingTriviaInfo, start, kind, end, fullEnd, trailingTriviaInfo, isVariableWidthKeyword) {
+            if (!isVariableWidthKeyword && kind >= 15 /* FirstFixedWidth */) {
+                if (leadingTriviaInfo === 0) {
+                    if (trailingTriviaInfo === 0) {
+                        return new TypeScript.Syntax.FixedWidthTokenWithNoTrivia(kind);
+                    } else {
+                        var fullText = this.text.substr(fullStart, fullEnd - fullStart, false);
+                        return new TypeScript.Syntax.FixedWidthTokenWithTrailingTrivia(fullText, kind, trailingTriviaInfo);
+                    }
+                } else if (trailingTriviaInfo === 0) {
+                    var fullText = this.text.substr(fullStart, fullEnd - fullStart, false);
+                    return new TypeScript.Syntax.FixedWidthTokenWithLeadingTrivia(fullText, kind, leadingTriviaInfo);
+                } else {
+                    var fullText = this.text.substr(fullStart, fullEnd - fullStart, false);
+                    return new TypeScript.Syntax.FixedWidthTokenWithLeadingAndTrailingTrivia(fullText, kind, leadingTriviaInfo, trailingTriviaInfo);
+                }
+            } else {
+                var width = end - start;
+
+                var fullText = this.text.substr(fullStart, fullEnd - fullStart, false);
+
+                if (leadingTriviaInfo === 0) {
+                    if (trailingTriviaInfo === 0) {
+                        return new TypeScript.Syntax.VariableWidthTokenWithNoTrivia(fullText, kind);
+                    } else {
+                        return new TypeScript.Syntax.VariableWidthTokenWithTrailingTrivia(fullText, kind, trailingTriviaInfo);
+                    }
+                } else if (trailingTriviaInfo === 0) {
+                    return new TypeScript.Syntax.VariableWidthTokenWithLeadingTrivia(fullText, kind, leadingTriviaInfo);
+                } else {
+                    return new TypeScript.Syntax.VariableWidthTokenWithLeadingAndTrailingTrivia(fullText, kind, leadingTriviaInfo, trailingTriviaInfo);
+                }
+            }
+        };
+
+        Scanner.scanTrivia = function (text, start, length, isTrailing) {
+            var scanner = new Scanner(null, text.subText(new TypeScript.TextSpan(start, length)), 1 /* EcmaScript5 */, Scanner.triviaWindow);
+            return scanner.scanTrivia(text, start, isTrailing);
+        };
+
+        Scanner.prototype.scanTrivia = function (underlyingText, underlyingTextStart, isTrailing) {
+            var trivia = new Array();
+
+            while (true) {
+                if (!this.slidingWindow.isAtEndOfSource()) {
+                    var ch = this.currentCharCode();
+
+                    switch (ch) {
+                        case 32 /* space */:
+                        case 160 /* nonBreakingSpace */:
+                        case 8192 /* enQuad */:
+                        case 8193 /* emQuad */:
+                        case 8194 /* enSpace */:
+                        case 8195 /* emSpace */:
+                        case 8196 /* threePerEmSpace */:
+                        case 8197 /* fourPerEmSpace */:
+                        case 8198 /* sixPerEmSpace */:
+                        case 8199 /* figureSpace */:
+                        case 8200 /* punctuationSpace */:
+                        case 8201 /* thinSpace */:
+                        case 8202 /* hairSpace */:
+                        case 8203 /* zeroWidthSpace */:
+                        case 8239 /* narrowNoBreakSpace */:
+                        case 12288 /* ideographicSpace */:
+
+                        case 9 /* tab */:
+                        case 11 /* verticalTab */:
+                        case 12 /* formFeed */:
+                        case 65279 /* byteOrderMark */:
+                            trivia.push(this.scanWhitespaceTrivia(underlyingText, underlyingTextStart));
+                            continue;
+
+                        case 47 /* slash */:
+                            var ch2 = this.slidingWindow.peekItemN(1);
+                            if (ch2 === 47 /* slash */) {
+                                trivia.push(this.scanSingleLineCommentTrivia(underlyingText, underlyingTextStart));
+                                continue;
+                            }
+
+                            if (ch2 === 42 /* asterisk */) {
+                                trivia.push(this.scanMultiLineCommentTrivia(underlyingText, underlyingTextStart));
+                                continue;
+                            }
+
+                            throw TypeScript.Errors.invalidOperation();
+
+                        case 13 /* carriageReturn */:
+                        case 10 /* lineFeed */:
+                        case 8233 /* paragraphSeparator */:
+                        case 8232 /* lineSeparator */:
+                            trivia.push(this.scanLineTerminatorSequenceTrivia(ch));
+
+                            if (!isTrailing) {
+                                continue;
+                            }
+
+                            break;
+
+                        default:
+                            throw TypeScript.Errors.invalidOperation();
+                    }
+                }
+
+                return TypeScript.Syntax.triviaList(trivia);
+            }
+        };
+
+        Scanner.prototype.scanTriviaInfo = function (diagnostics, isTrailing) {
+            var width = 0;
+            var hasCommentOrNewLine = 0;
+
+            while (true) {
+                var ch = this.currentCharCode();
+
+                switch (ch) {
+                    case 32 /* space */:
+                    case 160 /* nonBreakingSpace */:
+                    case 8192 /* enQuad */:
+                    case 8193 /* emQuad */:
+                    case 8194 /* enSpace */:
+                    case 8195 /* emSpace */:
+                    case 8196 /* threePerEmSpace */:
+                    case 8197 /* fourPerEmSpace */:
+                    case 8198 /* sixPerEmSpace */:
+                    case 8199 /* figureSpace */:
+                    case 8200 /* punctuationSpace */:
+                    case 8201 /* thinSpace */:
+                    case 8202 /* hairSpace */:
+                    case 8203 /* zeroWidthSpace */:
+                    case 8239 /* narrowNoBreakSpace */:
+                    case 12288 /* ideographicSpace */:
+
+                    case 9 /* tab */:
+                    case 11 /* verticalTab */:
+                    case 12 /* formFeed */:
+                    case 65279 /* byteOrderMark */:
+                        this.slidingWindow.moveToNextItem();
+                        width++;
+                        continue;
+
+                    case 47 /* slash */:
+                        var ch2 = this.slidingWindow.peekItemN(1);
+                        if (ch2 === 47 /* slash */) {
+                            hasCommentOrNewLine |= 2 /* TriviaCommentMask */;
+                            width += this.scanSingleLineCommentTriviaLength();
+                            continue;
+                        }
+
+                        if (ch2 === 42 /* asterisk */) {
+                            hasCommentOrNewLine |= 2 /* TriviaCommentMask */;
+                            width += this.scanMultiLineCommentTriviaLength(diagnostics);
+                            continue;
+                        }
+
+                        break;
+
+                    case 13 /* carriageReturn */:
+                    case 10 /* lineFeed */:
+                    case 8233 /* paragraphSeparator */:
+                    case 8232 /* lineSeparator */:
+                        hasCommentOrNewLine |= 1 /* TriviaNewLineMask */;
+                        width += this.scanLineTerminatorSequenceLength(ch);
+
+                        if (!isTrailing) {
+                            continue;
+                        }
+
+                        break;
+                }
+
+                return (width << 2 /* TriviaFullWidthShift */) | hasCommentOrNewLine;
+            }
+        };
+
+        Scanner.prototype.isNewLineCharacter = function (ch) {
+            switch (ch) {
+                case 13 /* carriageReturn */:
+                case 10 /* lineFeed */:
+                case 8233 /* paragraphSeparator */:
+                case 8232 /* lineSeparator */:
+                    return true;
+                default:
+                    return false;
+            }
+        };
+
+        Scanner.prototype.scanWhitespaceTrivia = function (underlyingText, underlyingTextStart) {
+            var absoluteStartIndex = this.absoluteIndex();
+
+            var width = 0;
+            while (true) {
+                var ch = this.currentCharCode();
+
+                switch (ch) {
+                    case 32 /* space */:
+                    case 160 /* nonBreakingSpace */:
+                    case 8192 /* enQuad */:
+                    case 8193 /* emQuad */:
+                    case 8194 /* enSpace */:
+                    case 8195 /* emSpace */:
+                    case 8196 /* threePerEmSpace */:
+                    case 8197 /* fourPerEmSpace */:
+                    case 8198 /* sixPerEmSpace */:
+                    case 8199 /* figureSpace */:
+                    case 8200 /* punctuationSpace */:
+                    case 8201 /* thinSpace */:
+                    case 8202 /* hairSpace */:
+                    case 8203 /* zeroWidthSpace */:
+                    case 8239 /* narrowNoBreakSpace */:
+                    case 12288 /* ideographicSpace */:
+
+                    case 9 /* tab */:
+                    case 11 /* verticalTab */:
+                    case 12 /* formFeed */:
+                    case 65279 /* byteOrderMark */:
+                        this.slidingWindow.moveToNextItem();
+                        width++;
+                        continue;
+                }
+
+                break;
+            }
+
+            return TypeScript.Syntax.deferredTrivia(4 /* WhitespaceTrivia */, underlyingText, underlyingTextStart + absoluteStartIndex, width);
+        };
+
+        Scanner.prototype.scanSingleLineCommentTrivia = function (underlyingText, underlyingTextStart) {
+            var absoluteStartIndex = this.slidingWindow.absoluteIndex();
+            var width = this.scanSingleLineCommentTriviaLength();
+
+            return TypeScript.Syntax.deferredTrivia(7 /* SingleLineCommentTrivia */, underlyingText, underlyingTextStart + absoluteStartIndex, width);
+        };
+
+        Scanner.prototype.scanSingleLineCommentTriviaLength = function () {
+            this.slidingWindow.moveToNextItem();
+            this.slidingWindow.moveToNextItem();
+
+            var width = 2;
+            while (true) {
+                if (this.slidingWindow.isAtEndOfSource() || this.isNewLineCharacter(this.currentCharCode())) {
+                    return width;
+                }
+
+                this.slidingWindow.moveToNextItem();
+                width++;
+            }
+        };
+
+        Scanner.prototype.scanMultiLineCommentTrivia = function (underlyingText, underlyingTextStart) {
+            var absoluteStartIndex = this.absoluteIndex();
+            var width = this.scanMultiLineCommentTriviaLength(null);
+
+            return TypeScript.Syntax.deferredTrivia(6 /* MultiLineCommentTrivia */, underlyingText, underlyingTextStart + absoluteStartIndex, width);
+        };
+
+        Scanner.prototype.scanMultiLineCommentTriviaLength = function (diagnostics) {
+            this.slidingWindow.moveToNextItem();
+            this.slidingWindow.moveToNextItem();
+
+            var width = 2;
+            while (true) {
+                if (this.slidingWindow.isAtEndOfSource()) {
+                    if (diagnostics !== null) {
+                        diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), this.slidingWindow.absoluteIndex(), 0, TypeScript.DiagnosticCode.AsteriskSlash_expected, null));
+                    }
+
+                    return width;
+                }
+
+                var ch = this.currentCharCode();
+                if (ch === 42 /* asterisk */ && this.slidingWindow.peekItemN(1) === 47 /* slash */) {
+                    this.slidingWindow.moveToNextItem();
+                    this.slidingWindow.moveToNextItem();
+                    width += 2;
+                    return width;
+                }
+
+                this.slidingWindow.moveToNextItem();
+                width++;
+            }
+        };
+
+        Scanner.prototype.scanLineTerminatorSequenceTrivia = function (ch) {
+            var absoluteStartIndex = this.slidingWindow.getAndPinAbsoluteIndex();
+            var width = this.scanLineTerminatorSequenceLength(ch);
+
+            var text = this.substring(absoluteStartIndex, absoluteStartIndex + width, false);
+            this.slidingWindow.releaseAndUnpinAbsoluteIndex(absoluteStartIndex);
+
+            return TypeScript.Syntax.trivia(5 /* NewLineTrivia */, text);
+        };
+
+        Scanner.prototype.scanLineTerminatorSequenceLength = function (ch) {
+            this.slidingWindow.moveToNextItem();
+
+            if (ch === 13 /* carriageReturn */ && this.currentCharCode() === 10 /* lineFeed */) {
+                this.slidingWindow.moveToNextItem();
+                return 2;
+            } else {
+                return 1;
+            }
+        };
+
+        Scanner.prototype.scanSyntaxToken = function (diagnostics, allowRegularExpression) {
+            if (this.slidingWindow.isAtEndOfSource()) {
+                return 10 /* EndOfFileToken */;
+            }
+
+            var character = this.currentCharCode();
+
+            switch (character) {
+                case 34 /* doubleQuote */:
+                case 39 /* singleQuote */:
+                    return this.scanStringLiteral(diagnostics);
+
+                case 47 /* slash */:
+                    return this.scanSlashToken(allowRegularExpression);
+
+                case 46 /* dot */:
+                    return this.scanDotToken(diagnostics);
+
+                case 45 /* minus */:
+                    return this.scanMinusToken();
+
+                case 33 /* exclamation */:
+                    return this.scanExclamationToken();
+
+                case 61 /* equals */:
+                    return this.scanEqualsToken();
+
+                case 124 /* bar */:
+                    return this.scanBarToken();
+
+                case 42 /* asterisk */:
+                    return this.scanAsteriskToken();
+
+                case 43 /* plus */:
+                    return this.scanPlusToken();
+
+                case 37 /* percent */:
+                    return this.scanPercentToken();
+
+                case 38 /* ampersand */:
+                    return this.scanAmpersandToken();
+
+                case 94 /* caret */:
+                    return this.scanCaretToken();
+
+                case 60 /* lessThan */:
+                    return this.scanLessThanToken();
+
+                case 62 /* greaterThan */:
+                    return this.advanceAndSetTokenKind(81 /* GreaterThanToken */);
+
+                case 44 /* comma */:
+                    return this.advanceAndSetTokenKind(79 /* CommaToken */);
+
+                case 58 /* colon */:
+                    return this.advanceAndSetTokenKind(106 /* ColonToken */);
+
+                case 59 /* semicolon */:
+                    return this.advanceAndSetTokenKind(78 /* SemicolonToken */);
+
+                case 126 /* tilde */:
+                    return this.advanceAndSetTokenKind(102 /* TildeToken */);
+
+                case 40 /* openParen */:
+                    return this.advanceAndSetTokenKind(72 /* OpenParenToken */);
+
+                case 41 /* closeParen */:
+                    return this.advanceAndSetTokenKind(73 /* CloseParenToken */);
+
+                case 123 /* openBrace */:
+                    return this.advanceAndSetTokenKind(70 /* OpenBraceToken */);
+
+                case 125 /* closeBrace */:
+                    return this.advanceAndSetTokenKind(71 /* CloseBraceToken */);
+
+                case 91 /* openBracket */:
+                    return this.advanceAndSetTokenKind(74 /* OpenBracketToken */);
+
+                case 93 /* closeBracket */:
+                    return this.advanceAndSetTokenKind(75 /* CloseBracketToken */);
+
+                case 63 /* question */:
+                    return this.advanceAndSetTokenKind(105 /* QuestionToken */);
+            }
+
+            if (isNumericLiteralStart[character]) {
+                return this.scanNumericLiteral(diagnostics);
+            }
+
+            if (isIdentifierStartCharacter[character]) {
+                var result = this.tryFastScanIdentifierOrKeyword(character);
+                if (result !== 0 /* None */) {
+                    return result;
+                }
+            }
+
+            if (this.isIdentifierStart(this.peekCharOrUnicodeEscape())) {
+                return this.slowScanIdentifierOrKeyword(diagnostics);
+            }
+
+            return this.scanDefaultCharacter(character, diagnostics);
+        };
+
+        Scanner.prototype.isIdentifierStart = function (interpretedChar) {
+            if (isIdentifierStartCharacter[interpretedChar]) {
+                return true;
+            }
+
+            return interpretedChar > 127 /* maxAsciiCharacter */ && TypeScript.Unicode.isIdentifierStart(interpretedChar, this._languageVersion);
+        };
+
+        Scanner.prototype.isIdentifierPart = function (interpretedChar) {
+            if (isIdentifierPartCharacter[interpretedChar]) {
+                return true;
+            }
+
+            return interpretedChar > 127 /* maxAsciiCharacter */ && TypeScript.Unicode.isIdentifierPart(interpretedChar, this._languageVersion);
+        };
+
+        Scanner.prototype.tryFastScanIdentifierOrKeyword = function (firstCharacter) {
+            var slidingWindow = this.slidingWindow;
+            var window = slidingWindow.window;
+
+            var startIndex = slidingWindow.currentRelativeItemIndex;
+            var endIndex = slidingWindow.windowCount;
+            var currentIndex = startIndex;
+            var character = 0;
+
+            while (currentIndex < endIndex) {
+                character = window[currentIndex];
+                if (!isIdentifierPartCharacter[character]) {
+                    break;
+                }
+
+                currentIndex++;
+            }
+
+            if (currentIndex === endIndex) {
+                return 0 /* None */;
+            } else if (character === 92 /* backslash */ || character > 127 /* maxAsciiCharacter */) {
+                return 0 /* None */;
+            } else {
+                var kind;
+                var identifierLength = currentIndex - startIndex;
+                if (isKeywordStartCharacter[firstCharacter]) {
+                    kind = TypeScript.ScannerUtilities.identifierKind(window, startIndex, identifierLength);
+                } else {
+                    kind = 11 /* IdentifierName */;
+                }
+
+                slidingWindow.setAbsoluteIndex(slidingWindow.absoluteIndex() + identifierLength);
+
+                return kind;
+            }
+        };
+
+        Scanner.prototype.slowScanIdentifierOrKeyword = function (diagnostics) {
+            var startIndex = this.slidingWindow.absoluteIndex();
+            var sawUnicodeEscape = false;
+
+            do {
+                var unicodeEscape = this.scanCharOrUnicodeEscape(diagnostics);
+                sawUnicodeEscape = sawUnicodeEscape || unicodeEscape;
+            } while(this.isIdentifierPart(this.peekCharOrUnicodeEscape()));
+
+            var length = this.slidingWindow.absoluteIndex() - startIndex;
+            var text = this.text.substr(startIndex, length, false);
+            var valueText = TypeScript.Syntax.massageEscapes(text);
+
+            var keywordKind = TypeScript.SyntaxFacts.getTokenKind(valueText);
+            if (keywordKind >= 15 /* FirstKeyword */ && keywordKind <= 69 /* LastKeyword */) {
+                if (sawUnicodeEscape) {
+                    return keywordKind | -2147483648 /* IsVariableWidthKeyword */;
+                } else {
+                    return keywordKind;
+                }
+            }
+
+            return 11 /* IdentifierName */;
+        };
+
+        Scanner.prototype.scanNumericLiteral = function (diagnostics) {
+            if (this.isHexNumericLiteral()) {
+                this.scanHexNumericLiteral();
+            } else if (this.isOctalNumericLiteral()) {
+                this.scanOctalNumericLiteral(diagnostics);
+            } else {
+                this.scanDecimalNumericLiteral();
+            }
+
+            return 13 /* NumericLiteral */;
+        };
+
+        Scanner.prototype.isOctalNumericLiteral = function () {
+            return this.currentCharCode() === 48 /* _0 */ && TypeScript.CharacterInfo.isOctalDigit(this.slidingWindow.peekItemN(1));
+        };
+
+        Scanner.prototype.scanOctalNumericLiteral = function (diagnostics) {
+            var position = this.absoluteIndex();
+
+            while (TypeScript.CharacterInfo.isOctalDigit(this.currentCharCode())) {
+                this.slidingWindow.moveToNextItem();
+            }
+
+            if (this.languageVersion() >= 1 /* EcmaScript5 */) {
+                diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), position, this.absoluteIndex() - position, TypeScript.DiagnosticCode.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher, null));
+            }
+        };
+
+        Scanner.prototype.scanDecimalDigits = function () {
+            while (TypeScript.CharacterInfo.isDecimalDigit(this.currentCharCode())) {
+                this.slidingWindow.moveToNextItem();
+            }
+        };
+
+        Scanner.prototype.scanDecimalNumericLiteral = function () {
+            this.scanDecimalDigits();
+
+            if (this.currentCharCode() === 46 /* dot */) {
+                this.slidingWindow.moveToNextItem();
+            }
+
+            this.scanDecimalDigits();
+
+            var ch = this.currentCharCode();
+            if (ch === 101 /* e */ || ch === 69 /* E */) {
+                var nextChar1 = this.slidingWindow.peekItemN(1);
+
+                if (TypeScript.CharacterInfo.isDecimalDigit(nextChar1)) {
+                    this.slidingWindow.moveToNextItem();
+                    this.scanDecimalDigits();
+                } else if (nextChar1 === 45 /* minus */ || nextChar1 === 43 /* plus */) {
+                    var nextChar2 = this.slidingWindow.peekItemN(2);
+                    if (TypeScript.CharacterInfo.isDecimalDigit(nextChar2)) {
+                        this.slidingWindow.moveToNextItem();
+                        this.slidingWindow.moveToNextItem();
+                        this.scanDecimalDigits();
+                    }
+                }
+            }
+        };
+
+        Scanner.prototype.scanHexNumericLiteral = function () {
+            this.slidingWindow.moveToNextItem();
+            this.slidingWindow.moveToNextItem();
+
+            while (TypeScript.CharacterInfo.isHexDigit(this.currentCharCode())) {
+                this.slidingWindow.moveToNextItem();
+            }
+        };
+
+        Scanner.prototype.isHexNumericLiteral = function () {
+            if (this.currentCharCode() === 48 /* _0 */) {
+                var ch = this.slidingWindow.peekItemN(1);
+
+                if (ch === 120 /* x */ || ch === 88 /* X */) {
+                    ch = this.slidingWindow.peekItemN(2);
+
+                    return TypeScript.CharacterInfo.isHexDigit(ch);
+                }
+            }
+
+            return false;
+        };
+
+        Scanner.prototype.advanceAndSetTokenKind = function (kind) {
+            this.slidingWindow.moveToNextItem();
+            return kind;
+        };
+
+        Scanner.prototype.scanLessThanToken = function () {
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 82 /* LessThanEqualsToken */;
+            } else if (this.currentCharCode() === 60 /* lessThan */) {
+                this.slidingWindow.moveToNextItem();
+                if (this.currentCharCode() === 61 /* equals */) {
+                    this.slidingWindow.moveToNextItem();
+                    return 112 /* LessThanLessThanEqualsToken */;
+                } else {
+                    return 95 /* LessThanLessThanToken */;
+                }
+            } else {
+                return 80 /* LessThanToken */;
+            }
+        };
+
+        Scanner.prototype.scanBarToken = function () {
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 116 /* BarEqualsToken */;
+            } else if (this.currentCharCode() === 124 /* bar */) {
+                this.slidingWindow.moveToNextItem();
+                return 104 /* BarBarToken */;
+            } else {
+                return 99 /* BarToken */;
+            }
+        };
+
+        Scanner.prototype.scanCaretToken = function () {
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 117 /* CaretEqualsToken */;
+            } else {
+                return 100 /* CaretToken */;
+            }
+        };
+
+        Scanner.prototype.scanAmpersandToken = function () {
+            this.slidingWindow.moveToNextItem();
+            var character = this.currentCharCode();
+            if (character === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 115 /* AmpersandEqualsToken */;
+            } else if (this.currentCharCode() === 38 /* ampersand */) {
+                this.slidingWindow.moveToNextItem();
+                return 103 /* AmpersandAmpersandToken */;
+            } else {
+                return 98 /* AmpersandToken */;
+            }
+        };
+
+        Scanner.prototype.scanPercentToken = function () {
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 111 /* PercentEqualsToken */;
+            } else {
+                return 92 /* PercentToken */;
+            }
+        };
+
+        Scanner.prototype.scanMinusToken = function () {
+            this.slidingWindow.moveToNextItem();
+            var character = this.currentCharCode();
+
+            if (character === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 109 /* MinusEqualsToken */;
+            } else if (character === 45 /* minus */) {
+                this.slidingWindow.moveToNextItem();
+                return 94 /* MinusMinusToken */;
+            } else {
+                return 90 /* MinusToken */;
+            }
+        };
+
+        Scanner.prototype.scanPlusToken = function () {
+            this.slidingWindow.moveToNextItem();
+            var character = this.currentCharCode();
+            if (character === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 108 /* PlusEqualsToken */;
+            } else if (character === 43 /* plus */) {
+                this.slidingWindow.moveToNextItem();
+                return 93 /* PlusPlusToken */;
+            } else {
+                return 89 /* PlusToken */;
+            }
+        };
+
+        Scanner.prototype.scanAsteriskToken = function () {
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 110 /* AsteriskEqualsToken */;
+            } else {
+                return 91 /* AsteriskToken */;
+            }
+        };
+
+        Scanner.prototype.scanEqualsToken = function () {
+            this.slidingWindow.moveToNextItem();
+            var character = this.currentCharCode();
+            if (character === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+
+                if (this.currentCharCode() === 61 /* equals */) {
+                    this.slidingWindow.moveToNextItem();
+
+                    return 87 /* EqualsEqualsEqualsToken */;
+                } else {
+                    return 84 /* EqualsEqualsToken */;
+                }
+            } else if (character === 62 /* greaterThan */) {
+                this.slidingWindow.moveToNextItem();
+                return 85 /* EqualsGreaterThanToken */;
+            } else {
+                return 107 /* EqualsToken */;
+            }
+        };
+
+        Scanner.prototype.isDotPrefixedNumericLiteral = function () {
+            if (this.currentCharCode() === 46 /* dot */) {
+                var ch = this.slidingWindow.peekItemN(1);
+                return TypeScript.CharacterInfo.isDecimalDigit(ch);
+            }
+
+            return false;
+        };
+
+        Scanner.prototype.scanDotToken = function (diagnostics) {
+            if (this.isDotPrefixedNumericLiteral()) {
+                return this.scanNumericLiteral(diagnostics);
+            }
+
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 46 /* dot */ && this.slidingWindow.peekItemN(1) === 46 /* dot */) {
+                this.slidingWindow.moveToNextItem();
+                this.slidingWindow.moveToNextItem();
+                return 77 /* DotDotDotToken */;
+            } else {
+                return 76 /* DotToken */;
+            }
+        };
+
+        Scanner.prototype.scanSlashToken = function (allowRegularExpression) {
+            if (allowRegularExpression) {
+                var result = this.tryScanRegularExpressionToken();
+                if (result !== 0 /* None */) {
+                    return result;
+                }
+            }
+
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 119 /* SlashEqualsToken */;
+            } else {
+                return 118 /* SlashToken */;
+            }
+        };
+
+        Scanner.prototype.tryScanRegularExpressionToken = function () {
+            var startIndex = this.slidingWindow.getAndPinAbsoluteIndex();
+
+            this.slidingWindow.moveToNextItem();
+
+            var inEscape = false;
+            var inCharacterClass = false;
+            while (true) {
+                var ch = this.currentCharCode();
+
+                if (this.isNewLineCharacter(ch) || this.slidingWindow.isAtEndOfSource()) {
+                    this.slidingWindow.rewindToPinnedIndex(startIndex);
+                    this.slidingWindow.releaseAndUnpinAbsoluteIndex(startIndex);
+                    return 0 /* None */;
+                }
+
+                this.slidingWindow.moveToNextItem();
+                if (inEscape) {
+                    inEscape = false;
+                    continue;
+                }
+
+                switch (ch) {
+                    case 92 /* backslash */:
+                        inEscape = true;
+                        continue;
+
+                    case 91 /* openBracket */:
+                        inCharacterClass = true;
+                        continue;
+
+                    case 93 /* closeBracket */:
+                        inCharacterClass = false;
+                        continue;
+
+                    case 47 /* slash */:
+                        if (inCharacterClass) {
+                            continue;
+                        }
+
+                        break;
+
+                    default:
+                        continue;
+                }
+
+                break;
+            }
+
+            while (isIdentifierPartCharacter[this.currentCharCode()]) {
+                this.slidingWindow.moveToNextItem();
+            }
+
+            this.slidingWindow.releaseAndUnpinAbsoluteIndex(startIndex);
+            return 12 /* RegularExpressionLiteral */;
+        };
+
+        Scanner.prototype.scanExclamationToken = function () {
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+
+                if (this.currentCharCode() === 61 /* equals */) {
+                    this.slidingWindow.moveToNextItem();
+
+                    return 88 /* ExclamationEqualsEqualsToken */;
+                } else {
+                    return 86 /* ExclamationEqualsToken */;
+                }
+            } else {
+                return 101 /* ExclamationToken */;
+            }
+        };
+
+        Scanner.prototype.scanDefaultCharacter = function (character, diagnostics) {
+            var position = this.slidingWindow.absoluteIndex();
+            this.slidingWindow.moveToNextItem();
+
+            var text = String.fromCharCode(character);
+            var messageText = this.getErrorMessageText(text);
+            diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), position, 1, TypeScript.DiagnosticCode.Unexpected_character_0, [messageText]));
+
+            return 9 /* ErrorToken */;
+        };
+
+        Scanner.prototype.getErrorMessageText = function (text) {
+            if (text === "\\") {
+                return '"\\"';
+            }
+
+            return JSON.stringify(text);
+        };
+
+        Scanner.prototype.skipEscapeSequence = function (diagnostics) {
+            var rewindPoint = this.slidingWindow.getAndPinAbsoluteIndex();
+
+            this.slidingWindow.moveToNextItem();
+
+            var ch = this.currentCharCode();
+            this.slidingWindow.moveToNextItem();
+            switch (ch) {
+                case 120 /* x */:
+                case 117 /* u */:
+                    this.slidingWindow.rewindToPinnedIndex(rewindPoint);
+                    var value = this.scanUnicodeOrHexEscape(diagnostics);
+                    break;
+
+                case 13 /* carriageReturn */:
+                    if (this.currentCharCode() === 10 /* lineFeed */) {
+                        this.slidingWindow.moveToNextItem();
+                    }
+                    break;
+
+                default:
+                    break;
+            }
+
+            this.slidingWindow.releaseAndUnpinAbsoluteIndex(rewindPoint);
+        };
+
+        Scanner.prototype.scanStringLiteral = function (diagnostics) {
+            var quoteCharacter = this.currentCharCode();
+
+            this.slidingWindow.moveToNextItem();
+
+            while (true) {
+                var ch = this.currentCharCode();
+                if (ch === 92 /* backslash */) {
+                    this.skipEscapeSequence(diagnostics);
+                } else if (ch === quoteCharacter) {
+                    this.slidingWindow.moveToNextItem();
+                    break;
+                } else if (this.isNewLineCharacter(ch) || this.slidingWindow.isAtEndOfSource()) {
+                    diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), TypeScript.MathPrototype.min(this.slidingWindow.absoluteIndex(), this.text.length()), 1, TypeScript.DiagnosticCode.Missing_close_quote_character, null));
+                    break;
+                } else {
+                    this.slidingWindow.moveToNextItem();
+                }
+            }
+
+            return 14 /* StringLiteral */;
+        };
+
+        Scanner.prototype.isUnicodeEscape = function (character) {
+            if (character === 92 /* backslash */) {
+                var ch2 = this.slidingWindow.peekItemN(1);
+                if (ch2 === 117 /* u */) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        Scanner.prototype.peekCharOrUnicodeEscape = function () {
+            var character = this.currentCharCode();
+            if (this.isUnicodeEscape(character)) {
+                return this.peekUnicodeOrHexEscape();
+            } else {
+                return character;
+            }
+        };
+
+        Scanner.prototype.peekUnicodeOrHexEscape = function () {
+            var startIndex = this.slidingWindow.getAndPinAbsoluteIndex();
+
+            var ch = this.scanUnicodeOrHexEscape(null);
+
+            this.slidingWindow.rewindToPinnedIndex(startIndex);
+            this.slidingWindow.releaseAndUnpinAbsoluteIndex(startIndex);
+
+            return ch;
+        };
+
+        Scanner.prototype.scanCharOrUnicodeEscape = function (errors) {
+            var ch = this.currentCharCode();
+            if (ch === 92 /* backslash */) {
+                var ch2 = this.slidingWindow.peekItemN(1);
+                if (ch2 === 117 /* u */) {
+                    this.scanUnicodeOrHexEscape(errors);
+                    return true;
+                }
+            }
+
+            this.slidingWindow.moveToNextItem();
+            return false;
+        };
+
+        Scanner.prototype.scanUnicodeOrHexEscape = function (errors) {
+            var start = this.slidingWindow.absoluteIndex();
+            var character = this.currentCharCode();
+
+            this.slidingWindow.moveToNextItem();
+
+            character = this.currentCharCode();
+
+            var intChar = 0;
+            this.slidingWindow.moveToNextItem();
+
+            var count = character === 117 /* u */ ? 4 : 2;
+
+            for (var i = 0; i < count; i++) {
+                var ch2 = this.currentCharCode();
+                if (!TypeScript.CharacterInfo.isHexDigit(ch2)) {
+                    if (errors !== null) {
+                        var end = this.slidingWindow.absoluteIndex();
+                        var info = this.createIllegalEscapeDiagnostic(start, end);
+                        errors.push(info);
+                    }
+
+                    break;
+                }
+
+                intChar = (intChar << 4) + TypeScript.CharacterInfo.hexValue(ch2);
+                this.slidingWindow.moveToNextItem();
+            }
+
+            return intChar;
+        };
+
+        Scanner.prototype.substring = function (start, end, intern) {
+            var length = end - start;
+            var offset = start - this.slidingWindow.windowAbsoluteStartIndex;
+
+            if (intern) {
+                return TypeScript.Collections.DefaultStringTable.addCharArray(this.slidingWindow.window, offset, length);
+            } else {
+                return TypeScript.StringUtilities.fromCharCodeArray(this.slidingWindow.window.slice(offset, offset + length));
+            }
+        };
+
+        Scanner.prototype.createIllegalEscapeDiagnostic = function (start, end) {
+            return new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), start, end - start, TypeScript.DiagnosticCode.Unrecognized_escape_sequence, null);
+        };
+
+        Scanner.isValidIdentifier = function (text, languageVersion) {
+            var scanner = new Scanner(null, text, languageVersion, Scanner.triviaWindow);
+            var errors = new Array();
+            var token = scanner.scan(errors, false);
+
+            return errors.length === 0 && TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token) && token.width() === text.length();
+        };
+        Scanner.triviaWindow = TypeScript.ArrayUtilities.createArray(2048, 0);
+        return Scanner;
+    })();
+    TypeScript.Scanner = Scanner;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var ScannerUtilities = (function () {
+        function ScannerUtilities() {
+        }
+        ScannerUtilities.identifierKind = function (array, startIndex, length) {
+            switch (length) {
+                case 2:
+                    switch (array[startIndex]) {
+                        case 100 /* d */:
+                            return (array[startIndex + 1] === 111 /* o */) ? 22 /* DoKeyword */ : 11 /* IdentifierName */;
+                        case 105 /* i */:
+                            switch (array[startIndex + 1]) {
+                                case 102 /* f */:
+                                    return 28 /* IfKeyword */;
+                                case 110 /* n */:
+                                    return 29 /* InKeyword */;
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 3:
+                    switch (array[startIndex]) {
+                        case 102 /* f */:
+                            return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 114 /* r */) ? 26 /* ForKeyword */ : 11 /* IdentifierName */;
+                        case 110 /* n */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 119 /* w */) ? 31 /* NewKeyword */ : 11 /* IdentifierName */;
+                        case 116 /* t */:
+                            return (array[startIndex + 1] === 114 /* r */ && array[startIndex + 2] === 121 /* y */) ? 38 /* TryKeyword */ : 11 /* IdentifierName */;
+                        case 118 /* v */:
+                            return (array[startIndex + 1] === 97 /* a */ && array[startIndex + 2] === 114 /* r */) ? 40 /* VarKeyword */ : 11 /* IdentifierName */;
+                        case 108 /* l */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */) ? 53 /* LetKeyword */ : 11 /* IdentifierName */;
+                        case 97 /* a */:
+                            return (array[startIndex + 1] === 110 /* n */ && array[startIndex + 2] === 121 /* y */) ? 60 /* AnyKeyword */ : 11 /* IdentifierName */;
+                        case 103 /* g */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */) ? 64 /* GetKeyword */ : 11 /* IdentifierName */;
+                        case 115 /* s */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */) ? 68 /* SetKeyword */ : 11 /* IdentifierName */;
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 4:
+                    switch (array[startIndex]) {
+                        case 99 /* c */:
+                            return (array[startIndex + 1] === 97 /* a */ && array[startIndex + 2] === 115 /* s */ && array[startIndex + 3] === 101 /* e */) ? 16 /* CaseKeyword */ : 11 /* IdentifierName */;
+                        case 101 /* e */:
+                            switch (array[startIndex + 1]) {
+                                case 108 /* l */:
+                                    return (array[startIndex + 2] === 115 /* s */ && array[startIndex + 3] === 101 /* e */) ? 23 /* ElseKeyword */ : 11 /* IdentifierName */;
+                                case 110 /* n */:
+                                    return (array[startIndex + 2] === 117 /* u */ && array[startIndex + 3] === 109 /* m */) ? 46 /* EnumKeyword */ : 11 /* IdentifierName */;
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        case 110 /* n */:
+                            return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 108 /* l */ && array[startIndex + 3] === 108 /* l */) ? 32 /* NullKeyword */ : 11 /* IdentifierName */;
+                        case 116 /* t */:
+                            switch (array[startIndex + 1]) {
+                                case 104 /* h */:
+                                    return (array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 115 /* s */) ? 35 /* ThisKeyword */ : 11 /* IdentifierName */;
+                                case 114 /* r */:
+                                    return (array[startIndex + 2] === 117 /* u */ && array[startIndex + 3] === 101 /* e */) ? 37 /* TrueKeyword */ : 11 /* IdentifierName */;
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        case 118 /* v */:
+                            return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 100 /* d */) ? 41 /* VoidKeyword */ : 11 /* IdentifierName */;
+                        case 119 /* w */:
+                            return (array[startIndex + 1] === 105 /* i */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 104 /* h */) ? 43 /* WithKeyword */ : 11 /* IdentifierName */;
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 5:
+                    switch (array[startIndex]) {
+                        case 98 /* b */:
+                            return (array[startIndex + 1] === 114 /* r */ && array[startIndex + 2] === 101 /* e */ && array[startIndex + 3] === 97 /* a */ && array[startIndex + 4] === 107 /* k */) ? 15 /* BreakKeyword */ : 11 /* IdentifierName */;
+                        case 99 /* c */:
+                            switch (array[startIndex + 1]) {
+                                case 97 /* a */:
+                                    return (array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 99 /* c */ && array[startIndex + 4] === 104 /* h */) ? 17 /* CatchKeyword */ : 11 /* IdentifierName */;
+                                case 108 /* l */:
+                                    return (array[startIndex + 2] === 97 /* a */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 115 /* s */) ? 44 /* ClassKeyword */ : 11 /* IdentifierName */;
+                                case 111 /* o */:
+                                    return (array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 116 /* t */) ? 45 /* ConstKeyword */ : 11 /* IdentifierName */;
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        case 102 /* f */:
+                            return (array[startIndex + 1] === 97 /* a */ && array[startIndex + 2] === 108 /* l */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 101 /* e */) ? 24 /* FalseKeyword */ : 11 /* IdentifierName */;
+                        case 116 /* t */:
+                            return (array[startIndex + 1] === 104 /* h */ && array[startIndex + 2] === 114 /* r */ && array[startIndex + 3] === 111 /* o */ && array[startIndex + 4] === 119 /* w */) ? 36 /* ThrowKeyword */ : 11 /* IdentifierName */;
+                        case 119 /* w */:
+                            return (array[startIndex + 1] === 104 /* h */ && array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 101 /* e */) ? 42 /* WhileKeyword */ : 11 /* IdentifierName */;
+                        case 115 /* s */:
+                            return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 114 /* r */) ? 50 /* SuperKeyword */ : 11 /* IdentifierName */;
+                        case 121 /* y */:
+                            return (array[startIndex + 1] === 105 /* i */ && array[startIndex + 2] === 101 /* e */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 100 /* d */) ? 59 /* YieldKeyword */ : 11 /* IdentifierName */;
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 6:
+                    switch (array[startIndex]) {
+                        case 100 /* d */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 108 /* l */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 116 /* t */ && array[startIndex + 5] === 101 /* e */) ? 21 /* DeleteKeyword */ : 11 /* IdentifierName */;
+                        case 114 /* r */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 110 /* n */) ? 33 /* ReturnKeyword */ : 11 /* IdentifierName */;
+                        case 115 /* s */:
+                            switch (array[startIndex + 1]) {
+                                case 119 /* w */:
+                                    return (array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 99 /* c */ && array[startIndex + 5] === 104 /* h */) ? 34 /* SwitchKeyword */ : 11 /* IdentifierName */;
+                                case 116 /* t */:
+                                    switch (array[startIndex + 2]) {
+                                        case 97 /* a */:
+                                            return (array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 99 /* c */) ? 58 /* StaticKeyword */ : 11 /* IdentifierName */;
+                                        case 114 /* r */:
+                                            return (array[startIndex + 3] === 105 /* i */ && array[startIndex + 4] === 110 /* n */ && array[startIndex + 5] === 103 /* g */) ? 69 /* StringKeyword */ : 11 /* IdentifierName */;
+                                        default:
+                                            return 11 /* IdentifierName */;
+                                    }
+
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        case 116 /* t */:
+                            return (array[startIndex + 1] === 121 /* y */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 111 /* o */ && array[startIndex + 5] === 102 /* f */) ? 39 /* TypeOfKeyword */ : 11 /* IdentifierName */;
+                        case 101 /* e */:
+                            return (array[startIndex + 1] === 120 /* x */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 111 /* o */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 116 /* t */) ? 47 /* ExportKeyword */ : 11 /* IdentifierName */;
+                        case 105 /* i */:
+                            return (array[startIndex + 1] === 109 /* m */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 111 /* o */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 116 /* t */) ? 49 /* ImportKeyword */ : 11 /* IdentifierName */;
+                        case 112 /* p */:
+                            return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 98 /* b */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 99 /* c */) ? 57 /* PublicKeyword */ : 11 /* IdentifierName */;
+                        case 109 /* m */:
+                            return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 100 /* d */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 108 /* l */ && array[startIndex + 5] === 101 /* e */) ? 65 /* ModuleKeyword */ : 11 /* IdentifierName */;
+                        case 110 /* n */:
+                            return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 109 /* m */ && array[startIndex + 3] === 98 /* b */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 114 /* r */) ? 67 /* NumberKeyword */ : 11 /* IdentifierName */;
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 7:
+                    switch (array[startIndex]) {
+                        case 100 /* d */:
+                            switch (array[startIndex + 1]) {
+                                case 101 /* e */:
+                                    switch (array[startIndex + 2]) {
+                                        case 102 /* f */:
+                                            return (array[startIndex + 3] === 97 /* a */ && array[startIndex + 4] === 117 /* u */ && array[startIndex + 5] === 108 /* l */ && array[startIndex + 6] === 116 /* t */) ? 20 /* DefaultKeyword */ : 11 /* IdentifierName */;
+                                        case 99 /* c */:
+                                            return (array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 114 /* r */ && array[startIndex + 6] === 101 /* e */) ? 63 /* DeclareKeyword */ : 11 /* IdentifierName */;
+                                        default:
+                                            return 11 /* IdentifierName */;
+                                    }
+
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        case 102 /* f */:
+                            return (array[startIndex + 1] === 105 /* i */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 97 /* a */ && array[startIndex + 4] === 108 /* l */ && array[startIndex + 5] === 108 /* l */ && array[startIndex + 6] === 121 /* y */) ? 25 /* FinallyKeyword */ : 11 /* IdentifierName */;
+                        case 101 /* e */:
+                            return (array[startIndex + 1] === 120 /* x */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 110 /* n */ && array[startIndex + 5] === 100 /* d */ && array[startIndex + 6] === 115 /* s */) ? 48 /* ExtendsKeyword */ : 11 /* IdentifierName */;
+                        case 112 /* p */:
+                            switch (array[startIndex + 1]) {
+                                case 97 /* a */:
+                                    return (array[startIndex + 2] === 99 /* c */ && array[startIndex + 3] === 107 /* k */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 103 /* g */ && array[startIndex + 6] === 101 /* e */) ? 54 /* PackageKeyword */ : 11 /* IdentifierName */;
+                                case 114 /* r */:
+                                    return (array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 118 /* v */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 116 /* t */ && array[startIndex + 6] === 101 /* e */) ? 55 /* PrivateKeyword */ : 11 /* IdentifierName */;
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        case 98 /* b */:
+                            return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 111 /* o */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 97 /* a */ && array[startIndex + 6] === 110 /* n */) ? 61 /* BooleanKeyword */ : 11 /* IdentifierName */;
+                        case 114 /* r */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 113 /* q */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 114 /* r */ && array[startIndex + 6] === 101 /* e */) ? 66 /* RequireKeyword */ : 11 /* IdentifierName */;
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 8:
+                    switch (array[startIndex]) {
+                        case 99 /* c */:
+                            return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 110 /* n */ && array[startIndex + 6] === 117 /* u */ && array[startIndex + 7] === 101 /* e */) ? 18 /* ContinueKeyword */ : 11 /* IdentifierName */;
+                        case 100 /* d */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 98 /* b */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 103 /* g */ && array[startIndex + 5] === 103 /* g */ && array[startIndex + 6] === 101 /* e */ && array[startIndex + 7] === 114 /* r */) ? 19 /* DebuggerKeyword */ : 11 /* IdentifierName */;
+                        case 102 /* f */:
+                            return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 99 /* c */ && array[startIndex + 4] === 116 /* t */ && array[startIndex + 5] === 105 /* i */ && array[startIndex + 6] === 111 /* o */ && array[startIndex + 7] === 110 /* n */) ? 27 /* FunctionKeyword */ : 11 /* IdentifierName */;
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 9:
+                    switch (array[startIndex]) {
+                        case 105 /* i */:
+                            return (array[startIndex + 1] === 110 /* n */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 102 /* f */ && array[startIndex + 6] === 97 /* a */ && array[startIndex + 7] === 99 /* c */ && array[startIndex + 8] === 101 /* e */) ? 52 /* InterfaceKeyword */ : 11 /* IdentifierName */;
+                        case 112 /* p */:
+                            return (array[startIndex + 1] === 114 /* r */ && array[startIndex + 2] === 111 /* o */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 99 /* c */ && array[startIndex + 6] === 116 /* t */ && array[startIndex + 7] === 101 /* e */ && array[startIndex + 8] === 100 /* d */) ? 56 /* ProtectedKeyword */ : 11 /* IdentifierName */;
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 10:
+                    switch (array[startIndex]) {
+                        case 105 /* i */:
+                            switch (array[startIndex + 1]) {
+                                case 110 /* n */:
+                                    return (array[startIndex + 2] === 115 /* s */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 110 /* n */ && array[startIndex + 6] === 99 /* c */ && array[startIndex + 7] === 101 /* e */ && array[startIndex + 8] === 111 /* o */ && array[startIndex + 9] === 102 /* f */) ? 30 /* InstanceOfKeyword */ : 11 /* IdentifierName */;
+                                case 109 /* m */:
+                                    return (array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 109 /* m */ && array[startIndex + 6] === 101 /* e */ && array[startIndex + 7] === 110 /* n */ && array[startIndex + 8] === 116 /* t */ && array[startIndex + 9] === 115 /* s */) ? 51 /* ImplementsKeyword */ : 11 /* IdentifierName */;
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 11:
+                    return (array[startIndex] === 99 /* c */ && array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 116 /* t */ && array[startIndex + 5] === 114 /* r */ && array[startIndex + 6] === 117 /* u */ && array[startIndex + 7] === 99 /* c */ && array[startIndex + 8] === 116 /* t */ && array[startIndex + 9] === 111 /* o */ && array[startIndex + 10] === 114 /* r */) ? 62 /* ConstructorKeyword */ : 11 /* IdentifierName */;
+                default:
+                    return 11 /* IdentifierName */;
+            }
+        };
+        return ScannerUtilities;
+    })();
+    TypeScript.ScannerUtilities = ScannerUtilities;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        var EmptySeparatedSyntaxList = (function () {
+            function EmptySeparatedSyntaxList() {
+            }
+            EmptySeparatedSyntaxList.prototype.kind = function () {
+                return 2 /* SeparatedList */;
+            };
+
+            EmptySeparatedSyntaxList.prototype.isNode = function () {
+                return false;
+            };
+
+            EmptySeparatedSyntaxList.prototype.isToken = function () {
+                return false;
+            };
+
+            EmptySeparatedSyntaxList.prototype.isList = function () {
+                return false;
+            };
+
+            EmptySeparatedSyntaxList.prototype.isSeparatedList = function () {
+                return true;
+            };
+
+            EmptySeparatedSyntaxList.prototype.toJSON = function (key) {
+                return [];
+            };
+
+            EmptySeparatedSyntaxList.prototype.childCount = function () {
+                return 0;
+            };
+
+            EmptySeparatedSyntaxList.prototype.nonSeparatorCount = function () {
+                return 0;
+            };
+
+            EmptySeparatedSyntaxList.prototype.separatorCount = function () {
+                return 0;
+            };
+
+            EmptySeparatedSyntaxList.prototype.toArray = function () {
+                return [];
+            };
+
+            EmptySeparatedSyntaxList.prototype.toNonSeparatorArray = function () {
+                return [];
+            };
+
+            EmptySeparatedSyntaxList.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            };
+
+            EmptySeparatedSyntaxList.prototype.nonSeparatorAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            };
+
+            EmptySeparatedSyntaxList.prototype.separatorAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            };
+
+            EmptySeparatedSyntaxList.prototype.collectTextElements = function (elements) {
+            };
+
+            EmptySeparatedSyntaxList.prototype.firstToken = function () {
+                return null;
+            };
+
+            EmptySeparatedSyntaxList.prototype.lastToken = function () {
+                return null;
+            };
+
+            EmptySeparatedSyntaxList.prototype.fullWidth = function () {
+                return 0;
+            };
+
+            EmptySeparatedSyntaxList.prototype.fullText = function () {
+                return "";
+            };
+
+            EmptySeparatedSyntaxList.prototype.width = function () {
+                return 0;
+            };
+
+            EmptySeparatedSyntaxList.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+
+            EmptySeparatedSyntaxList.prototype.isIncrementallyUnusable = function () {
+                return false;
+            };
+
+            EmptySeparatedSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) {
+                throw TypeScript.Errors.invalidOperation();
+            };
+
+            EmptySeparatedSyntaxList.prototype.insertChildrenInto = function (array, index) {
+            };
+
+            EmptySeparatedSyntaxList.prototype.leadingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            EmptySeparatedSyntaxList.prototype.trailingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            EmptySeparatedSyntaxList.prototype.leadingTriviaWidth = function () {
+                return 0;
+            };
+
+            EmptySeparatedSyntaxList.prototype.trailingTriviaWidth = function () {
+                return 0;
+            };
+            return EmptySeparatedSyntaxList;
+        })();
+
+        Syntax.emptySeparatedList = new EmptySeparatedSyntaxList();
+
+        var SingletonSeparatedSyntaxList = (function () {
+            function SingletonSeparatedSyntaxList(item) {
+                this.item = item;
+            }
+            SingletonSeparatedSyntaxList.prototype.toJSON = function (key) {
+                return [this.item];
+            };
+
+            SingletonSeparatedSyntaxList.prototype.kind = function () {
+                return 2 /* SeparatedList */;
+            };
+
+            SingletonSeparatedSyntaxList.prototype.isNode = function () {
+                return false;
+            };
+            SingletonSeparatedSyntaxList.prototype.isToken = function () {
+                return false;
+            };
+            SingletonSeparatedSyntaxList.prototype.isList = function () {
+                return false;
+            };
+            SingletonSeparatedSyntaxList.prototype.isSeparatedList = function () {
+                return true;
+            };
+
+            SingletonSeparatedSyntaxList.prototype.childCount = function () {
+                return 1;
+            };
+            SingletonSeparatedSyntaxList.prototype.nonSeparatorCount = function () {
+                return 1;
+            };
+            SingletonSeparatedSyntaxList.prototype.separatorCount = function () {
+                return 0;
+            };
+
+            SingletonSeparatedSyntaxList.prototype.toArray = function () {
+                return [this.item];
+            };
+            SingletonSeparatedSyntaxList.prototype.toNonSeparatorArray = function () {
+                return [this.item];
+            };
+
+            SingletonSeparatedSyntaxList.prototype.childAt = function (index) {
+                if (index !== 0) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.item;
+            };
+
+            SingletonSeparatedSyntaxList.prototype.nonSeparatorAt = function (index) {
+                if (index !== 0) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.item;
+            };
+
+            SingletonSeparatedSyntaxList.prototype.separatorAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            };
+
+            SingletonSeparatedSyntaxList.prototype.collectTextElements = function (elements) {
+                this.item.collectTextElements(elements);
+            };
+
+            SingletonSeparatedSyntaxList.prototype.firstToken = function () {
+                return this.item.firstToken();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.lastToken = function () {
+                return this.item.lastToken();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.fullWidth = function () {
+                return this.item.fullWidth();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.width = function () {
+                return this.item.width();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.fullText = function () {
+                return this.item.fullText();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.leadingTrivia = function () {
+                return this.item.leadingTrivia();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.trailingTrivia = function () {
+                return this.item.trailingTrivia();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.leadingTriviaWidth = function () {
+                return this.item.leadingTriviaWidth();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.trailingTriviaWidth = function () {
+                return this.item.trailingTriviaWidth();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.isTypeScriptSpecific = function () {
+                return this.item.isTypeScriptSpecific();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.isIncrementallyUnusable = function () {
+                return this.item.isIncrementallyUnusable();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return this.item.findTokenInternal(new TypeScript.PositionedSeparatedList(parent, this, fullStart), position, fullStart);
+            };
+
+            SingletonSeparatedSyntaxList.prototype.insertChildrenInto = function (array, index) {
+                array.splice(index, 0, this.item);
+            };
+            return SingletonSeparatedSyntaxList;
+        })();
+
+        var NormalSeparatedSyntaxList = (function () {
+            function NormalSeparatedSyntaxList(elements) {
+                this._data = 0;
+                this.elements = elements;
+            }
+            NormalSeparatedSyntaxList.prototype.kind = function () {
+                return 2 /* SeparatedList */;
+            };
+
+            NormalSeparatedSyntaxList.prototype.isToken = function () {
+                return false;
+            };
+            NormalSeparatedSyntaxList.prototype.isNode = function () {
+                return false;
+            };
+            NormalSeparatedSyntaxList.prototype.isList = function () {
+                return false;
+            };
+            NormalSeparatedSyntaxList.prototype.isSeparatedList = function () {
+                return true;
+            };
+            NormalSeparatedSyntaxList.prototype.toJSON = function (key) {
+                return this.elements;
+            };
+
+            NormalSeparatedSyntaxList.prototype.childCount = function () {
+                return this.elements.length;
+            };
+            NormalSeparatedSyntaxList.prototype.nonSeparatorCount = function () {
+                return TypeScript.IntegerUtilities.integerDivide(this.elements.length + 1, 2);
+            };
+            NormalSeparatedSyntaxList.prototype.separatorCount = function () {
+                return TypeScript.IntegerUtilities.integerDivide(this.elements.length, 2);
+            };
+
+            NormalSeparatedSyntaxList.prototype.toArray = function () {
+                return this.elements.slice(0);
+            };
+
+            NormalSeparatedSyntaxList.prototype.toNonSeparatorArray = function () {
+                var result = [];
+                for (var i = 0, n = this.nonSeparatorCount(); i < n; i++) {
+                    result.push(this.nonSeparatorAt(i));
+                }
+
+                return result;
+            };
+
+            NormalSeparatedSyntaxList.prototype.childAt = function (index) {
+                if (index < 0 || index >= this.elements.length) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.elements[index];
+            };
+
+            NormalSeparatedSyntaxList.prototype.nonSeparatorAt = function (index) {
+                var value = index * 2;
+                if (value < 0 || value >= this.elements.length) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.elements[value];
+            };
+
+            NormalSeparatedSyntaxList.prototype.separatorAt = function (index) {
+                var value = index * 2 + 1;
+                if (value < 0 || value >= this.elements.length) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.elements[value];
+            };
+
+            NormalSeparatedSyntaxList.prototype.firstToken = function () {
+                var token;
+                for (var i = 0, n = this.elements.length; i < n; i++) {
+                    if (i % 2 === 0) {
+                        var nodeOrToken = this.elements[i];
+                        token = nodeOrToken.firstToken();
+                        if (token !== null) {
+                            return token;
+                        }
+                    } else {
+                        token = this.elements[i];
+                        if (token.width() > 0) {
+                            return token;
+                        }
+                    }
+                }
+
+                return null;
+            };
+
+            NormalSeparatedSyntaxList.prototype.lastToken = function () {
+                var token;
+                for (var i = this.elements.length - 1; i >= 0; i--) {
+                    if (i % 2 === 0) {
+                        var nodeOrToken = this.elements[i];
+                        token = nodeOrToken.lastToken();
+                        if (token !== null) {
+                            return token;
+                        }
+                    } else {
+                        token = this.elements[i];
+                        if (token.width() > 0) {
+                            return token;
+                        }
+                    }
+                }
+
+                return null;
+            };
+
+            NormalSeparatedSyntaxList.prototype.fullText = function () {
+                var elements = [];
+                this.collectTextElements(elements);
+                return elements.join("");
+            };
+
+            NormalSeparatedSyntaxList.prototype.isTypeScriptSpecific = function () {
+                for (var i = 0, n = this.nonSeparatorCount(); i < n; i++) {
+                    if (this.nonSeparatorAt(i).isTypeScriptSpecific()) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            NormalSeparatedSyntaxList.prototype.isIncrementallyUnusable = function () {
+                return (this.data() & 2 /* NodeIncrementallyUnusableMask */) !== 0;
+            };
+
+            NormalSeparatedSyntaxList.prototype.fullWidth = function () {
+                return this.data() >>> 3 /* NodeFullWidthShift */;
+            };
+
+            NormalSeparatedSyntaxList.prototype.width = function () {
+                var fullWidth = this.fullWidth();
+                return fullWidth - this.leadingTriviaWidth() - this.trailingTriviaWidth();
+            };
+
+            NormalSeparatedSyntaxList.prototype.leadingTrivia = function () {
+                return this.firstToken().leadingTrivia();
+            };
+
+            NormalSeparatedSyntaxList.prototype.trailingTrivia = function () {
+                return this.lastToken().trailingTrivia();
+            };
+
+            NormalSeparatedSyntaxList.prototype.leadingTriviaWidth = function () {
+                return this.firstToken().leadingTriviaWidth();
+            };
+
+            NormalSeparatedSyntaxList.prototype.trailingTriviaWidth = function () {
+                return this.lastToken().trailingTriviaWidth();
+            };
+
+            NormalSeparatedSyntaxList.prototype.computeData = function () {
+                var fullWidth = 0;
+                var isIncrementallyUnusable = false;
+
+                for (var i = 0, n = this.elements.length; i < n; i++) {
+                    var element = this.elements[i];
+
+                    var childWidth = element.fullWidth();
+                    fullWidth += childWidth;
+
+                    isIncrementallyUnusable = isIncrementallyUnusable || element.isIncrementallyUnusable();
+                }
+
+                return (fullWidth << 3 /* NodeFullWidthShift */) | (isIncrementallyUnusable ? 2 /* NodeIncrementallyUnusableMask */ : 0) | 1 /* NodeDataComputed */;
+            };
+
+            NormalSeparatedSyntaxList.prototype.data = function () {
+                if ((this._data & 1 /* NodeDataComputed */) === 0) {
+                    this._data = this.computeData();
+                }
+
+                return this._data;
+            };
+
+            NormalSeparatedSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) {
+                parent = new TypeScript.PositionedSeparatedList(parent, this, fullStart);
+                for (var i = 0, n = this.elements.length; i < n; i++) {
+                    var element = this.elements[i];
+
+                    var childWidth = element.fullWidth();
+                    if (position < childWidth) {
+                        return element.findTokenInternal(parent, position, fullStart);
+                    }
+
+                    position -= childWidth;
+                    fullStart += childWidth;
+                }
+
+                throw TypeScript.Errors.invalidOperation();
+            };
+
+            NormalSeparatedSyntaxList.prototype.collectTextElements = function (elements) {
+                for (var i = 0, n = this.elements.length; i < n; i++) {
+                    var element = this.elements[i];
+                    element.collectTextElements(elements);
+                }
+            };
+
+            NormalSeparatedSyntaxList.prototype.insertChildrenInto = function (array, index) {
+                if (index === 0) {
+                    array.unshift.apply(array, this.elements);
+                } else {
+                    array.splice.apply(array, [index, 0].concat(this.elements));
+                }
+            };
+            return NormalSeparatedSyntaxList;
+        })();
+
+        function separatedList(nodes) {
+            return separatedListAndValidate(nodes, false);
+        }
+        Syntax.separatedList = separatedList;
+
+        function separatedListAndValidate(nodes, validate) {
+            if (nodes === undefined || nodes === null || nodes.length === 0) {
+                return Syntax.emptySeparatedList;
+            }
+
+            if (validate) {
+                for (var i = 0; i < nodes.length; i++) {
+                    var item = nodes[i];
+
+                    if (i % 2 === 1) {
+                    }
+                }
+            }
+
+            if (nodes.length === 1) {
+                return new SingletonSeparatedSyntaxList(nodes[0]);
+            }
+
+            return new NormalSeparatedSyntaxList(nodes);
+        }
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SlidingWindow = (function () {
+        function SlidingWindow(source, window, defaultValue, sourceLength) {
+            if (typeof sourceLength === "undefined") { sourceLength = -1; }
+            this.source = source;
+            this.window = window;
+            this.defaultValue = defaultValue;
+            this.sourceLength = sourceLength;
+            this.windowCount = 0;
+            this.windowAbsoluteStartIndex = 0;
+            this.currentRelativeItemIndex = 0;
+            this._pinCount = 0;
+            this.firstPinnedAbsoluteIndex = -1;
+        }
+        SlidingWindow.prototype.windowAbsoluteEndIndex = function () {
+            return this.windowAbsoluteStartIndex + this.windowCount;
+        };
+
+        SlidingWindow.prototype.addMoreItemsToWindow = function (argument) {
+            if (this.sourceLength >= 0 && this.absoluteIndex() >= this.sourceLength) {
+                return false;
+            }
+
+            if (this.windowCount >= this.window.length) {
+                this.tryShiftOrGrowWindow();
+            }
+
+            var spaceAvailable = this.window.length - this.windowCount;
+            var amountFetched = this.source.fetchMoreItems(argument, this.windowAbsoluteEndIndex(), this.window, this.windowCount, spaceAvailable);
+
+            this.windowCount += amountFetched;
+            return amountFetched > 0;
+        };
+
+        SlidingWindow.prototype.tryShiftOrGrowWindow = function () {
+            var currentIndexIsPastWindowHalfwayPoint = this.currentRelativeItemIndex > (this.window.length >>> 1);
+
+            var isAllowedToShift = this.firstPinnedAbsoluteIndex === -1 || this.firstPinnedAbsoluteIndex > this.windowAbsoluteStartIndex;
+
+            if (currentIndexIsPastWindowHalfwayPoint && isAllowedToShift) {
+                var shiftStartIndex = this.firstPinnedAbsoluteIndex === -1 ? this.currentRelativeItemIndex : this.firstPinnedAbsoluteIndex - this.windowAbsoluteStartIndex;
+
+                var shiftCount = this.windowCount - shiftStartIndex;
+
+                if (shiftCount > 0) {
+                    TypeScript.ArrayUtilities.copy(this.window, shiftStartIndex, this.window, 0, shiftCount);
+                }
+
+                this.windowAbsoluteStartIndex += shiftStartIndex;
+
+                this.windowCount -= shiftStartIndex;
+
+                this.currentRelativeItemIndex -= shiftStartIndex;
+            } else {
+                TypeScript.ArrayUtilities.grow(this.window, this.window.length * 2, this.defaultValue);
+            }
+        };
+
+        SlidingWindow.prototype.absoluteIndex = function () {
+            return this.windowAbsoluteStartIndex + this.currentRelativeItemIndex;
+        };
+
+        SlidingWindow.prototype.isAtEndOfSource = function () {
+            return this.absoluteIndex() >= this.sourceLength;
+        };
+
+        SlidingWindow.prototype.getAndPinAbsoluteIndex = function () {
+            var absoluteIndex = this.absoluteIndex();
+            var pinCount = this._pinCount++;
+            if (pinCount === 0) {
+                this.firstPinnedAbsoluteIndex = absoluteIndex;
+            }
+
+            return absoluteIndex;
+        };
+
+        SlidingWindow.prototype.releaseAndUnpinAbsoluteIndex = function (absoluteIndex) {
+            this._pinCount--;
+            if (this._pinCount === 0) {
+                this.firstPinnedAbsoluteIndex = -1;
+            }
+        };
+
+        SlidingWindow.prototype.rewindToPinnedIndex = function (absoluteIndex) {
+            var relativeIndex = absoluteIndex - this.windowAbsoluteStartIndex;
+
+            this.currentRelativeItemIndex = relativeIndex;
+        };
+
+        SlidingWindow.prototype.currentItem = function (argument) {
+            if (this.currentRelativeItemIndex >= this.windowCount) {
+                if (!this.addMoreItemsToWindow(argument)) {
+                    return this.defaultValue;
+                }
+            }
+
+            return this.window[this.currentRelativeItemIndex];
+        };
+
+        SlidingWindow.prototype.peekItemN = function (n) {
+            while (this.currentRelativeItemIndex + n >= this.windowCount) {
+                if (!this.addMoreItemsToWindow(null)) {
+                    return this.defaultValue;
+                }
+            }
+
+            return this.window[this.currentRelativeItemIndex + n];
+        };
+
+        SlidingWindow.prototype.moveToNextItem = function () {
+            this.currentRelativeItemIndex++;
+        };
+
+        SlidingWindow.prototype.disgardAllItemsFromCurrentIndexOnwards = function () {
+            this.windowCount = this.currentRelativeItemIndex;
+        };
+
+        SlidingWindow.prototype.setAbsoluteIndex = function (absoluteIndex) {
+            if (this.absoluteIndex() === absoluteIndex) {
+                return;
+            }
+
+            if (this._pinCount > 0) {
+            }
+
+            if (absoluteIndex >= this.windowAbsoluteStartIndex && absoluteIndex < this.windowAbsoluteEndIndex()) {
+                this.currentRelativeItemIndex = (absoluteIndex - this.windowAbsoluteStartIndex);
+            } else {
+                this.windowAbsoluteStartIndex = absoluteIndex;
+
+                this.windowCount = 0;
+
+                this.currentRelativeItemIndex = 0;
+            }
+        };
+
+        SlidingWindow.prototype.pinCount = function () {
+            return this._pinCount;
+        };
+        return SlidingWindow;
+    })();
+    TypeScript.SlidingWindow = SlidingWindow;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        function emptySourceUnit() {
+            return Syntax.normalModeFactory.sourceUnit(Syntax.emptyList, Syntax.token(10 /* EndOfFileToken */, { text: "" }));
+        }
+        Syntax.emptySourceUnit = emptySourceUnit;
+
+        function getStandaloneExpression(positionedToken) {
+            var token = positionedToken.token();
+            if (positionedToken !== null && positionedToken.kind() === 11 /* IdentifierName */) {
+                var parentPositionedNode = positionedToken.containingNode();
+                var parentNode = parentPositionedNode.node();
+
+                if (parentNode.kind() === 121 /* QualifiedName */ && parentNode.right === token) {
+                    return parentPositionedNode;
+                } else if (parentNode.kind() === 212 /* MemberAccessExpression */ && parentNode.name === token) {
+                    return parentPositionedNode;
+                }
+            }
+
+            return positionedToken;
+        }
+        Syntax.getStandaloneExpression = getStandaloneExpression;
+
+        function isInModuleOrTypeContext(positionedToken) {
+            if (positionedToken !== null) {
+                var positionedNodeOrToken = Syntax.getStandaloneExpression(positionedToken);
+                var parent = positionedNodeOrToken.containingNode();
+
+                if (parent !== null) {
+                    switch (parent.kind()) {
+                        case 246 /* ModuleNameModuleReference */:
+                            return true;
+                        case 121 /* QualifiedName */:
+                            return true;
+                        default:
+                            return isInTypeOnlyContext(positionedToken);
+                    }
+                }
+            }
+
+            return false;
+        }
+        Syntax.isInModuleOrTypeContext = isInModuleOrTypeContext;
+
+        function isInTypeOnlyContext(positionedToken) {
+            var positionedNodeOrToken = Syntax.getStandaloneExpression(positionedToken);
+            var positionedParent = positionedNodeOrToken.containingNode();
+
+            var parent = positionedParent.node();
+            var nodeOrToken = positionedNodeOrToken.nodeOrToken();
+
+            if (parent !== null) {
+                switch (parent.kind()) {
+                    case 124 /* ArrayType */:
+                        return parent.type === nodeOrToken;
+                    case 220 /* CastExpression */:
+                        return parent.type === nodeOrToken;
+                    case 244 /* TypeAnnotation */:
+                    case 230 /* ExtendsHeritageClause */:
+                    case 231 /* ImplementsHeritageClause */:
+                    case 228 /* TypeArgumentList */:
+                        return true;
+                }
+            }
+
+            return false;
+        }
+        Syntax.isInTypeOnlyContext = isInTypeOnlyContext;
+
+        function childOffset(parent, child) {
+            var offset = 0;
+            for (var i = 0, n = parent.childCount(); i < n; i++) {
+                var current = parent.childAt(i);
+                if (current === child) {
+                    return offset;
+                }
+
+                if (current !== null) {
+                    offset += current.fullWidth();
+                }
+            }
+
+            throw TypeScript.Errors.invalidOperation();
+        }
+        Syntax.childOffset = childOffset;
+
+        function childOffsetAt(parent, index) {
+            var offset = 0;
+            for (var i = 0; i < index; i++) {
+                var current = parent.childAt(i);
+                if (current !== null) {
+                    offset += current.fullWidth();
+                }
+            }
+
+            return offset;
+        }
+        Syntax.childOffsetAt = childOffsetAt;
+
+        function childIndex(parent, child) {
+            for (var i = 0, n = parent.childCount(); i < n; i++) {
+                var current = parent.childAt(i);
+                if (current === child) {
+                    return i;
+                }
+            }
+
+            throw TypeScript.Errors.invalidOperation();
+        }
+        Syntax.childIndex = childIndex;
+
+        function nodeStructuralEquals(node1, node2) {
+            if (node1 === null) {
+                return node2 === null;
+            }
+
+            return node1.structuralEquals(node2);
+        }
+        Syntax.nodeStructuralEquals = nodeStructuralEquals;
+
+        function nodeOrTokenStructuralEquals(node1, node2) {
+            if (node1 === node2) {
+                return true;
+            }
+
+            if (node1 === null || node2 === null) {
+                return false;
+            }
+
+            if (node1.isToken()) {
+                return node2.isToken() ? tokenStructuralEquals(node1, node2) : false;
+            }
+
+            return node2.isNode() ? nodeStructuralEquals(node1, node2) : false;
+        }
+        Syntax.nodeOrTokenStructuralEquals = nodeOrTokenStructuralEquals;
+
+        function tokenStructuralEquals(token1, token2) {
+            if (token1 === token2) {
+                return true;
+            }
+
+            if (token1 === null || token2 === null) {
+                return false;
+            }
+
+            return token1.kind() === token2.kind() && token1.width() === token2.width() && token1.fullWidth() === token2.fullWidth() && token1.text() === token2.text() && Syntax.triviaListStructuralEquals(token1.leadingTrivia(), token2.leadingTrivia()) && Syntax.triviaListStructuralEquals(token1.trailingTrivia(), token2.trailingTrivia());
+        }
+        Syntax.tokenStructuralEquals = tokenStructuralEquals;
+
+        function triviaListStructuralEquals(triviaList1, triviaList2) {
+            if (triviaList1.count() !== triviaList2.count()) {
+                return false;
+            }
+
+            for (var i = 0, n = triviaList1.count(); i < n; i++) {
+                if (!Syntax.triviaStructuralEquals(triviaList1.syntaxTriviaAt(i), triviaList2.syntaxTriviaAt(i))) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+        Syntax.triviaListStructuralEquals = triviaListStructuralEquals;
+
+        function triviaStructuralEquals(trivia1, trivia2) {
+            return trivia1.kind() === trivia2.kind() && trivia1.fullWidth() === trivia2.fullWidth() && trivia1.fullText() === trivia2.fullText();
+        }
+        Syntax.triviaStructuralEquals = triviaStructuralEquals;
+
+        function listStructuralEquals(list1, list2) {
+            if (list1.childCount() !== list2.childCount()) {
+                return false;
+            }
+
+            for (var i = 0, n = list1.childCount(); i < n; i++) {
+                var child1 = list1.childAt(i);
+                var child2 = list2.childAt(i);
+
+                if (!Syntax.nodeOrTokenStructuralEquals(child1, child2)) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+        Syntax.listStructuralEquals = listStructuralEquals;
+
+        function separatedListStructuralEquals(list1, list2) {
+            if (list1.childCount() !== list2.childCount()) {
+                return false;
+            }
+
+            for (var i = 0, n = list1.childCount(); i < n; i++) {
+                var element1 = list1.childAt(i);
+                var element2 = list2.childAt(i);
+                if (!Syntax.nodeOrTokenStructuralEquals(element1, element2)) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+        Syntax.separatedListStructuralEquals = separatedListStructuralEquals;
+
+        function elementStructuralEquals(element1, element2) {
+            if (element1 === element2) {
+                return true;
+            }
+
+            if (element1 === null || element2 === null) {
+                return false;
+            }
+
+            if (element2.kind() !== element2.kind()) {
+                return false;
+            }
+
+            if (element1.isToken()) {
+                return tokenStructuralEquals(element1, element2);
+            } else if (element1.isNode()) {
+                return nodeStructuralEquals(element1, element2);
+            } else if (element1.isList()) {
+                return listStructuralEquals(element1, element2);
+            } else if (element1.isSeparatedList()) {
+                return separatedListStructuralEquals(element1, element2);
+            }
+
+            throw TypeScript.Errors.invalidOperation();
+        }
+        Syntax.elementStructuralEquals = elementStructuralEquals;
+
+        function identifierName(text, info) {
+            if (typeof info === "undefined") { info = null; }
+            return Syntax.identifier(text);
+        }
+        Syntax.identifierName = identifierName;
+
+        function trueExpression() {
+            return Syntax.token(37 /* TrueKeyword */);
+        }
+        Syntax.trueExpression = trueExpression;
+
+        function falseExpression() {
+            return Syntax.token(24 /* FalseKeyword */);
+        }
+        Syntax.falseExpression = falseExpression;
+
+        function numericLiteralExpression(text) {
+            return Syntax.token(13 /* NumericLiteral */, { text: text });
+        }
+        Syntax.numericLiteralExpression = numericLiteralExpression;
+
+        function stringLiteralExpression(text) {
+            return Syntax.token(14 /* StringLiteral */, { text: text });
+        }
+        Syntax.stringLiteralExpression = stringLiteralExpression;
+
+        function isSuperInvocationExpression(node) {
+            return node.kind() === 213 /* InvocationExpression */ && node.expression.kind() === 50 /* SuperKeyword */;
+        }
+        Syntax.isSuperInvocationExpression = isSuperInvocationExpression;
+
+        function isSuperInvocationExpressionStatement(node) {
+            return node.kind() === 149 /* ExpressionStatement */ && isSuperInvocationExpression(node.expression);
+        }
+        Syntax.isSuperInvocationExpressionStatement = isSuperInvocationExpressionStatement;
+
+        function isSuperMemberAccessExpression(node) {
+            return node.kind() === 212 /* MemberAccessExpression */ && node.expression.kind() === 50 /* SuperKeyword */;
+        }
+        Syntax.isSuperMemberAccessExpression = isSuperMemberAccessExpression;
+
+        function isSuperMemberAccessInvocationExpression(node) {
+            return node.kind() === 213 /* InvocationExpression */ && isSuperMemberAccessExpression(node.expression);
+        }
+        Syntax.isSuperMemberAccessInvocationExpression = isSuperMemberAccessInvocationExpression;
+
+        function assignmentExpression(left, token, right) {
+            return Syntax.normalModeFactory.binaryExpression(174 /* AssignmentExpression */, left, token, right);
+        }
+        Syntax.assignmentExpression = assignmentExpression;
+
+        function nodeHasSkippedOrMissingTokens(node) {
+            for (var i = 0; i < node.childCount(); i++) {
+                var child = node.childAt(i);
+                if (child !== null && child.isToken()) {
+                    var token = child;
+
+                    if (token.hasSkippedToken() || (token.width() === 0 && token.kind() !== 10 /* EndOfFileToken */)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        Syntax.nodeHasSkippedOrMissingTokens = nodeHasSkippedOrMissingTokens;
+
+        function isUnterminatedStringLiteral(token) {
+            if (token && token.kind() === 14 /* StringLiteral */) {
+                var text = token.text();
+                return text.length < 2 || text.charCodeAt(text.length - 1) !== text.charCodeAt(0);
+            }
+
+            return false;
+        }
+        Syntax.isUnterminatedStringLiteral = isUnterminatedStringLiteral;
+
+        function isUnterminatedMultilineCommentTrivia(trivia) {
+            if (trivia && trivia.kind() === 6 /* MultiLineCommentTrivia */) {
+                var text = trivia.fullText();
+                return text.length < 4 || text.substring(text.length - 2) !== "*/";
+            }
+            return false;
+        }
+        Syntax.isUnterminatedMultilineCommentTrivia = isUnterminatedMultilineCommentTrivia;
+
+        function isEntirelyInsideCommentTrivia(trivia, fullStart, position) {
+            if (trivia && trivia.isComment() && position > fullStart) {
+                var end = fullStart + trivia.fullWidth();
+                if (position < end) {
+                    return true;
+                } else if (position === end) {
+                    return trivia.kind() === 7 /* SingleLineCommentTrivia */ || isUnterminatedMultilineCommentTrivia(trivia);
+                }
+            }
+
+            return false;
+        }
+        Syntax.isEntirelyInsideCommentTrivia = isEntirelyInsideCommentTrivia;
+
+        function isEntirelyInsideComment(sourceUnit, position) {
+            var positionedToken = sourceUnit.findToken(position);
+            var fullStart = positionedToken.fullStart();
+            var triviaList = null;
+            var lastTriviaBeforeToken = null;
+
+            if (positionedToken.kind() === 10 /* EndOfFileToken */) {
+                if (positionedToken.token().hasLeadingTrivia()) {
+                    triviaList = positionedToken.token().leadingTrivia();
+                } else {
+                    positionedToken = positionedToken.previousToken();
+                    if (positionedToken) {
+                        if (positionedToken && positionedToken.token().hasTrailingTrivia()) {
+                            triviaList = positionedToken.token().trailingTrivia();
+                            fullStart = positionedToken.end();
+                        }
+                    }
+                }
+            } else {
+                if (position <= (fullStart + positionedToken.token().leadingTriviaWidth())) {
+                    triviaList = positionedToken.token().leadingTrivia();
+                } else if (position >= (fullStart + positionedToken.token().width())) {
+                    triviaList = positionedToken.token().trailingTrivia();
+                    fullStart = positionedToken.end();
+                }
+            }
+
+            if (triviaList) {
+                for (var i = 0, n = triviaList.count(); i < n; i++) {
+                    var trivia = triviaList.syntaxTriviaAt(i);
+                    if (position <= fullStart) {
+                        break;
+                    } else if (position <= fullStart + trivia.fullWidth() && trivia.isComment()) {
+                        lastTriviaBeforeToken = trivia;
+                        break;
+                    }
+
+                    fullStart += trivia.fullWidth();
+                }
+            }
+
+            return lastTriviaBeforeToken && isEntirelyInsideCommentTrivia(lastTriviaBeforeToken, fullStart, position);
+        }
+        Syntax.isEntirelyInsideComment = isEntirelyInsideComment;
+
+        function isEntirelyInStringOrRegularExpressionLiteral(sourceUnit, position) {
+            var positionedToken = sourceUnit.findToken(position);
+
+            if (positionedToken) {
+                if (positionedToken.kind() === 10 /* EndOfFileToken */) {
+                    positionedToken = positionedToken.previousToken();
+                    return positionedToken && positionedToken.token().trailingTriviaWidth() === 0 && isUnterminatedStringLiteral(positionedToken.token());
+                } else if (position > positionedToken.start()) {
+                    return (position < positionedToken.end() && (positionedToken.kind() === 14 /* StringLiteral */ || positionedToken.kind() === 12 /* RegularExpressionLiteral */)) || (position <= positionedToken.end() && isUnterminatedStringLiteral(positionedToken.token()));
+                }
+            }
+
+            return false;
+        }
+        Syntax.isEntirelyInStringOrRegularExpressionLiteral = isEntirelyInStringOrRegularExpressionLiteral;
+
+        function findSkippedTokenInTriviaList(positionedToken, position, lookInLeadingTriviaList) {
+            var triviaList = null;
+            var fullStart;
+
+            if (lookInLeadingTriviaList) {
+                triviaList = positionedToken.token().leadingTrivia();
+                fullStart = positionedToken.fullStart();
+            } else {
+                triviaList = positionedToken.token().trailingTrivia();
+                fullStart = positionedToken.end();
+            }
+
+            if (triviaList && triviaList.hasSkippedToken()) {
+                for (var i = 0, n = triviaList.count(); i < n; i++) {
+                    var trivia = triviaList.syntaxTriviaAt(i);
+                    var triviaWidth = trivia.fullWidth();
+
+                    if (trivia.isSkippedToken() && position >= fullStart && position <= fullStart + triviaWidth) {
+                        return new TypeScript.PositionedSkippedToken(positionedToken, trivia.skippedToken(), fullStart);
+                    }
+
+                    fullStart += triviaWidth;
+                }
+            }
+
+            return null;
+        }
+
+        function findSkippedTokenOnLeftInTriviaList(positionedToken, position, lookInLeadingTriviaList) {
+            var triviaList = null;
+            var fullEnd;
+
+            if (lookInLeadingTriviaList) {
+                triviaList = positionedToken.token().leadingTrivia();
+                fullEnd = positionedToken.fullStart() + triviaList.fullWidth();
+            } else {
+                triviaList = positionedToken.token().trailingTrivia();
+                fullEnd = positionedToken.fullEnd();
+            }
+
+            if (triviaList && triviaList.hasSkippedToken()) {
+                for (var i = triviaList.count() - 1; i >= 0; i--) {
+                    var trivia = triviaList.syntaxTriviaAt(i);
+                    var triviaWidth = trivia.fullWidth();
+
+                    if (trivia.isSkippedToken() && position >= fullEnd) {
+                        return new TypeScript.PositionedSkippedToken(positionedToken, trivia.skippedToken(), fullEnd - triviaWidth);
+                    }
+
+                    fullEnd -= triviaWidth;
+                }
+            }
+
+            return null;
+        }
+
+        function findSkippedTokenInLeadingTriviaList(positionedToken, position) {
+            return findSkippedTokenInTriviaList(positionedToken, position, true);
+        }
+        Syntax.findSkippedTokenInLeadingTriviaList = findSkippedTokenInLeadingTriviaList;
+
+        function findSkippedTokenInTrailingTriviaList(positionedToken, position) {
+            return findSkippedTokenInTriviaList(positionedToken, position, false);
+        }
+        Syntax.findSkippedTokenInTrailingTriviaList = findSkippedTokenInTrailingTriviaList;
+
+        function findSkippedTokenInPositionedToken(positionedToken, position) {
+            var positionInLeadingTriviaList = (position < positionedToken.start());
+            return findSkippedTokenInTriviaList(positionedToken, position, positionInLeadingTriviaList);
+        }
+        Syntax.findSkippedTokenInPositionedToken = findSkippedTokenInPositionedToken;
+
+        function findSkippedTokenOnLeft(positionedToken, position) {
+            var positionInLeadingTriviaList = (position < positionedToken.start());
+            return findSkippedTokenOnLeftInTriviaList(positionedToken, position, positionInLeadingTriviaList);
+        }
+        Syntax.findSkippedTokenOnLeft = findSkippedTokenOnLeft;
+
+        function getAncestorOfKind(positionedToken, kind) {
+            while (positionedToken && positionedToken.parent()) {
+                if (positionedToken.parent().kind() === kind) {
+                    return positionedToken.parent();
+                }
+
+                positionedToken = positionedToken.parent();
+            }
+
+            return null;
+        }
+        Syntax.getAncestorOfKind = getAncestorOfKind;
+
+        function hasAncestorOfKind(positionedToken, kind) {
+            return Syntax.getAncestorOfKind(positionedToken, kind) !== null;
+        }
+        Syntax.hasAncestorOfKind = hasAncestorOfKind;
+
+        function isIntegerLiteral(expression) {
+            if (expression) {
+                switch (expression.kind()) {
+                    case 164 /* PlusExpression */:
+                    case 165 /* NegateExpression */:
+                        expression = expression.operand;
+                        return expression.isToken() && TypeScript.IntegerUtilities.isInteger(expression.text());
+
+                    case 13 /* NumericLiteral */:
+                        var text = expression.text();
+                        return TypeScript.IntegerUtilities.isInteger(text) || TypeScript.IntegerUtilities.isHexInteger(text);
+                }
+            }
+
+            return false;
+        }
+        Syntax.isIntegerLiteral = isIntegerLiteral;
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        var NormalModeFactory = (function () {
+            function NormalModeFactory() {
+            }
+            NormalModeFactory.prototype.sourceUnit = function (moduleElements, endOfFileToken) {
+                return new TypeScript.SourceUnitSyntax(moduleElements, endOfFileToken, false);
+            };
+            NormalModeFactory.prototype.externalModuleReference = function (requireKeyword, openParenToken, stringLiteral, closeParenToken) {
+                return new TypeScript.ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, false);
+            };
+            NormalModeFactory.prototype.moduleNameModuleReference = function (moduleName) {
+                return new TypeScript.ModuleNameModuleReferenceSyntax(moduleName, false);
+            };
+            NormalModeFactory.prototype.importDeclaration = function (modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken) {
+                return new TypeScript.ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.exportAssignment = function (exportKeyword, equalsToken, identifier, semicolonToken) {
+                return new TypeScript.ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.classDeclaration = function (modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken) {
+                return new TypeScript.ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, false);
+            };
+            NormalModeFactory.prototype.interfaceDeclaration = function (modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body) {
+                return new TypeScript.InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, false);
+            };
+            NormalModeFactory.prototype.heritageClause = function (kind, extendsOrImplementsKeyword, typeNames) {
+                return new TypeScript.HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, false);
+            };
+            NormalModeFactory.prototype.moduleDeclaration = function (modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken) {
+                return new TypeScript.ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, false);
+            };
+            NormalModeFactory.prototype.functionDeclaration = function (modifiers, functionKeyword, identifier, callSignature, block, semicolonToken) {
+                return new TypeScript.FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.variableStatement = function (modifiers, variableDeclaration, semicolonToken) {
+                return new TypeScript.VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.variableDeclaration = function (varKeyword, variableDeclarators) {
+                return new TypeScript.VariableDeclarationSyntax(varKeyword, variableDeclarators, false);
+            };
+            NormalModeFactory.prototype.variableDeclarator = function (propertyName, typeAnnotation, equalsValueClause) {
+                return new TypeScript.VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, false);
+            };
+            NormalModeFactory.prototype.equalsValueClause = function (equalsToken, value) {
+                return new TypeScript.EqualsValueClauseSyntax(equalsToken, value, false);
+            };
+            NormalModeFactory.prototype.prefixUnaryExpression = function (kind, operatorToken, operand) {
+                return new TypeScript.PrefixUnaryExpressionSyntax(kind, operatorToken, operand, false);
+            };
+            NormalModeFactory.prototype.arrayLiteralExpression = function (openBracketToken, expressions, closeBracketToken) {
+                return new TypeScript.ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, false);
+            };
+            NormalModeFactory.prototype.omittedExpression = function () {
+                return new TypeScript.OmittedExpressionSyntax(false);
+            };
+            NormalModeFactory.prototype.parenthesizedExpression = function (openParenToken, expression, closeParenToken) {
+                return new TypeScript.ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, false);
+            };
+            NormalModeFactory.prototype.simpleArrowFunctionExpression = function (identifier, equalsGreaterThanToken, block, expression) {
+                return new TypeScript.SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, false);
+            };
+            NormalModeFactory.prototype.parenthesizedArrowFunctionExpression = function (callSignature, equalsGreaterThanToken, block, expression) {
+                return new TypeScript.ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, false);
+            };
+            NormalModeFactory.prototype.qualifiedName = function (left, dotToken, right) {
+                return new TypeScript.QualifiedNameSyntax(left, dotToken, right, false);
+            };
+            NormalModeFactory.prototype.typeArgumentList = function (lessThanToken, typeArguments, greaterThanToken) {
+                return new TypeScript.TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, false);
+            };
+            NormalModeFactory.prototype.constructorType = function (newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type) {
+                return new TypeScript.ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, false);
+            };
+            NormalModeFactory.prototype.functionType = function (typeParameterList, parameterList, equalsGreaterThanToken, type) {
+                return new TypeScript.FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, false);
+            };
+            NormalModeFactory.prototype.objectType = function (openBraceToken, typeMembers, closeBraceToken) {
+                return new TypeScript.ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, false);
+            };
+            NormalModeFactory.prototype.arrayType = function (type, openBracketToken, closeBracketToken) {
+                return new TypeScript.ArrayTypeSyntax(type, openBracketToken, closeBracketToken, false);
+            };
+            NormalModeFactory.prototype.genericType = function (name, typeArgumentList) {
+                return new TypeScript.GenericTypeSyntax(name, typeArgumentList, false);
+            };
+            NormalModeFactory.prototype.typeQuery = function (typeOfKeyword, name) {
+                return new TypeScript.TypeQuerySyntax(typeOfKeyword, name, false);
+            };
+            NormalModeFactory.prototype.typeAnnotation = function (colonToken, type) {
+                return new TypeScript.TypeAnnotationSyntax(colonToken, type, false);
+            };
+            NormalModeFactory.prototype.block = function (openBraceToken, statements, closeBraceToken) {
+                return new TypeScript.BlockSyntax(openBraceToken, statements, closeBraceToken, false);
+            };
+            NormalModeFactory.prototype.parameter = function (dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) {
+                return new TypeScript.ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, false);
+            };
+            NormalModeFactory.prototype.memberAccessExpression = function (expression, dotToken, name) {
+                return new TypeScript.MemberAccessExpressionSyntax(expression, dotToken, name, false);
+            };
+            NormalModeFactory.prototype.postfixUnaryExpression = function (kind, operand, operatorToken) {
+                return new TypeScript.PostfixUnaryExpressionSyntax(kind, operand, operatorToken, false);
+            };
+            NormalModeFactory.prototype.elementAccessExpression = function (expression, openBracketToken, argumentExpression, closeBracketToken) {
+                return new TypeScript.ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, false);
+            };
+            NormalModeFactory.prototype.invocationExpression = function (expression, argumentList) {
+                return new TypeScript.InvocationExpressionSyntax(expression, argumentList, false);
+            };
+            NormalModeFactory.prototype.argumentList = function (typeArgumentList, openParenToken, _arguments, closeParenToken) {
+                return new TypeScript.ArgumentListSyntax(typeArgumentList, openParenToken, _arguments, closeParenToken, false);
+            };
+            NormalModeFactory.prototype.binaryExpression = function (kind, left, operatorToken, right) {
+                return new TypeScript.BinaryExpressionSyntax(kind, left, operatorToken, right, false);
+            };
+            NormalModeFactory.prototype.conditionalExpression = function (condition, questionToken, whenTrue, colonToken, whenFalse) {
+                return new TypeScript.ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, false);
+            };
+            NormalModeFactory.prototype.constructSignature = function (newKeyword, callSignature) {
+                return new TypeScript.ConstructSignatureSyntax(newKeyword, callSignature, false);
+            };
+            NormalModeFactory.prototype.methodSignature = function (propertyName, questionToken, callSignature) {
+                return new TypeScript.MethodSignatureSyntax(propertyName, questionToken, callSignature, false);
+            };
+            NormalModeFactory.prototype.indexSignature = function (openBracketToken, parameter, closeBracketToken, typeAnnotation) {
+                return new TypeScript.IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, false);
+            };
+            NormalModeFactory.prototype.propertySignature = function (propertyName, questionToken, typeAnnotation) {
+                return new TypeScript.PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, false);
+            };
+            NormalModeFactory.prototype.callSignature = function (typeParameterList, parameterList, typeAnnotation) {
+                return new TypeScript.CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, false);
+            };
+            NormalModeFactory.prototype.parameterList = function (openParenToken, parameters, closeParenToken) {
+                return new TypeScript.ParameterListSyntax(openParenToken, parameters, closeParenToken, false);
+            };
+            NormalModeFactory.prototype.typeParameterList = function (lessThanToken, typeParameters, greaterThanToken) {
+                return new TypeScript.TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, false);
+            };
+            NormalModeFactory.prototype.typeParameter = function (identifier, constraint) {
+                return new TypeScript.TypeParameterSyntax(identifier, constraint, false);
+            };
+            NormalModeFactory.prototype.constraint = function (extendsKeyword, type) {
+                return new TypeScript.ConstraintSyntax(extendsKeyword, type, false);
+            };
+            NormalModeFactory.prototype.elseClause = function (elseKeyword, statement) {
+                return new TypeScript.ElseClauseSyntax(elseKeyword, statement, false);
+            };
+            NormalModeFactory.prototype.ifStatement = function (ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause) {
+                return new TypeScript.IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, false);
+            };
+            NormalModeFactory.prototype.expressionStatement = function (expression, semicolonToken) {
+                return new TypeScript.ExpressionStatementSyntax(expression, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.constructorDeclaration = function (modifiers, constructorKeyword, callSignature, block, semicolonToken) {
+                return new TypeScript.ConstructorDeclarationSyntax(modifiers, constructorKeyword, callSignature, block, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.memberFunctionDeclaration = function (modifiers, propertyName, callSignature, block, semicolonToken) {
+                return new TypeScript.MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.getAccessor = function (modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block) {
+                return new TypeScript.GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, false);
+            };
+            NormalModeFactory.prototype.setAccessor = function (modifiers, setKeyword, propertyName, parameterList, block) {
+                return new TypeScript.SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, false);
+            };
+            NormalModeFactory.prototype.memberVariableDeclaration = function (modifiers, variableDeclarator, semicolonToken) {
+                return new TypeScript.MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.indexMemberDeclaration = function (modifiers, indexSignature, semicolonToken) {
+                return new TypeScript.IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.throwStatement = function (throwKeyword, expression, semicolonToken) {
+                return new TypeScript.ThrowStatementSyntax(throwKeyword, expression, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.returnStatement = function (returnKeyword, expression, semicolonToken) {
+                return new TypeScript.ReturnStatementSyntax(returnKeyword, expression, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.objectCreationExpression = function (newKeyword, expression, argumentList) {
+                return new TypeScript.ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, false);
+            };
+            NormalModeFactory.prototype.switchStatement = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken) {
+                return new TypeScript.SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, false);
+            };
+            NormalModeFactory.prototype.caseSwitchClause = function (caseKeyword, expression, colonToken, statements) {
+                return new TypeScript.CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, false);
+            };
+            NormalModeFactory.prototype.defaultSwitchClause = function (defaultKeyword, colonToken, statements) {
+                return new TypeScript.DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, false);
+            };
+            NormalModeFactory.prototype.breakStatement = function (breakKeyword, identifier, semicolonToken) {
+                return new TypeScript.BreakStatementSyntax(breakKeyword, identifier, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.continueStatement = function (continueKeyword, identifier, semicolonToken) {
+                return new TypeScript.ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.forStatement = function (forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement) {
+                return new TypeScript.ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, false);
+            };
+            NormalModeFactory.prototype.forInStatement = function (forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement) {
+                return new TypeScript.ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, false);
+            };
+            NormalModeFactory.prototype.whileStatement = function (whileKeyword, openParenToken, condition, closeParenToken, statement) {
+                return new TypeScript.WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, false);
+            };
+            NormalModeFactory.prototype.withStatement = function (withKeyword, openParenToken, condition, closeParenToken, statement) {
+                return new TypeScript.WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, false);
+            };
+            NormalModeFactory.prototype.enumDeclaration = function (modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken) {
+                return new TypeScript.EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, false);
+            };
+            NormalModeFactory.prototype.enumElement = function (propertyName, equalsValueClause) {
+                return new TypeScript.EnumElementSyntax(propertyName, equalsValueClause, false);
+            };
+            NormalModeFactory.prototype.castExpression = function (lessThanToken, type, greaterThanToken, expression) {
+                return new TypeScript.CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, false);
+            };
+            NormalModeFactory.prototype.objectLiteralExpression = function (openBraceToken, propertyAssignments, closeBraceToken) {
+                return new TypeScript.ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, false);
+            };
+            NormalModeFactory.prototype.simplePropertyAssignment = function (propertyName, colonToken, expression) {
+                return new TypeScript.SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, false);
+            };
+            NormalModeFactory.prototype.functionPropertyAssignment = function (propertyName, callSignature, block) {
+                return new TypeScript.FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, false);
+            };
+            NormalModeFactory.prototype.functionExpression = function (functionKeyword, identifier, callSignature, block) {
+                return new TypeScript.FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, false);
+            };
+            NormalModeFactory.prototype.emptyStatement = function (semicolonToken) {
+                return new TypeScript.EmptyStatementSyntax(semicolonToken, false);
+            };
+            NormalModeFactory.prototype.tryStatement = function (tryKeyword, block, catchClause, finallyClause) {
+                return new TypeScript.TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, false);
+            };
+            NormalModeFactory.prototype.catchClause = function (catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block) {
+                return new TypeScript.CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, false);
+            };
+            NormalModeFactory.prototype.finallyClause = function (finallyKeyword, block) {
+                return new TypeScript.FinallyClauseSyntax(finallyKeyword, block, false);
+            };
+            NormalModeFactory.prototype.labeledStatement = function (identifier, colonToken, statement) {
+                return new TypeScript.LabeledStatementSyntax(identifier, colonToken, statement, false);
+            };
+            NormalModeFactory.prototype.doStatement = function (doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken) {
+                return new TypeScript.DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.typeOfExpression = function (typeOfKeyword, expression) {
+                return new TypeScript.TypeOfExpressionSyntax(typeOfKeyword, expression, false);
+            };
+            NormalModeFactory.prototype.deleteExpression = function (deleteKeyword, expression) {
+                return new TypeScript.DeleteExpressionSyntax(deleteKeyword, expression, false);
+            };
+            NormalModeFactory.prototype.voidExpression = function (voidKeyword, expression) {
+                return new TypeScript.VoidExpressionSyntax(voidKeyword, expression, false);
+            };
+            NormalModeFactory.prototype.debuggerStatement = function (debuggerKeyword, semicolonToken) {
+                return new TypeScript.DebuggerStatementSyntax(debuggerKeyword, semicolonToken, false);
+            };
+            return NormalModeFactory;
+        })();
+        Syntax.NormalModeFactory = NormalModeFactory;
+
+        var StrictModeFactory = (function () {
+            function StrictModeFactory() {
+            }
+            StrictModeFactory.prototype.sourceUnit = function (moduleElements, endOfFileToken) {
+                return new TypeScript.SourceUnitSyntax(moduleElements, endOfFileToken, true);
+            };
+            StrictModeFactory.prototype.externalModuleReference = function (requireKeyword, openParenToken, stringLiteral, closeParenToken) {
+                return new TypeScript.ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, true);
+            };
+            StrictModeFactory.prototype.moduleNameModuleReference = function (moduleName) {
+                return new TypeScript.ModuleNameModuleReferenceSyntax(moduleName, true);
+            };
+            StrictModeFactory.prototype.importDeclaration = function (modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken) {
+                return new TypeScript.ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.exportAssignment = function (exportKeyword, equalsToken, identifier, semicolonToken) {
+                return new TypeScript.ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.classDeclaration = function (modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken) {
+                return new TypeScript.ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, true);
+            };
+            StrictModeFactory.prototype.interfaceDeclaration = function (modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body) {
+                return new TypeScript.InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, true);
+            };
+            StrictModeFactory.prototype.heritageClause = function (kind, extendsOrImplementsKeyword, typeNames) {
+                return new TypeScript.HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, true);
+            };
+            StrictModeFactory.prototype.moduleDeclaration = function (modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken) {
+                return new TypeScript.ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, true);
+            };
+            StrictModeFactory.prototype.functionDeclaration = function (modifiers, functionKeyword, identifier, callSignature, block, semicolonToken) {
+                return new TypeScript.FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.variableStatement = function (modifiers, variableDeclaration, semicolonToken) {
+                return new TypeScript.VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.variableDeclaration = function (varKeyword, variableDeclarators) {
+                return new TypeScript.VariableDeclarationSyntax(varKeyword, variableDeclarators, true);
+            };
+            StrictModeFactory.prototype.variableDeclarator = function (propertyName, typeAnnotation, equalsValueClause) {
+                return new TypeScript.VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, true);
+            };
+            StrictModeFactory.prototype.equalsValueClause = function (equalsToken, value) {
+                return new TypeScript.EqualsValueClauseSyntax(equalsToken, value, true);
+            };
+            StrictModeFactory.prototype.prefixUnaryExpression = function (kind, operatorToken, operand) {
+                return new TypeScript.PrefixUnaryExpressionSyntax(kind, operatorToken, operand, true);
+            };
+            StrictModeFactory.prototype.arrayLiteralExpression = function (openBracketToken, expressions, closeBracketToken) {
+                return new TypeScript.ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, true);
+            };
+            StrictModeFactory.prototype.omittedExpression = function () {
+                return new TypeScript.OmittedExpressionSyntax(true);
+            };
+            StrictModeFactory.prototype.parenthesizedExpression = function (openParenToken, expression, closeParenToken) {
+                return new TypeScript.ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, true);
+            };
+            StrictModeFactory.prototype.simpleArrowFunctionExpression = function (identifier, equalsGreaterThanToken, block, expression) {
+                return new TypeScript.SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, true);
+            };
+            StrictModeFactory.prototype.parenthesizedArrowFunctionExpression = function (callSignature, equalsGreaterThanToken, block, expression) {
+                return new TypeScript.ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, true);
+            };
+            StrictModeFactory.prototype.qualifiedName = function (left, dotToken, right) {
+                return new TypeScript.QualifiedNameSyntax(left, dotToken, right, true);
+            };
+            StrictModeFactory.prototype.typeArgumentList = function (lessThanToken, typeArguments, greaterThanToken) {
+                return new TypeScript.TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, true);
+            };
+            StrictModeFactory.prototype.constructorType = function (newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type) {
+                return new TypeScript.ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, true);
+            };
+            StrictModeFactory.prototype.functionType = function (typeParameterList, parameterList, equalsGreaterThanToken, type) {
+                return new TypeScript.FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, true);
+            };
+            StrictModeFactory.prototype.objectType = function (openBraceToken, typeMembers, closeBraceToken) {
+                return new TypeScript.ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, true);
+            };
+            StrictModeFactory.prototype.arrayType = function (type, openBracketToken, closeBracketToken) {
+                return new TypeScript.ArrayTypeSyntax(type, openBracketToken, closeBracketToken, true);
+            };
+            StrictModeFactory.prototype.genericType = function (name, typeArgumentList) {
+                return new TypeScript.GenericTypeSyntax(name, typeArgumentList, true);
+            };
+            StrictModeFactory.prototype.typeQuery = function (typeOfKeyword, name) {
+                return new TypeScript.TypeQuerySyntax(typeOfKeyword, name, true);
+            };
+            StrictModeFactory.prototype.typeAnnotation = function (colonToken, type) {
+                return new TypeScript.TypeAnnotationSyntax(colonToken, type, true);
+            };
+            StrictModeFactory.prototype.block = function (openBraceToken, statements, closeBraceToken) {
+                return new TypeScript.BlockSyntax(openBraceToken, statements, closeBraceToken, true);
+            };
+            StrictModeFactory.prototype.parameter = function (dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) {
+                return new TypeScript.ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, true);
+            };
+            StrictModeFactory.prototype.memberAccessExpression = function (expression, dotToken, name) {
+                return new TypeScript.MemberAccessExpressionSyntax(expression, dotToken, name, true);
+            };
+            StrictModeFactory.prototype.postfixUnaryExpression = function (kind, operand, operatorToken) {
+                return new TypeScript.PostfixUnaryExpressionSyntax(kind, operand, operatorToken, true);
+            };
+            StrictModeFactory.prototype.elementAccessExpression = function (expression, openBracketToken, argumentExpression, closeBracketToken) {
+                return new TypeScript.ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, true);
+            };
+            StrictModeFactory.prototype.invocationExpression = function (expression, argumentList) {
+                return new TypeScript.InvocationExpressionSyntax(expression, argumentList, true);
+            };
+            StrictModeFactory.prototype.argumentList = function (typeArgumentList, openParenToken, _arguments, closeParenToken) {
+                return new TypeScript.ArgumentListSyntax(typeArgumentList, openParenToken, _arguments, closeParenToken, true);
+            };
+            StrictModeFactory.prototype.binaryExpression = function (kind, left, operatorToken, right) {
+                return new TypeScript.BinaryExpressionSyntax(kind, left, operatorToken, right, true);
+            };
+            StrictModeFactory.prototype.conditionalExpression = function (condition, questionToken, whenTrue, colonToken, whenFalse) {
+                return new TypeScript.ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, true);
+            };
+            StrictModeFactory.prototype.constructSignature = function (newKeyword, callSignature) {
+                return new TypeScript.ConstructSignatureSyntax(newKeyword, callSignature, true);
+            };
+            StrictModeFactory.prototype.methodSignature = function (propertyName, questionToken, callSignature) {
+                return new TypeScript.MethodSignatureSyntax(propertyName, questionToken, callSignature, true);
+            };
+            StrictModeFactory.prototype.indexSignature = function (openBracketToken, parameter, closeBracketToken, typeAnnotation) {
+                return new TypeScript.IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, true);
+            };
+            StrictModeFactory.prototype.propertySignature = function (propertyName, questionToken, typeAnnotation) {
+                return new TypeScript.PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, true);
+            };
+            StrictModeFactory.prototype.callSignature = function (typeParameterList, parameterList, typeAnnotation) {
+                return new TypeScript.CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, true);
+            };
+            StrictModeFactory.prototype.parameterList = function (openParenToken, parameters, closeParenToken) {
+                return new TypeScript.ParameterListSyntax(openParenToken, parameters, closeParenToken, true);
+            };
+            StrictModeFactory.prototype.typeParameterList = function (lessThanToken, typeParameters, greaterThanToken) {
+                return new TypeScript.TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, true);
+            };
+            StrictModeFactory.prototype.typeParameter = function (identifier, constraint) {
+                return new TypeScript.TypeParameterSyntax(identifier, constraint, true);
+            };
+            StrictModeFactory.prototype.constraint = function (extendsKeyword, type) {
+                return new TypeScript.ConstraintSyntax(extendsKeyword, type, true);
+            };
+            StrictModeFactory.prototype.elseClause = function (elseKeyword, statement) {
+                return new TypeScript.ElseClauseSyntax(elseKeyword, statement, true);
+            };
+            StrictModeFactory.prototype.ifStatement = function (ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause) {
+                return new TypeScript.IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, true);
+            };
+            StrictModeFactory.prototype.expressionStatement = function (expression, semicolonToken) {
+                return new TypeScript.ExpressionStatementSyntax(expression, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.constructorDeclaration = function (modifiers, constructorKeyword, callSignature, block, semicolonToken) {
+                return new TypeScript.ConstructorDeclarationSyntax(modifiers, constructorKeyword, callSignature, block, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.memberFunctionDeclaration = function (modifiers, propertyName, callSignature, block, semicolonToken) {
+                return new TypeScript.MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.getAccessor = function (modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block) {
+                return new TypeScript.GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, true);
+            };
+            StrictModeFactory.prototype.setAccessor = function (modifiers, setKeyword, propertyName, parameterList, block) {
+                return new TypeScript.SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, true);
+            };
+            StrictModeFactory.prototype.memberVariableDeclaration = function (modifiers, variableDeclarator, semicolonToken) {
+                return new TypeScript.MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.indexMemberDeclaration = function (modifiers, indexSignature, semicolonToken) {
+                return new TypeScript.IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.throwStatement = function (throwKeyword, expression, semicolonToken) {
+                return new TypeScript.ThrowStatementSyntax(throwKeyword, expression, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.returnStatement = function (returnKeyword, expression, semicolonToken) {
+                return new TypeScript.ReturnStatementSyntax(returnKeyword, expression, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.objectCreationExpression = function (newKeyword, expression, argumentList) {
+                return new TypeScript.ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, true);
+            };
+            StrictModeFactory.prototype.switchStatement = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken) {
+                return new TypeScript.SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, true);
+            };
+            StrictModeFactory.prototype.caseSwitchClause = function (caseKeyword, expression, colonToken, statements) {
+                return new TypeScript.CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, true);
+            };
+            StrictModeFactory.prototype.defaultSwitchClause = function (defaultKeyword, colonToken, statements) {
+                return new TypeScript.DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, true);
+            };
+            StrictModeFactory.prototype.breakStatement = function (breakKeyword, identifier, semicolonToken) {
+                return new TypeScript.BreakStatementSyntax(breakKeyword, identifier, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.continueStatement = function (continueKeyword, identifier, semicolonToken) {
+                return new TypeScript.ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.forStatement = function (forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement) {
+                return new TypeScript.ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, true);
+            };
+            StrictModeFactory.prototype.forInStatement = function (forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement) {
+                return new TypeScript.ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, true);
+            };
+            StrictModeFactory.prototype.whileStatement = function (whileKeyword, openParenToken, condition, closeParenToken, statement) {
+                return new TypeScript.WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, true);
+            };
+            StrictModeFactory.prototype.withStatement = function (withKeyword, openParenToken, condition, closeParenToken, statement) {
+                return new TypeScript.WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, true);
+            };
+            StrictModeFactory.prototype.enumDeclaration = function (modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken) {
+                return new TypeScript.EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, true);
+            };
+            StrictModeFactory.prototype.enumElement = function (propertyName, equalsValueClause) {
+                return new TypeScript.EnumElementSyntax(propertyName, equalsValueClause, true);
+            };
+            StrictModeFactory.prototype.castExpression = function (lessThanToken, type, greaterThanToken, expression) {
+                return new TypeScript.CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, true);
+            };
+            StrictModeFactory.prototype.objectLiteralExpression = function (openBraceToken, propertyAssignments, closeBraceToken) {
+                return new TypeScript.ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, true);
+            };
+            StrictModeFactory.prototype.simplePropertyAssignment = function (propertyName, colonToken, expression) {
+                return new TypeScript.SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, true);
+            };
+            StrictModeFactory.prototype.functionPropertyAssignment = function (propertyName, callSignature, block) {
+                return new TypeScript.FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, true);
+            };
+            StrictModeFactory.prototype.functionExpression = function (functionKeyword, identifier, callSignature, block) {
+                return new TypeScript.FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, true);
+            };
+            StrictModeFactory.prototype.emptyStatement = function (semicolonToken) {
+                return new TypeScript.EmptyStatementSyntax(semicolonToken, true);
+            };
+            StrictModeFactory.prototype.tryStatement = function (tryKeyword, block, catchClause, finallyClause) {
+                return new TypeScript.TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, true);
+            };
+            StrictModeFactory.prototype.catchClause = function (catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block) {
+                return new TypeScript.CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, true);
+            };
+            StrictModeFactory.prototype.finallyClause = function (finallyKeyword, block) {
+                return new TypeScript.FinallyClauseSyntax(finallyKeyword, block, true);
+            };
+            StrictModeFactory.prototype.labeledStatement = function (identifier, colonToken, statement) {
+                return new TypeScript.LabeledStatementSyntax(identifier, colonToken, statement, true);
+            };
+            StrictModeFactory.prototype.doStatement = function (doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken) {
+                return new TypeScript.DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.typeOfExpression = function (typeOfKeyword, expression) {
+                return new TypeScript.TypeOfExpressionSyntax(typeOfKeyword, expression, true);
+            };
+            StrictModeFactory.prototype.deleteExpression = function (deleteKeyword, expression) {
+                return new TypeScript.DeleteExpressionSyntax(deleteKeyword, expression, true);
+            };
+            StrictModeFactory.prototype.voidExpression = function (voidKeyword, expression) {
+                return new TypeScript.VoidExpressionSyntax(voidKeyword, expression, true);
+            };
+            StrictModeFactory.prototype.debuggerStatement = function (debuggerKeyword, semicolonToken) {
+                return new TypeScript.DebuggerStatementSyntax(debuggerKeyword, semicolonToken, true);
+            };
+            return StrictModeFactory;
+        })();
+        Syntax.StrictModeFactory = StrictModeFactory;
+
+        Syntax.normalModeFactory = new NormalModeFactory();
+        Syntax.strictModeFactory = new StrictModeFactory();
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (SyntaxFacts) {
+        function isDirectivePrologueElement(node) {
+            if (node.kind() === 149 /* ExpressionStatement */) {
+                var expressionStatement = node;
+                var expression = expressionStatement.expression;
+
+                if (expression.kind() === 14 /* StringLiteral */) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+        SyntaxFacts.isDirectivePrologueElement = isDirectivePrologueElement;
+
+        function isUseStrictDirective(node) {
+            var expressionStatement = node;
+            var stringLiteral = expressionStatement.expression;
+
+            var text = stringLiteral.text();
+            return text === '"use strict"' || text === "'use strict'";
+        }
+        SyntaxFacts.isUseStrictDirective = isUseStrictDirective;
+
+        function isIdentifierNameOrAnyKeyword(token) {
+            var tokenKind = token.tokenKind;
+            return tokenKind === 11 /* IdentifierName */ || SyntaxFacts.isAnyKeyword(tokenKind);
+        }
+        SyntaxFacts.isIdentifierNameOrAnyKeyword = isIdentifierNameOrAnyKeyword;
+    })(TypeScript.SyntaxFacts || (TypeScript.SyntaxFacts = {}));
+    var SyntaxFacts = TypeScript.SyntaxFacts;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        var EmptySyntaxList = (function () {
+            function EmptySyntaxList() {
+            }
+            EmptySyntaxList.prototype.kind = function () {
+                return 1 /* List */;
+            };
+
+            EmptySyntaxList.prototype.isNode = function () {
+                return false;
+            };
+            EmptySyntaxList.prototype.isToken = function () {
+                return false;
+            };
+            EmptySyntaxList.prototype.isList = function () {
+                return true;
+            };
+            EmptySyntaxList.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            EmptySyntaxList.prototype.toJSON = function (key) {
+                return [];
+            };
+
+            EmptySyntaxList.prototype.childCount = function () {
+                return 0;
+            };
+
+            EmptySyntaxList.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            };
+
+            EmptySyntaxList.prototype.toArray = function () {
+                return [];
+            };
+
+            EmptySyntaxList.prototype.collectTextElements = function (elements) {
+            };
+
+            EmptySyntaxList.prototype.firstToken = function () {
+                return null;
+            };
+
+            EmptySyntaxList.prototype.lastToken = function () {
+                return null;
+            };
+
+            EmptySyntaxList.prototype.fullWidth = function () {
+                return 0;
+            };
+
+            EmptySyntaxList.prototype.width = function () {
+                return 0;
+            };
+
+            EmptySyntaxList.prototype.leadingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            EmptySyntaxList.prototype.trailingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            EmptySyntaxList.prototype.leadingTriviaWidth = function () {
+                return 0;
+            };
+
+            EmptySyntaxList.prototype.trailingTriviaWidth = function () {
+                return 0;
+            };
+
+            EmptySyntaxList.prototype.fullText = function () {
+                return "";
+            };
+
+            EmptySyntaxList.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+
+            EmptySyntaxList.prototype.isIncrementallyUnusable = function () {
+                return false;
+            };
+
+            EmptySyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) {
+                throw TypeScript.Errors.invalidOperation();
+            };
+
+            EmptySyntaxList.prototype.insertChildrenInto = function (array, index) {
+            };
+            return EmptySyntaxList;
+        })();
+        Syntax.EmptySyntaxList = EmptySyntaxList;
+
+        Syntax.emptyList = new EmptySyntaxList();
+
+        var SingletonSyntaxList = (function () {
+            function SingletonSyntaxList(item) {
+                this.item = item;
+            }
+            SingletonSyntaxList.prototype.kind = function () {
+                return 1 /* List */;
+            };
+
+            SingletonSyntaxList.prototype.isToken = function () {
+                return false;
+            };
+            SingletonSyntaxList.prototype.isNode = function () {
+                return false;
+            };
+            SingletonSyntaxList.prototype.isList = function () {
+                return true;
+            };
+            SingletonSyntaxList.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            SingletonSyntaxList.prototype.toJSON = function (key) {
+                return [this.item];
+            };
+
+            SingletonSyntaxList.prototype.childCount = function () {
+                return 1;
+            };
+
+            SingletonSyntaxList.prototype.childAt = function (index) {
+                if (index !== 0) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.item;
+            };
+
+            SingletonSyntaxList.prototype.toArray = function () {
+                return [this.item];
+            };
+
+            SingletonSyntaxList.prototype.collectTextElements = function (elements) {
+                this.item.collectTextElements(elements);
+            };
+
+            SingletonSyntaxList.prototype.firstToken = function () {
+                return this.item.firstToken();
+            };
+
+            SingletonSyntaxList.prototype.lastToken = function () {
+                return this.item.lastToken();
+            };
+
+            SingletonSyntaxList.prototype.fullWidth = function () {
+                return this.item.fullWidth();
+            };
+
+            SingletonSyntaxList.prototype.width = function () {
+                return this.item.width();
+            };
+
+            SingletonSyntaxList.prototype.leadingTrivia = function () {
+                return this.item.leadingTrivia();
+            };
+
+            SingletonSyntaxList.prototype.trailingTrivia = function () {
+                return this.item.trailingTrivia();
+            };
+
+            SingletonSyntaxList.prototype.leadingTriviaWidth = function () {
+                return this.item.leadingTriviaWidth();
+            };
+
+            SingletonSyntaxList.prototype.trailingTriviaWidth = function () {
+                return this.item.trailingTriviaWidth();
+            };
+
+            SingletonSyntaxList.prototype.fullText = function () {
+                return this.item.fullText();
+            };
+
+            SingletonSyntaxList.prototype.isTypeScriptSpecific = function () {
+                return this.item.isTypeScriptSpecific();
+            };
+
+            SingletonSyntaxList.prototype.isIncrementallyUnusable = function () {
+                return this.item.isIncrementallyUnusable();
+            };
+
+            SingletonSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return this.item.findTokenInternal(new TypeScript.PositionedList(parent, this, fullStart), position, fullStart);
+            };
+
+            SingletonSyntaxList.prototype.insertChildrenInto = function (array, index) {
+                array.splice(index, 0, this.item);
+            };
+            return SingletonSyntaxList;
+        })();
+
+        var NormalSyntaxList = (function () {
+            function NormalSyntaxList(nodeOrTokens) {
+                this._data = 0;
+                this.nodeOrTokens = nodeOrTokens;
+            }
+            NormalSyntaxList.prototype.kind = function () {
+                return 1 /* List */;
+            };
+
+            NormalSyntaxList.prototype.isNode = function () {
+                return false;
+            };
+            NormalSyntaxList.prototype.isToken = function () {
+                return false;
+            };
+            NormalSyntaxList.prototype.isList = function () {
+                return true;
+            };
+            NormalSyntaxList.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            NormalSyntaxList.prototype.toJSON = function (key) {
+                return this.nodeOrTokens;
+            };
+
+            NormalSyntaxList.prototype.childCount = function () {
+                return this.nodeOrTokens.length;
+            };
+
+            NormalSyntaxList.prototype.childAt = function (index) {
+                if (index < 0 || index >= this.nodeOrTokens.length) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.nodeOrTokens[index];
+            };
+
+            NormalSyntaxList.prototype.toArray = function () {
+                return this.nodeOrTokens.slice(0);
+            };
+
+            NormalSyntaxList.prototype.collectTextElements = function (elements) {
+                for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) {
+                    var element = this.nodeOrTokens[i];
+                    element.collectTextElements(elements);
+                }
+            };
+
+            NormalSyntaxList.prototype.firstToken = function () {
+                for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) {
+                    var token = this.nodeOrTokens[i].firstToken();
+                    if (token !== null) {
+                        return token;
+                    }
+                }
+
+                return null;
+            };
+
+            NormalSyntaxList.prototype.lastToken = function () {
+                for (var i = this.nodeOrTokens.length - 1; i >= 0; i--) {
+                    var token = this.nodeOrTokens[i].lastToken();
+                    if (token !== null) {
+                        return token;
+                    }
+                }
+
+                return null;
+            };
+
+            NormalSyntaxList.prototype.fullText = function () {
+                var elements = new Array();
+                this.collectTextElements(elements);
+                return elements.join("");
+            };
+
+            NormalSyntaxList.prototype.isTypeScriptSpecific = function () {
+                for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) {
+                    if (this.nodeOrTokens[i].isTypeScriptSpecific()) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            NormalSyntaxList.prototype.isIncrementallyUnusable = function () {
+                return (this.data() & 2 /* NodeIncrementallyUnusableMask */) !== 0;
+            };
+
+            NormalSyntaxList.prototype.fullWidth = function () {
+                return this.data() >>> 3 /* NodeFullWidthShift */;
+            };
+
+            NormalSyntaxList.prototype.width = function () {
+                var fullWidth = this.fullWidth();
+                return fullWidth - this.leadingTriviaWidth() - this.trailingTriviaWidth();
+            };
+
+            NormalSyntaxList.prototype.leadingTrivia = function () {
+                return this.firstToken().leadingTrivia();
+            };
+
+            NormalSyntaxList.prototype.trailingTrivia = function () {
+                return this.lastToken().trailingTrivia();
+            };
+
+            NormalSyntaxList.prototype.leadingTriviaWidth = function () {
+                return this.firstToken().leadingTriviaWidth();
+            };
+
+            NormalSyntaxList.prototype.trailingTriviaWidth = function () {
+                return this.lastToken().trailingTriviaWidth();
+            };
+
+            NormalSyntaxList.prototype.computeData = function () {
+                var fullWidth = 0;
+                var isIncrementallyUnusable = false;
+
+                for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) {
+                    var node = this.nodeOrTokens[i];
+                    fullWidth += node.fullWidth();
+                    isIncrementallyUnusable = isIncrementallyUnusable || node.isIncrementallyUnusable();
+                }
+
+                return (fullWidth << 3 /* NodeFullWidthShift */) | (isIncrementallyUnusable ? 2 /* NodeIncrementallyUnusableMask */ : 0) | 1 /* NodeDataComputed */;
+            };
+
+            NormalSyntaxList.prototype.data = function () {
+                if ((this._data & 1 /* NodeDataComputed */) === 0) {
+                    this._data = this.computeData();
+                }
+
+                return this._data;
+            };
+
+            NormalSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) {
+                parent = new TypeScript.PositionedList(parent, this, fullStart);
+                for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) {
+                    var nodeOrToken = this.nodeOrTokens[i];
+
+                    var childWidth = nodeOrToken.fullWidth();
+                    if (position < childWidth) {
+                        return nodeOrToken.findTokenInternal(parent, position, fullStart);
+                    }
+
+                    position -= childWidth;
+                    fullStart += childWidth;
+                }
+
+                throw TypeScript.Errors.invalidOperation();
+            };
+
+            NormalSyntaxList.prototype.insertChildrenInto = function (array, index) {
+                if (index === 0) {
+                    array.unshift.apply(array, this.nodeOrTokens);
+                } else {
+                    array.splice.apply(array, [index, 0].concat(this.nodeOrTokens));
+                }
+            };
+            return NormalSyntaxList;
+        })();
+
+        function list(nodes) {
+            if (nodes === undefined || nodes === null || nodes.length === 0) {
+                return Syntax.emptyList;
+            }
+
+            if (nodes.length === 1) {
+                var item = nodes[0];
+                return new SingletonSyntaxList(item);
+            }
+
+            return new NormalSyntaxList(nodes);
+        }
+        Syntax.list = list;
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxNode = (function () {
+        function SyntaxNode(parsedInStrictMode) {
+            this._data = parsedInStrictMode ? 4 /* NodeParsedInStrictModeMask */ : 0;
+        }
+        SyntaxNode.prototype.isNode = function () {
+            return true;
+        };
+        SyntaxNode.prototype.isToken = function () {
+            return false;
+        };
+        SyntaxNode.prototype.isList = function () {
+            return false;
+        };
+        SyntaxNode.prototype.isSeparatedList = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.kind = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        SyntaxNode.prototype.childCount = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        SyntaxNode.prototype.childAt = function (slot) {
+            throw TypeScript.Errors.abstract();
+        };
+
+        SyntaxNode.prototype.firstToken = function () {
+            for (var i = 0, n = this.childCount(); i < n; i++) {
+                var element = this.childAt(i);
+
+                if (element !== null) {
+                    if (element.fullWidth() > 0 || element.kind() === 10 /* EndOfFileToken */) {
+                        return element.firstToken();
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        SyntaxNode.prototype.lastToken = function () {
+            for (var i = this.childCount() - 1; i >= 0; i--) {
+                var element = this.childAt(i);
+
+                if (element !== null) {
+                    if (element.fullWidth() > 0 || element.kind() === 10 /* EndOfFileToken */) {
+                        return element.lastToken();
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        SyntaxNode.prototype.insertChildrenInto = function (array, index) {
+            for (var i = this.childCount() - 1; i >= 0; i--) {
+                var element = this.childAt(i);
+
+                if (element !== null) {
+                    if (element.isNode() || element.isToken()) {
+                        array.splice(index, 0, element);
+                    } else if (element.isList()) {
+                        element.insertChildrenInto(array, index);
+                    } else if (element.isSeparatedList()) {
+                        element.insertChildrenInto(array, index);
+                    } else {
+                        throw TypeScript.Errors.invalidOperation();
+                    }
+                }
+            }
+        };
+
+        SyntaxNode.prototype.leadingTrivia = function () {
+            var firstToken = this.firstToken();
+            return firstToken ? firstToken.leadingTrivia() : TypeScript.Syntax.emptyTriviaList;
+        };
+
+        SyntaxNode.prototype.trailingTrivia = function () {
+            var lastToken = this.lastToken();
+            return lastToken ? lastToken.trailingTrivia() : TypeScript.Syntax.emptyTriviaList;
+        };
+
+        SyntaxNode.prototype.toJSON = function (key) {
+            var result = {
+                kind: TypeScript.SyntaxKind[this.kind()],
+                fullWidth: this.fullWidth()
+            };
+
+            if (this.isIncrementallyUnusable()) {
+                result.isIncrementallyUnusable = true;
+            }
+
+            if (this.parsedInStrictMode()) {
+                result.parsedInStrictMode = true;
+            }
+
+            var thisAsIndexable = this;
+            for (var i = 0, n = this.childCount(); i < n; i++) {
+                var value = this.childAt(i);
+
+                if (value) {
+                    for (var name in this) {
+                        if (value === thisAsIndexable[name]) {
+                            result[name] = value;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            return result;
+        };
+
+        SyntaxNode.prototype.accept = function (visitor) {
+            throw TypeScript.Errors.abstract();
+        };
+
+        SyntaxNode.prototype.fullText = function () {
+            var elements = [];
+            this.collectTextElements(elements);
+            return elements.join("");
+        };
+
+        SyntaxNode.prototype.collectTextElements = function (elements) {
+            for (var i = 0, n = this.childCount(); i < n; i++) {
+                var element = this.childAt(i);
+
+                if (element !== null) {
+                    element.collectTextElements(elements);
+                }
+            }
+        };
+
+        SyntaxNode.prototype.replaceToken = function (token1, token2) {
+            if (token1 === token2) {
+                return this;
+            }
+
+            return this.accept(new TypeScript.SyntaxTokenReplacer(token1, token2));
+        };
+
+        SyntaxNode.prototype.withLeadingTrivia = function (trivia) {
+            return this.replaceToken(this.firstToken(), this.firstToken().withLeadingTrivia(trivia));
+        };
+
+        SyntaxNode.prototype.withTrailingTrivia = function (trivia) {
+            return this.replaceToken(this.lastToken(), this.lastToken().withTrailingTrivia(trivia));
+        };
+
+        SyntaxNode.prototype.hasLeadingTrivia = function () {
+            return this.lastToken().hasLeadingTrivia();
+        };
+
+        SyntaxNode.prototype.hasTrailingTrivia = function () {
+            return this.lastToken().hasTrailingTrivia();
+        };
+
+        SyntaxNode.prototype.isTypeScriptSpecific = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.isIncrementallyUnusable = function () {
+            return (this.data() & 2 /* NodeIncrementallyUnusableMask */) !== 0;
+        };
+
+        SyntaxNode.prototype.parsedInStrictMode = function () {
+            return (this.data() & 4 /* NodeParsedInStrictModeMask */) !== 0;
+        };
+
+        SyntaxNode.prototype.fullWidth = function () {
+            return this.data() >>> 3 /* NodeFullWidthShift */;
+        };
+
+        SyntaxNode.prototype.computeData = function () {
+            var slotCount = this.childCount();
+
+            var fullWidth = 0;
+            var childWidth = 0;
+
+            var isIncrementallyUnusable = ((this._data & 2 /* NodeIncrementallyUnusableMask */) !== 0) || slotCount === 0;
+
+            for (var i = 0, n = slotCount; i < n; i++) {
+                var element = this.childAt(i);
+
+                if (element !== null) {
+                    childWidth = element.fullWidth();
+                    fullWidth += childWidth;
+
+                    if (!isIncrementallyUnusable) {
+                        isIncrementallyUnusable = element.isIncrementallyUnusable();
+                    }
+                }
+            }
+
+            return (fullWidth << 3 /* NodeFullWidthShift */) | (isIncrementallyUnusable ? 2 /* NodeIncrementallyUnusableMask */ : 0) | 1 /* NodeDataComputed */;
+        };
+
+        SyntaxNode.prototype.data = function () {
+            if ((this._data & 1 /* NodeDataComputed */) === 0) {
+                this._data |= this.computeData();
+            }
+
+            return this._data;
+        };
+
+        SyntaxNode.prototype.findToken = function (position, includeSkippedTokens) {
+            if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; }
+            var endOfFileToken = this.tryGetEndOfFileAt(position);
+            if (endOfFileToken !== null) {
+                return endOfFileToken;
+            }
+
+            if (position < 0 || position >= this.fullWidth()) {
+                throw TypeScript.Errors.argumentOutOfRange("position");
+            }
+
+            var positionedToken = this.findTokenInternal(null, position, 0);
+
+            if (includeSkippedTokens) {
+                return TypeScript.Syntax.findSkippedTokenInPositionedToken(positionedToken, position) || positionedToken;
+            }
+
+            return positionedToken;
+        };
+
+        SyntaxNode.prototype.tryGetEndOfFileAt = function (position) {
+            if (this.kind() === 120 /* SourceUnit */ && position === this.fullWidth()) {
+                var sourceUnit = this;
+                return new TypeScript.PositionedToken(new TypeScript.PositionedNode(null, sourceUnit, 0), sourceUnit.endOfFileToken, sourceUnit.moduleElements.fullWidth());
+            }
+
+            return null;
+        };
+
+        SyntaxNode.prototype.findTokenInternal = function (parent, position, fullStart) {
+            parent = new TypeScript.PositionedNode(parent, this, fullStart);
+            for (var i = 0, n = this.childCount(); i < n; i++) {
+                var element = this.childAt(i);
+
+                if (element !== null) {
+                    var childWidth = element.fullWidth();
+
+                    if (position < childWidth) {
+                        return element.findTokenInternal(parent, position, fullStart);
+                    }
+
+                    position -= childWidth;
+                    fullStart += childWidth;
+                }
+            }
+
+            throw TypeScript.Errors.invalidOperation();
+        };
+
+        SyntaxNode.prototype.findTokenOnLeft = function (position, includeSkippedTokens) {
+            if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; }
+            var positionedToken = this.findToken(position, false);
+            var start = positionedToken.start();
+
+            if (includeSkippedTokens) {
+                positionedToken = TypeScript.Syntax.findSkippedTokenOnLeft(positionedToken, position) || positionedToken;
+            }
+
+            if (position > start) {
+                return positionedToken;
+            }
+
+            if (positionedToken.fullStart() === 0) {
+                return null;
+            }
+
+            return positionedToken.previousToken(includeSkippedTokens);
+        };
+
+        SyntaxNode.prototype.findCompleteTokenOnLeft = function (position, includeSkippedTokens) {
+            if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; }
+            var positionedToken = this.findToken(position, false);
+
+            if (includeSkippedTokens) {
+                positionedToken = TypeScript.Syntax.findSkippedTokenOnLeft(positionedToken, position) || positionedToken;
+            }
+
+            if (positionedToken.token().width() > 0 && position >= positionedToken.end()) {
+                return positionedToken;
+            }
+
+            return positionedToken.previousToken(includeSkippedTokens);
+        };
+
+        SyntaxNode.prototype.isModuleElement = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.isClassElement = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.isTypeMember = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.isStatement = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.isExpression = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.isSwitchClause = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.structuralEquals = function (node) {
+            if (this === node) {
+                return true;
+            }
+            if (node === null) {
+                return false;
+            }
+            if (this.kind() !== node.kind()) {
+                return false;
+            }
+
+            for (var i = 0, n = this.childCount(); i < n; i++) {
+                var element1 = this.childAt(i);
+                var element2 = node.childAt(i);
+
+                if (!TypeScript.Syntax.elementStructuralEquals(element1, element2)) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        SyntaxNode.prototype.width = function () {
+            return this.fullWidth() - this.leadingTriviaWidth() - this.trailingTriviaWidth();
+        };
+
+        SyntaxNode.prototype.leadingTriviaWidth = function () {
+            var firstToken = this.firstToken();
+            return firstToken === null ? 0 : firstToken.leadingTriviaWidth();
+        };
+
+        SyntaxNode.prototype.trailingTriviaWidth = function () {
+            var lastToken = this.lastToken();
+            return lastToken === null ? 0 : lastToken.trailingTriviaWidth();
+        };
+        return SyntaxNode;
+    })();
+    TypeScript.SyntaxNode = SyntaxNode;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SourceUnitSyntax = (function (_super) {
+        __extends(SourceUnitSyntax, _super);
+        function SourceUnitSyntax(moduleElements, endOfFileToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.moduleElements = moduleElements;
+            this.endOfFileToken = endOfFileToken;
+        }
+        SourceUnitSyntax.prototype.accept = function (visitor) {
+            return visitor.visitSourceUnit(this);
+        };
+
+        SourceUnitSyntax.prototype.kind = function () {
+            return 120 /* SourceUnit */;
+        };
+
+        SourceUnitSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        SourceUnitSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.moduleElements;
+                case 1:
+                    return this.endOfFileToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        SourceUnitSyntax.prototype.update = function (moduleElements, endOfFileToken) {
+            if (this.moduleElements === moduleElements && this.endOfFileToken === endOfFileToken) {
+                return this;
+            }
+
+            return new SourceUnitSyntax(moduleElements, endOfFileToken, this.parsedInStrictMode());
+        };
+
+        SourceUnitSyntax.create = function (endOfFileToken) {
+            return new SourceUnitSyntax(TypeScript.Syntax.emptyList, endOfFileToken, false);
+        };
+
+        SourceUnitSyntax.create1 = function (endOfFileToken) {
+            return new SourceUnitSyntax(TypeScript.Syntax.emptyList, endOfFileToken, false);
+        };
+
+        SourceUnitSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        SourceUnitSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        SourceUnitSyntax.prototype.withModuleElements = function (moduleElements) {
+            return this.update(moduleElements, this.endOfFileToken);
+        };
+
+        SourceUnitSyntax.prototype.withModuleElement = function (moduleElement) {
+            return this.withModuleElements(TypeScript.Syntax.list([moduleElement]));
+        };
+
+        SourceUnitSyntax.prototype.withEndOfFileToken = function (endOfFileToken) {
+            return this.update(this.moduleElements, endOfFileToken);
+        };
+
+        SourceUnitSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.moduleElements.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return SourceUnitSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.SourceUnitSyntax = SourceUnitSyntax;
+
+    var ExternalModuleReferenceSyntax = (function (_super) {
+        __extends(ExternalModuleReferenceSyntax, _super);
+        function ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.requireKeyword = requireKeyword;
+            this.openParenToken = openParenToken;
+            this.stringLiteral = stringLiteral;
+            this.closeParenToken = closeParenToken;
+        }
+        ExternalModuleReferenceSyntax.prototype.accept = function (visitor) {
+            return visitor.visitExternalModuleReference(this);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.kind = function () {
+            return 245 /* ExternalModuleReference */;
+        };
+
+        ExternalModuleReferenceSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        ExternalModuleReferenceSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.requireKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.stringLiteral;
+                case 3:
+                    return this.closeParenToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ExternalModuleReferenceSyntax.prototype.isModuleReference = function () {
+            return true;
+        };
+
+        ExternalModuleReferenceSyntax.prototype.update = function (requireKeyword, openParenToken, stringLiteral, closeParenToken) {
+            if (this.requireKeyword === requireKeyword && this.openParenToken === openParenToken && this.stringLiteral === stringLiteral && this.closeParenToken === closeParenToken) {
+                return this;
+            }
+
+            return new ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, this.parsedInStrictMode());
+        };
+
+        ExternalModuleReferenceSyntax.create1 = function (stringLiteral) {
+            return new ExternalModuleReferenceSyntax(TypeScript.Syntax.token(66 /* RequireKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), stringLiteral, TypeScript.Syntax.token(73 /* CloseParenToken */), false);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.withRequireKeyword = function (requireKeyword) {
+            return this.update(requireKeyword, this.openParenToken, this.stringLiteral, this.closeParenToken);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.requireKeyword, openParenToken, this.stringLiteral, this.closeParenToken);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.withStringLiteral = function (stringLiteral) {
+            return this.update(this.requireKeyword, this.openParenToken, stringLiteral, this.closeParenToken);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.requireKeyword, this.openParenToken, this.stringLiteral, closeParenToken);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ExternalModuleReferenceSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ExternalModuleReferenceSyntax = ExternalModuleReferenceSyntax;
+
+    var ModuleNameModuleReferenceSyntax = (function (_super) {
+        __extends(ModuleNameModuleReferenceSyntax, _super);
+        function ModuleNameModuleReferenceSyntax(moduleName, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.moduleName = moduleName;
+        }
+        ModuleNameModuleReferenceSyntax.prototype.accept = function (visitor) {
+            return visitor.visitModuleNameModuleReference(this);
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.kind = function () {
+            return 246 /* ModuleNameModuleReference */;
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.childCount = function () {
+            return 1;
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.moduleName;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.isModuleReference = function () {
+            return true;
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.update = function (moduleName) {
+            if (this.moduleName === moduleName) {
+                return this;
+            }
+
+            return new ModuleNameModuleReferenceSyntax(moduleName, this.parsedInStrictMode());
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.withModuleName = function (moduleName) {
+            return this.update(moduleName);
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ModuleNameModuleReferenceSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ModuleNameModuleReferenceSyntax = ModuleNameModuleReferenceSyntax;
+
+    var ImportDeclarationSyntax = (function (_super) {
+        __extends(ImportDeclarationSyntax, _super);
+        function ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.importKeyword = importKeyword;
+            this.identifier = identifier;
+            this.equalsToken = equalsToken;
+            this.moduleReference = moduleReference;
+            this.semicolonToken = semicolonToken;
+        }
+        ImportDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitImportDeclaration(this);
+        };
+
+        ImportDeclarationSyntax.prototype.kind = function () {
+            return 133 /* ImportDeclaration */;
+        };
+
+        ImportDeclarationSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        ImportDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.importKeyword;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.equalsToken;
+                case 4:
+                    return this.moduleReference;
+                case 5:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ImportDeclarationSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ImportDeclarationSyntax.prototype.update = function (modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken) {
+            if (this.modifiers === modifiers && this.importKeyword === importKeyword && this.identifier === identifier && this.equalsToken === equalsToken && this.moduleReference === moduleReference && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, this.parsedInStrictMode());
+        };
+
+        ImportDeclarationSyntax.create = function (importKeyword, identifier, equalsToken, moduleReference, semicolonToken) {
+            return new ImportDeclarationSyntax(TypeScript.Syntax.emptyList, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, false);
+        };
+
+        ImportDeclarationSyntax.create1 = function (identifier, moduleReference) {
+            return new ImportDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(49 /* ImportKeyword */), identifier, TypeScript.Syntax.token(107 /* EqualsToken */), moduleReference, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        ImportDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ImportDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ImportDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.importKeyword, this.identifier, this.equalsToken, this.moduleReference, this.semicolonToken);
+        };
+
+        ImportDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        ImportDeclarationSyntax.prototype.withImportKeyword = function (importKeyword) {
+            return this.update(this.modifiers, importKeyword, this.identifier, this.equalsToken, this.moduleReference, this.semicolonToken);
+        };
+
+        ImportDeclarationSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.modifiers, this.importKeyword, identifier, this.equalsToken, this.moduleReference, this.semicolonToken);
+        };
+
+        ImportDeclarationSyntax.prototype.withEqualsToken = function (equalsToken) {
+            return this.update(this.modifiers, this.importKeyword, this.identifier, equalsToken, this.moduleReference, this.semicolonToken);
+        };
+
+        ImportDeclarationSyntax.prototype.withModuleReference = function (moduleReference) {
+            return this.update(this.modifiers, this.importKeyword, this.identifier, this.equalsToken, moduleReference, this.semicolonToken);
+        };
+
+        ImportDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.modifiers, this.importKeyword, this.identifier, this.equalsToken, this.moduleReference, semicolonToken);
+        };
+
+        ImportDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ImportDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ImportDeclarationSyntax = ImportDeclarationSyntax;
+
+    var ExportAssignmentSyntax = (function (_super) {
+        __extends(ExportAssignmentSyntax, _super);
+        function ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.exportKeyword = exportKeyword;
+            this.equalsToken = equalsToken;
+            this.identifier = identifier;
+            this.semicolonToken = semicolonToken;
+        }
+        ExportAssignmentSyntax.prototype.accept = function (visitor) {
+            return visitor.visitExportAssignment(this);
+        };
+
+        ExportAssignmentSyntax.prototype.kind = function () {
+            return 134 /* ExportAssignment */;
+        };
+
+        ExportAssignmentSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        ExportAssignmentSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.exportKeyword;
+                case 1:
+                    return this.equalsToken;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ExportAssignmentSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ExportAssignmentSyntax.prototype.update = function (exportKeyword, equalsToken, identifier, semicolonToken) {
+            if (this.exportKeyword === exportKeyword && this.equalsToken === equalsToken && this.identifier === identifier && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, this.parsedInStrictMode());
+        };
+
+        ExportAssignmentSyntax.create1 = function (identifier) {
+            return new ExportAssignmentSyntax(TypeScript.Syntax.token(47 /* ExportKeyword */), TypeScript.Syntax.token(107 /* EqualsToken */), identifier, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        ExportAssignmentSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ExportAssignmentSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ExportAssignmentSyntax.prototype.withExportKeyword = function (exportKeyword) {
+            return this.update(exportKeyword, this.equalsToken, this.identifier, this.semicolonToken);
+        };
+
+        ExportAssignmentSyntax.prototype.withEqualsToken = function (equalsToken) {
+            return this.update(this.exportKeyword, equalsToken, this.identifier, this.semicolonToken);
+        };
+
+        ExportAssignmentSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.exportKeyword, this.equalsToken, identifier, this.semicolonToken);
+        };
+
+        ExportAssignmentSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.exportKeyword, this.equalsToken, this.identifier, semicolonToken);
+        };
+
+        ExportAssignmentSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ExportAssignmentSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ExportAssignmentSyntax = ExportAssignmentSyntax;
+
+    var ClassDeclarationSyntax = (function (_super) {
+        __extends(ClassDeclarationSyntax, _super);
+        function ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.classKeyword = classKeyword;
+            this.identifier = identifier;
+            this.typeParameterList = typeParameterList;
+            this.heritageClauses = heritageClauses;
+            this.openBraceToken = openBraceToken;
+            this.classElements = classElements;
+            this.closeBraceToken = closeBraceToken;
+        }
+        ClassDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitClassDeclaration(this);
+        };
+
+        ClassDeclarationSyntax.prototype.kind = function () {
+            return 131 /* ClassDeclaration */;
+        };
+
+        ClassDeclarationSyntax.prototype.childCount = function () {
+            return 8;
+        };
+
+        ClassDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.classKeyword;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.typeParameterList;
+                case 4:
+                    return this.heritageClauses;
+                case 5:
+                    return this.openBraceToken;
+                case 6:
+                    return this.classElements;
+                case 7:
+                    return this.closeBraceToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ClassDeclarationSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ClassDeclarationSyntax.prototype.update = function (modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken) {
+            if (this.modifiers === modifiers && this.classKeyword === classKeyword && this.identifier === identifier && this.typeParameterList === typeParameterList && this.heritageClauses === heritageClauses && this.openBraceToken === openBraceToken && this.classElements === classElements && this.closeBraceToken === closeBraceToken) {
+                return this;
+            }
+
+            return new ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, this.parsedInStrictMode());
+        };
+
+        ClassDeclarationSyntax.create = function (classKeyword, identifier, openBraceToken, closeBraceToken) {
+            return new ClassDeclarationSyntax(TypeScript.Syntax.emptyList, classKeyword, identifier, null, TypeScript.Syntax.emptyList, openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false);
+        };
+
+        ClassDeclarationSyntax.create1 = function (identifier) {
+            return new ClassDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(44 /* ClassKeyword */), identifier, null, TypeScript.Syntax.emptyList, TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false);
+        };
+
+        ClassDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ClassDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ClassDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        ClassDeclarationSyntax.prototype.withClassKeyword = function (classKeyword) {
+            return this.update(this.modifiers, classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.modifiers, this.classKeyword, identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.withTypeParameterList = function (typeParameterList) {
+            return this.update(this.modifiers, this.classKeyword, this.identifier, typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.withHeritageClauses = function (heritageClauses) {
+            return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.withHeritageClause = function (heritageClause) {
+            return this.withHeritageClauses(TypeScript.Syntax.list([heritageClause]));
+        };
+
+        ClassDeclarationSyntax.prototype.withOpenBraceToken = function (openBraceToken) {
+            return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, openBraceToken, this.classElements, this.closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.withClassElements = function (classElements) {
+            return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, classElements, this.closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.withClassElement = function (classElement) {
+            return this.withClassElements(TypeScript.Syntax.list([classElement]));
+        };
+
+        ClassDeclarationSyntax.prototype.withCloseBraceToken = function (closeBraceToken) {
+            return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ClassDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ClassDeclarationSyntax = ClassDeclarationSyntax;
+
+    var InterfaceDeclarationSyntax = (function (_super) {
+        __extends(InterfaceDeclarationSyntax, _super);
+        function InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.interfaceKeyword = interfaceKeyword;
+            this.identifier = identifier;
+            this.typeParameterList = typeParameterList;
+            this.heritageClauses = heritageClauses;
+            this.body = body;
+        }
+        InterfaceDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitInterfaceDeclaration(this);
+        };
+
+        InterfaceDeclarationSyntax.prototype.kind = function () {
+            return 128 /* InterfaceDeclaration */;
+        };
+
+        InterfaceDeclarationSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        InterfaceDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.interfaceKeyword;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.typeParameterList;
+                case 4:
+                    return this.heritageClauses;
+                case 5:
+                    return this.body;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        InterfaceDeclarationSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        InterfaceDeclarationSyntax.prototype.update = function (modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body) {
+            if (this.modifiers === modifiers && this.interfaceKeyword === interfaceKeyword && this.identifier === identifier && this.typeParameterList === typeParameterList && this.heritageClauses === heritageClauses && this.body === body) {
+                return this;
+            }
+
+            return new InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, this.parsedInStrictMode());
+        };
+
+        InterfaceDeclarationSyntax.create = function (interfaceKeyword, identifier, body) {
+            return new InterfaceDeclarationSyntax(TypeScript.Syntax.emptyList, interfaceKeyword, identifier, null, TypeScript.Syntax.emptyList, body, false);
+        };
+
+        InterfaceDeclarationSyntax.create1 = function (identifier) {
+            return new InterfaceDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(52 /* InterfaceKeyword */), identifier, null, TypeScript.Syntax.emptyList, ObjectTypeSyntax.create1(), false);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.interfaceKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.body);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        InterfaceDeclarationSyntax.prototype.withInterfaceKeyword = function (interfaceKeyword) {
+            return this.update(this.modifiers, interfaceKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.body);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.modifiers, this.interfaceKeyword, identifier, this.typeParameterList, this.heritageClauses, this.body);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withTypeParameterList = function (typeParameterList) {
+            return this.update(this.modifiers, this.interfaceKeyword, this.identifier, typeParameterList, this.heritageClauses, this.body);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withHeritageClauses = function (heritageClauses) {
+            return this.update(this.modifiers, this.interfaceKeyword, this.identifier, this.typeParameterList, heritageClauses, this.body);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withHeritageClause = function (heritageClause) {
+            return this.withHeritageClauses(TypeScript.Syntax.list([heritageClause]));
+        };
+
+        InterfaceDeclarationSyntax.prototype.withBody = function (body) {
+            return this.update(this.modifiers, this.interfaceKeyword, this.identifier, this.typeParameterList, this.heritageClauses, body);
+        };
+
+        InterfaceDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return InterfaceDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.InterfaceDeclarationSyntax = InterfaceDeclarationSyntax;
+
+    var HeritageClauseSyntax = (function (_super) {
+        __extends(HeritageClauseSyntax, _super);
+        function HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.extendsOrImplementsKeyword = extendsOrImplementsKeyword;
+            this.typeNames = typeNames;
+
+            this._kind = kind;
+        }
+        HeritageClauseSyntax.prototype.accept = function (visitor) {
+            return visitor.visitHeritageClause(this);
+        };
+
+        HeritageClauseSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        HeritageClauseSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.extendsOrImplementsKeyword;
+                case 1:
+                    return this.typeNames;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        HeritageClauseSyntax.prototype.kind = function () {
+            return this._kind;
+        };
+
+        HeritageClauseSyntax.prototype.update = function (kind, extendsOrImplementsKeyword, typeNames) {
+            if (this._kind === kind && this.extendsOrImplementsKeyword === extendsOrImplementsKeyword && this.typeNames === typeNames) {
+                return this;
+            }
+
+            return new HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, this.parsedInStrictMode());
+        };
+
+        HeritageClauseSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        HeritageClauseSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        HeritageClauseSyntax.prototype.withKind = function (kind) {
+            return this.update(kind, this.extendsOrImplementsKeyword, this.typeNames);
+        };
+
+        HeritageClauseSyntax.prototype.withExtendsOrImplementsKeyword = function (extendsOrImplementsKeyword) {
+            return this.update(this._kind, extendsOrImplementsKeyword, this.typeNames);
+        };
+
+        HeritageClauseSyntax.prototype.withTypeNames = function (typeNames) {
+            return this.update(this._kind, this.extendsOrImplementsKeyword, typeNames);
+        };
+
+        HeritageClauseSyntax.prototype.withTypeName = function (typeName) {
+            return this.withTypeNames(TypeScript.Syntax.separatedList([typeName]));
+        };
+
+        HeritageClauseSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return HeritageClauseSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.HeritageClauseSyntax = HeritageClauseSyntax;
+
+    var ModuleDeclarationSyntax = (function (_super) {
+        __extends(ModuleDeclarationSyntax, _super);
+        function ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.moduleKeyword = moduleKeyword;
+            this.name = name;
+            this.stringLiteral = stringLiteral;
+            this.openBraceToken = openBraceToken;
+            this.moduleElements = moduleElements;
+            this.closeBraceToken = closeBraceToken;
+        }
+        ModuleDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitModuleDeclaration(this);
+        };
+
+        ModuleDeclarationSyntax.prototype.kind = function () {
+            return 130 /* ModuleDeclaration */;
+        };
+
+        ModuleDeclarationSyntax.prototype.childCount = function () {
+            return 7;
+        };
+
+        ModuleDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.moduleKeyword;
+                case 2:
+                    return this.name;
+                case 3:
+                    return this.stringLiteral;
+                case 4:
+                    return this.openBraceToken;
+                case 5:
+                    return this.moduleElements;
+                case 6:
+                    return this.closeBraceToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ModuleDeclarationSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ModuleDeclarationSyntax.prototype.update = function (modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken) {
+            if (this.modifiers === modifiers && this.moduleKeyword === moduleKeyword && this.name === name && this.stringLiteral === stringLiteral && this.openBraceToken === openBraceToken && this.moduleElements === moduleElements && this.closeBraceToken === closeBraceToken) {
+                return this;
+            }
+
+            return new ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, this.parsedInStrictMode());
+        };
+
+        ModuleDeclarationSyntax.create = function (moduleKeyword, openBraceToken, closeBraceToken) {
+            return new ModuleDeclarationSyntax(TypeScript.Syntax.emptyList, moduleKeyword, null, null, openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false);
+        };
+
+        ModuleDeclarationSyntax.create1 = function () {
+            return new ModuleDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(65 /* ModuleKeyword */), null, null, TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false);
+        };
+
+        ModuleDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ModuleDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ModuleDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken);
+        };
+
+        ModuleDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        ModuleDeclarationSyntax.prototype.withModuleKeyword = function (moduleKeyword) {
+            return this.update(this.modifiers, moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken);
+        };
+
+        ModuleDeclarationSyntax.prototype.withName = function (name) {
+            return this.update(this.modifiers, this.moduleKeyword, name, this.stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken);
+        };
+
+        ModuleDeclarationSyntax.prototype.withStringLiteral = function (stringLiteral) {
+            return this.update(this.modifiers, this.moduleKeyword, this.name, stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken);
+        };
+
+        ModuleDeclarationSyntax.prototype.withOpenBraceToken = function (openBraceToken) {
+            return this.update(this.modifiers, this.moduleKeyword, this.name, this.stringLiteral, openBraceToken, this.moduleElements, this.closeBraceToken);
+        };
+
+        ModuleDeclarationSyntax.prototype.withModuleElements = function (moduleElements) {
+            return this.update(this.modifiers, this.moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, moduleElements, this.closeBraceToken);
+        };
+
+        ModuleDeclarationSyntax.prototype.withModuleElement = function (moduleElement) {
+            return this.withModuleElements(TypeScript.Syntax.list([moduleElement]));
+        };
+
+        ModuleDeclarationSyntax.prototype.withCloseBraceToken = function (closeBraceToken) {
+            return this.update(this.modifiers, this.moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, this.moduleElements, closeBraceToken);
+        };
+
+        ModuleDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ModuleDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ModuleDeclarationSyntax = ModuleDeclarationSyntax;
+
+    var FunctionDeclarationSyntax = (function (_super) {
+        __extends(FunctionDeclarationSyntax, _super);
+        function FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.functionKeyword = functionKeyword;
+            this.identifier = identifier;
+            this.callSignature = callSignature;
+            this.block = block;
+            this.semicolonToken = semicolonToken;
+        }
+        FunctionDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitFunctionDeclaration(this);
+        };
+
+        FunctionDeclarationSyntax.prototype.kind = function () {
+            return 129 /* FunctionDeclaration */;
+        };
+
+        FunctionDeclarationSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        FunctionDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.functionKeyword;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.callSignature;
+                case 4:
+                    return this.block;
+                case 5:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        FunctionDeclarationSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        FunctionDeclarationSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        FunctionDeclarationSyntax.prototype.update = function (modifiers, functionKeyword, identifier, callSignature, block, semicolonToken) {
+            if (this.modifiers === modifiers && this.functionKeyword === functionKeyword && this.identifier === identifier && this.callSignature === callSignature && this.block === block && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, this.parsedInStrictMode());
+        };
+
+        FunctionDeclarationSyntax.create = function (functionKeyword, identifier, callSignature) {
+            return new FunctionDeclarationSyntax(TypeScript.Syntax.emptyList, functionKeyword, identifier, callSignature, null, null, false);
+        };
+
+        FunctionDeclarationSyntax.create1 = function (identifier) {
+            return new FunctionDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(27 /* FunctionKeyword */), identifier, CallSignatureSyntax.create1(), null, null, false);
+        };
+
+        FunctionDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        FunctionDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        FunctionDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.functionKeyword, this.identifier, this.callSignature, this.block, this.semicolonToken);
+        };
+
+        FunctionDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        FunctionDeclarationSyntax.prototype.withFunctionKeyword = function (functionKeyword) {
+            return this.update(this.modifiers, functionKeyword, this.identifier, this.callSignature, this.block, this.semicolonToken);
+        };
+
+        FunctionDeclarationSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.modifiers, this.functionKeyword, identifier, this.callSignature, this.block, this.semicolonToken);
+        };
+
+        FunctionDeclarationSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(this.modifiers, this.functionKeyword, this.identifier, callSignature, this.block, this.semicolonToken);
+        };
+
+        FunctionDeclarationSyntax.prototype.withBlock = function (block) {
+            return this.update(this.modifiers, this.functionKeyword, this.identifier, this.callSignature, block, this.semicolonToken);
+        };
+
+        FunctionDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.modifiers, this.functionKeyword, this.identifier, this.callSignature, this.block, semicolonToken);
+        };
+
+        FunctionDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.modifiers.childCount() > 0) {
+                return true;
+            }
+            if (this.callSignature.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.block !== null && this.block.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return FunctionDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.FunctionDeclarationSyntax = FunctionDeclarationSyntax;
+
+    var VariableStatementSyntax = (function (_super) {
+        __extends(VariableStatementSyntax, _super);
+        function VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.variableDeclaration = variableDeclaration;
+            this.semicolonToken = semicolonToken;
+        }
+        VariableStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitVariableStatement(this);
+        };
+
+        VariableStatementSyntax.prototype.kind = function () {
+            return 148 /* VariableStatement */;
+        };
+
+        VariableStatementSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        VariableStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.variableDeclaration;
+                case 2:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        VariableStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        VariableStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        VariableStatementSyntax.prototype.update = function (modifiers, variableDeclaration, semicolonToken) {
+            if (this.modifiers === modifiers && this.variableDeclaration === variableDeclaration && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, this.parsedInStrictMode());
+        };
+
+        VariableStatementSyntax.create = function (variableDeclaration, semicolonToken) {
+            return new VariableStatementSyntax(TypeScript.Syntax.emptyList, variableDeclaration, semicolonToken, false);
+        };
+
+        VariableStatementSyntax.create1 = function (variableDeclaration) {
+            return new VariableStatementSyntax(TypeScript.Syntax.emptyList, variableDeclaration, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        VariableStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        VariableStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        VariableStatementSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.variableDeclaration, this.semicolonToken);
+        };
+
+        VariableStatementSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        VariableStatementSyntax.prototype.withVariableDeclaration = function (variableDeclaration) {
+            return this.update(this.modifiers, variableDeclaration, this.semicolonToken);
+        };
+
+        VariableStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.modifiers, this.variableDeclaration, semicolonToken);
+        };
+
+        VariableStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.modifiers.childCount() > 0) {
+                return true;
+            }
+            if (this.variableDeclaration.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return VariableStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.VariableStatementSyntax = VariableStatementSyntax;
+
+    var VariableDeclarationSyntax = (function (_super) {
+        __extends(VariableDeclarationSyntax, _super);
+        function VariableDeclarationSyntax(varKeyword, variableDeclarators, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.varKeyword = varKeyword;
+            this.variableDeclarators = variableDeclarators;
+        }
+        VariableDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitVariableDeclaration(this);
+        };
+
+        VariableDeclarationSyntax.prototype.kind = function () {
+            return 224 /* VariableDeclaration */;
+        };
+
+        VariableDeclarationSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        VariableDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.varKeyword;
+                case 1:
+                    return this.variableDeclarators;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        VariableDeclarationSyntax.prototype.update = function (varKeyword, variableDeclarators) {
+            if (this.varKeyword === varKeyword && this.variableDeclarators === variableDeclarators) {
+                return this;
+            }
+
+            return new VariableDeclarationSyntax(varKeyword, variableDeclarators, this.parsedInStrictMode());
+        };
+
+        VariableDeclarationSyntax.create1 = function (variableDeclarators) {
+            return new VariableDeclarationSyntax(TypeScript.Syntax.token(40 /* VarKeyword */), variableDeclarators, false);
+        };
+
+        VariableDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        VariableDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        VariableDeclarationSyntax.prototype.withVarKeyword = function (varKeyword) {
+            return this.update(varKeyword, this.variableDeclarators);
+        };
+
+        VariableDeclarationSyntax.prototype.withVariableDeclarators = function (variableDeclarators) {
+            return this.update(this.varKeyword, variableDeclarators);
+        };
+
+        VariableDeclarationSyntax.prototype.withVariableDeclarator = function (variableDeclarator) {
+            return this.withVariableDeclarators(TypeScript.Syntax.separatedList([variableDeclarator]));
+        };
+
+        VariableDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.variableDeclarators.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return VariableDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.VariableDeclarationSyntax = VariableDeclarationSyntax;
+
+    var VariableDeclaratorSyntax = (function (_super) {
+        __extends(VariableDeclaratorSyntax, _super);
+        function VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.propertyName = propertyName;
+            this.typeAnnotation = typeAnnotation;
+            this.equalsValueClause = equalsValueClause;
+        }
+        VariableDeclaratorSyntax.prototype.accept = function (visitor) {
+            return visitor.visitVariableDeclarator(this);
+        };
+
+        VariableDeclaratorSyntax.prototype.kind = function () {
+            return 225 /* VariableDeclarator */;
+        };
+
+        VariableDeclaratorSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        VariableDeclaratorSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.propertyName;
+                case 1:
+                    return this.typeAnnotation;
+                case 2:
+                    return this.equalsValueClause;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        VariableDeclaratorSyntax.prototype.update = function (propertyName, typeAnnotation, equalsValueClause) {
+            if (this.propertyName === propertyName && this.typeAnnotation === typeAnnotation && this.equalsValueClause === equalsValueClause) {
+                return this;
+            }
+
+            return new VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, this.parsedInStrictMode());
+        };
+
+        VariableDeclaratorSyntax.create = function (propertyName) {
+            return new VariableDeclaratorSyntax(propertyName, null, null, false);
+        };
+
+        VariableDeclaratorSyntax.create1 = function (propertyName) {
+            return new VariableDeclaratorSyntax(propertyName, null, null, false);
+        };
+
+        VariableDeclaratorSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        VariableDeclaratorSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        VariableDeclaratorSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(propertyName, this.typeAnnotation, this.equalsValueClause);
+        };
+
+        VariableDeclaratorSyntax.prototype.withTypeAnnotation = function (typeAnnotation) {
+            return this.update(this.propertyName, typeAnnotation, this.equalsValueClause);
+        };
+
+        VariableDeclaratorSyntax.prototype.withEqualsValueClause = function (equalsValueClause) {
+            return this.update(this.propertyName, this.typeAnnotation, equalsValueClause);
+        };
+
+        VariableDeclaratorSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.typeAnnotation !== null) {
+                return true;
+            }
+            if (this.equalsValueClause !== null && this.equalsValueClause.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return VariableDeclaratorSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.VariableDeclaratorSyntax = VariableDeclaratorSyntax;
+
+    var EqualsValueClauseSyntax = (function (_super) {
+        __extends(EqualsValueClauseSyntax, _super);
+        function EqualsValueClauseSyntax(equalsToken, value, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.equalsToken = equalsToken;
+            this.value = value;
+        }
+        EqualsValueClauseSyntax.prototype.accept = function (visitor) {
+            return visitor.visitEqualsValueClause(this);
+        };
+
+        EqualsValueClauseSyntax.prototype.kind = function () {
+            return 232 /* EqualsValueClause */;
+        };
+
+        EqualsValueClauseSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        EqualsValueClauseSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.equalsToken;
+                case 1:
+                    return this.value;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        EqualsValueClauseSyntax.prototype.update = function (equalsToken, value) {
+            if (this.equalsToken === equalsToken && this.value === value) {
+                return this;
+            }
+
+            return new EqualsValueClauseSyntax(equalsToken, value, this.parsedInStrictMode());
+        };
+
+        EqualsValueClauseSyntax.create1 = function (value) {
+            return new EqualsValueClauseSyntax(TypeScript.Syntax.token(107 /* EqualsToken */), value, false);
+        };
+
+        EqualsValueClauseSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        EqualsValueClauseSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        EqualsValueClauseSyntax.prototype.withEqualsToken = function (equalsToken) {
+            return this.update(equalsToken, this.value);
+        };
+
+        EqualsValueClauseSyntax.prototype.withValue = function (value) {
+            return this.update(this.equalsToken, value);
+        };
+
+        EqualsValueClauseSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.value.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return EqualsValueClauseSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.EqualsValueClauseSyntax = EqualsValueClauseSyntax;
+
+    var PrefixUnaryExpressionSyntax = (function (_super) {
+        __extends(PrefixUnaryExpressionSyntax, _super);
+        function PrefixUnaryExpressionSyntax(kind, operatorToken, operand, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.operatorToken = operatorToken;
+            this.operand = operand;
+
+            this._kind = kind;
+        }
+        PrefixUnaryExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitPrefixUnaryExpression(this);
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.operatorToken;
+                case 1:
+                    return this.operand;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.kind = function () {
+            return this._kind;
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.update = function (kind, operatorToken, operand) {
+            if (this._kind === kind && this.operatorToken === operatorToken && this.operand === operand) {
+                return this;
+            }
+
+            return new PrefixUnaryExpressionSyntax(kind, operatorToken, operand, this.parsedInStrictMode());
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.withKind = function (kind) {
+            return this.update(kind, this.operatorToken, this.operand);
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.withOperatorToken = function (operatorToken) {
+            return this.update(this._kind, operatorToken, this.operand);
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.withOperand = function (operand) {
+            return this.update(this._kind, this.operatorToken, operand);
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.operand.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return PrefixUnaryExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.PrefixUnaryExpressionSyntax = PrefixUnaryExpressionSyntax;
+
+    var ArrayLiteralExpressionSyntax = (function (_super) {
+        __extends(ArrayLiteralExpressionSyntax, _super);
+        function ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.openBracketToken = openBracketToken;
+            this.expressions = expressions;
+            this.closeBracketToken = closeBracketToken;
+        }
+        ArrayLiteralExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitArrayLiteralExpression(this);
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.kind = function () {
+            return 214 /* ArrayLiteralExpression */;
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.openBracketToken;
+                case 1:
+                    return this.expressions;
+                case 2:
+                    return this.closeBracketToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.isPrimaryExpression = function () {
+            return true;
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.update = function (openBracketToken, expressions, closeBracketToken) {
+            if (this.openBracketToken === openBracketToken && this.expressions === expressions && this.closeBracketToken === closeBracketToken) {
+                return this;
+            }
+
+            return new ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, this.parsedInStrictMode());
+        };
+
+        ArrayLiteralExpressionSyntax.create = function (openBracketToken, closeBracketToken) {
+            return new ArrayLiteralExpressionSyntax(openBracketToken, TypeScript.Syntax.emptySeparatedList, closeBracketToken, false);
+        };
+
+        ArrayLiteralExpressionSyntax.create1 = function () {
+            return new ArrayLiteralExpressionSyntax(TypeScript.Syntax.token(74 /* OpenBracketToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(75 /* CloseBracketToken */), false);
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.withOpenBracketToken = function (openBracketToken) {
+            return this.update(openBracketToken, this.expressions, this.closeBracketToken);
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.withExpressions = function (expressions) {
+            return this.update(this.openBracketToken, expressions, this.closeBracketToken);
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.withExpressions(TypeScript.Syntax.separatedList([expression]));
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.withCloseBracketToken = function (closeBracketToken) {
+            return this.update(this.openBracketToken, this.expressions, closeBracketToken);
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expressions.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ArrayLiteralExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ArrayLiteralExpressionSyntax = ArrayLiteralExpressionSyntax;
+
+    var OmittedExpressionSyntax = (function (_super) {
+        __extends(OmittedExpressionSyntax, _super);
+        function OmittedExpressionSyntax(parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+        }
+        OmittedExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitOmittedExpression(this);
+        };
+
+        OmittedExpressionSyntax.prototype.kind = function () {
+            return 223 /* OmittedExpression */;
+        };
+
+        OmittedExpressionSyntax.prototype.childCount = function () {
+            return 0;
+        };
+
+        OmittedExpressionSyntax.prototype.childAt = function (slot) {
+            throw TypeScript.Errors.invalidOperation();
+        };
+
+        OmittedExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        OmittedExpressionSyntax.prototype.update = function () {
+            return this;
+        };
+
+        OmittedExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        OmittedExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        OmittedExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            return false;
+        };
+        return OmittedExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.OmittedExpressionSyntax = OmittedExpressionSyntax;
+
+    var ParenthesizedExpressionSyntax = (function (_super) {
+        __extends(ParenthesizedExpressionSyntax, _super);
+        function ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.openParenToken = openParenToken;
+            this.expression = expression;
+            this.closeParenToken = closeParenToken;
+        }
+        ParenthesizedExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitParenthesizedExpression(this);
+        };
+
+        ParenthesizedExpressionSyntax.prototype.kind = function () {
+            return 217 /* ParenthesizedExpression */;
+        };
+
+        ParenthesizedExpressionSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ParenthesizedExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.openParenToken;
+                case 1:
+                    return this.expression;
+                case 2:
+                    return this.closeParenToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ParenthesizedExpressionSyntax.prototype.isPrimaryExpression = function () {
+            return true;
+        };
+
+        ParenthesizedExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        ParenthesizedExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        ParenthesizedExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        ParenthesizedExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        ParenthesizedExpressionSyntax.prototype.update = function (openParenToken, expression, closeParenToken) {
+            if (this.openParenToken === openParenToken && this.expression === expression && this.closeParenToken === closeParenToken) {
+                return this;
+            }
+
+            return new ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, this.parsedInStrictMode());
+        };
+
+        ParenthesizedExpressionSyntax.create1 = function (expression) {
+            return new ParenthesizedExpressionSyntax(TypeScript.Syntax.token(72 /* OpenParenToken */), expression, TypeScript.Syntax.token(73 /* CloseParenToken */), false);
+        };
+
+        ParenthesizedExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ParenthesizedExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ParenthesizedExpressionSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(openParenToken, this.expression, this.closeParenToken);
+        };
+
+        ParenthesizedExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.openParenToken, expression, this.closeParenToken);
+        };
+
+        ParenthesizedExpressionSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.openParenToken, this.expression, closeParenToken);
+        };
+
+        ParenthesizedExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ParenthesizedExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ParenthesizedExpressionSyntax = ParenthesizedExpressionSyntax;
+
+    var SimpleArrowFunctionExpressionSyntax = (function (_super) {
+        __extends(SimpleArrowFunctionExpressionSyntax, _super);
+        function SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.identifier = identifier;
+            this.equalsGreaterThanToken = equalsGreaterThanToken;
+            this.block = block;
+            this.expression = expression;
+        }
+        SimpleArrowFunctionExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitSimpleArrowFunctionExpression(this);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.kind = function () {
+            return 219 /* SimpleArrowFunctionExpression */;
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.identifier;
+                case 1:
+                    return this.equalsGreaterThanToken;
+                case 2:
+                    return this.block;
+                case 3:
+                    return this.expression;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.isArrowFunctionExpression = function () {
+            return true;
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.update = function (identifier, equalsGreaterThanToken, block, expression) {
+            if (this.identifier === identifier && this.equalsGreaterThanToken === equalsGreaterThanToken && this.block === block && this.expression === expression) {
+                return this;
+            }
+
+            return new SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, this.parsedInStrictMode());
+        };
+
+        SimpleArrowFunctionExpressionSyntax.create = function (identifier, equalsGreaterThanToken) {
+            return new SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, null, null, false);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.create1 = function (identifier) {
+            return new SimpleArrowFunctionExpressionSyntax(identifier, TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), null, null, false);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(identifier, this.equalsGreaterThanToken, this.block, this.expression);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) {
+            return this.update(this.identifier, equalsGreaterThanToken, this.block, this.expression);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.withBlock = function (block) {
+            return this.update(this.identifier, this.equalsGreaterThanToken, block, this.expression);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.identifier, this.equalsGreaterThanToken, this.block, expression);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return SimpleArrowFunctionExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.SimpleArrowFunctionExpressionSyntax = SimpleArrowFunctionExpressionSyntax;
+
+    var ParenthesizedArrowFunctionExpressionSyntax = (function (_super) {
+        __extends(ParenthesizedArrowFunctionExpressionSyntax, _super);
+        function ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.callSignature = callSignature;
+            this.equalsGreaterThanToken = equalsGreaterThanToken;
+            this.block = block;
+            this.expression = expression;
+        }
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitParenthesizedArrowFunctionExpression(this);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.kind = function () {
+            return 218 /* ParenthesizedArrowFunctionExpression */;
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.callSignature;
+                case 1:
+                    return this.equalsGreaterThanToken;
+                case 2:
+                    return this.block;
+                case 3:
+                    return this.expression;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.isArrowFunctionExpression = function () {
+            return true;
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.update = function (callSignature, equalsGreaterThanToken, block, expression) {
+            if (this.callSignature === callSignature && this.equalsGreaterThanToken === equalsGreaterThanToken && this.block === block && this.expression === expression) {
+                return this;
+            }
+
+            return new ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, this.parsedInStrictMode());
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.create = function (callSignature, equalsGreaterThanToken) {
+            return new ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, null, null, false);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.create1 = function () {
+            return new ParenthesizedArrowFunctionExpressionSyntax(CallSignatureSyntax.create1(), TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), null, null, false);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(callSignature, this.equalsGreaterThanToken, this.block, this.expression);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) {
+            return this.update(this.callSignature, equalsGreaterThanToken, this.block, this.expression);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.withBlock = function (block) {
+            return this.update(this.callSignature, this.equalsGreaterThanToken, block, this.expression);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.callSignature, this.equalsGreaterThanToken, this.block, expression);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ParenthesizedArrowFunctionExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ParenthesizedArrowFunctionExpressionSyntax = ParenthesizedArrowFunctionExpressionSyntax;
+
+    var QualifiedNameSyntax = (function (_super) {
+        __extends(QualifiedNameSyntax, _super);
+        function QualifiedNameSyntax(left, dotToken, right, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.left = left;
+            this.dotToken = dotToken;
+            this.right = right;
+        }
+        QualifiedNameSyntax.prototype.accept = function (visitor) {
+            return visitor.visitQualifiedName(this);
+        };
+
+        QualifiedNameSyntax.prototype.kind = function () {
+            return 121 /* QualifiedName */;
+        };
+
+        QualifiedNameSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        QualifiedNameSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.left;
+                case 1:
+                    return this.dotToken;
+                case 2:
+                    return this.right;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        QualifiedNameSyntax.prototype.isName = function () {
+            return true;
+        };
+
+        QualifiedNameSyntax.prototype.isType = function () {
+            return true;
+        };
+
+        QualifiedNameSyntax.prototype.update = function (left, dotToken, right) {
+            if (this.left === left && this.dotToken === dotToken && this.right === right) {
+                return this;
+            }
+
+            return new QualifiedNameSyntax(left, dotToken, right, this.parsedInStrictMode());
+        };
+
+        QualifiedNameSyntax.create1 = function (left, right) {
+            return new QualifiedNameSyntax(left, TypeScript.Syntax.token(76 /* DotToken */), right, false);
+        };
+
+        QualifiedNameSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        QualifiedNameSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        QualifiedNameSyntax.prototype.withLeft = function (left) {
+            return this.update(left, this.dotToken, this.right);
+        };
+
+        QualifiedNameSyntax.prototype.withDotToken = function (dotToken) {
+            return this.update(this.left, dotToken, this.right);
+        };
+
+        QualifiedNameSyntax.prototype.withRight = function (right) {
+            return this.update(this.left, this.dotToken, right);
+        };
+
+        QualifiedNameSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return QualifiedNameSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.QualifiedNameSyntax = QualifiedNameSyntax;
+
+    var TypeArgumentListSyntax = (function (_super) {
+        __extends(TypeArgumentListSyntax, _super);
+        function TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.lessThanToken = lessThanToken;
+            this.typeArguments = typeArguments;
+            this.greaterThanToken = greaterThanToken;
+        }
+        TypeArgumentListSyntax.prototype.accept = function (visitor) {
+            return visitor.visitTypeArgumentList(this);
+        };
+
+        TypeArgumentListSyntax.prototype.kind = function () {
+            return 228 /* TypeArgumentList */;
+        };
+
+        TypeArgumentListSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        TypeArgumentListSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.lessThanToken;
+                case 1:
+                    return this.typeArguments;
+                case 2:
+                    return this.greaterThanToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        TypeArgumentListSyntax.prototype.update = function (lessThanToken, typeArguments, greaterThanToken) {
+            if (this.lessThanToken === lessThanToken && this.typeArguments === typeArguments && this.greaterThanToken === greaterThanToken) {
+                return this;
+            }
+
+            return new TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, this.parsedInStrictMode());
+        };
+
+        TypeArgumentListSyntax.create = function (lessThanToken, greaterThanToken) {
+            return new TypeArgumentListSyntax(lessThanToken, TypeScript.Syntax.emptySeparatedList, greaterThanToken, false);
+        };
+
+        TypeArgumentListSyntax.create1 = function () {
+            return new TypeArgumentListSyntax(TypeScript.Syntax.token(80 /* LessThanToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(81 /* GreaterThanToken */), false);
+        };
+
+        TypeArgumentListSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        TypeArgumentListSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        TypeArgumentListSyntax.prototype.withLessThanToken = function (lessThanToken) {
+            return this.update(lessThanToken, this.typeArguments, this.greaterThanToken);
+        };
+
+        TypeArgumentListSyntax.prototype.withTypeArguments = function (typeArguments) {
+            return this.update(this.lessThanToken, typeArguments, this.greaterThanToken);
+        };
+
+        TypeArgumentListSyntax.prototype.withTypeArgument = function (typeArgument) {
+            return this.withTypeArguments(TypeScript.Syntax.separatedList([typeArgument]));
+        };
+
+        TypeArgumentListSyntax.prototype.withGreaterThanToken = function (greaterThanToken) {
+            return this.update(this.lessThanToken, this.typeArguments, greaterThanToken);
+        };
+
+        TypeArgumentListSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return TypeArgumentListSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.TypeArgumentListSyntax = TypeArgumentListSyntax;
+
+    var ConstructorTypeSyntax = (function (_super) {
+        __extends(ConstructorTypeSyntax, _super);
+        function ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.newKeyword = newKeyword;
+            this.typeParameterList = typeParameterList;
+            this.parameterList = parameterList;
+            this.equalsGreaterThanToken = equalsGreaterThanToken;
+            this.type = type;
+        }
+        ConstructorTypeSyntax.prototype.accept = function (visitor) {
+            return visitor.visitConstructorType(this);
+        };
+
+        ConstructorTypeSyntax.prototype.kind = function () {
+            return 125 /* ConstructorType */;
+        };
+
+        ConstructorTypeSyntax.prototype.childCount = function () {
+            return 5;
+        };
+
+        ConstructorTypeSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.newKeyword;
+                case 1:
+                    return this.typeParameterList;
+                case 2:
+                    return this.parameterList;
+                case 3:
+                    return this.equalsGreaterThanToken;
+                case 4:
+                    return this.type;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ConstructorTypeSyntax.prototype.isType = function () {
+            return true;
+        };
+
+        ConstructorTypeSyntax.prototype.update = function (newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type) {
+            if (this.newKeyword === newKeyword && this.typeParameterList === typeParameterList && this.parameterList === parameterList && this.equalsGreaterThanToken === equalsGreaterThanToken && this.type === type) {
+                return this;
+            }
+
+            return new ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, this.parsedInStrictMode());
+        };
+
+        ConstructorTypeSyntax.create = function (newKeyword, parameterList, equalsGreaterThanToken, type) {
+            return new ConstructorTypeSyntax(newKeyword, null, parameterList, equalsGreaterThanToken, type, false);
+        };
+
+        ConstructorTypeSyntax.create1 = function (type) {
+            return new ConstructorTypeSyntax(TypeScript.Syntax.token(31 /* NewKeyword */), null, ParameterListSyntax.create1(), TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), type, false);
+        };
+
+        ConstructorTypeSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ConstructorTypeSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ConstructorTypeSyntax.prototype.withNewKeyword = function (newKeyword) {
+            return this.update(newKeyword, this.typeParameterList, this.parameterList, this.equalsGreaterThanToken, this.type);
+        };
+
+        ConstructorTypeSyntax.prototype.withTypeParameterList = function (typeParameterList) {
+            return this.update(this.newKeyword, typeParameterList, this.parameterList, this.equalsGreaterThanToken, this.type);
+        };
+
+        ConstructorTypeSyntax.prototype.withParameterList = function (parameterList) {
+            return this.update(this.newKeyword, this.typeParameterList, parameterList, this.equalsGreaterThanToken, this.type);
+        };
+
+        ConstructorTypeSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) {
+            return this.update(this.newKeyword, this.typeParameterList, this.parameterList, equalsGreaterThanToken, this.type);
+        };
+
+        ConstructorTypeSyntax.prototype.withType = function (type) {
+            return this.update(this.newKeyword, this.typeParameterList, this.parameterList, this.equalsGreaterThanToken, type);
+        };
+
+        ConstructorTypeSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ConstructorTypeSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ConstructorTypeSyntax = ConstructorTypeSyntax;
+
+    var FunctionTypeSyntax = (function (_super) {
+        __extends(FunctionTypeSyntax, _super);
+        function FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.typeParameterList = typeParameterList;
+            this.parameterList = parameterList;
+            this.equalsGreaterThanToken = equalsGreaterThanToken;
+            this.type = type;
+        }
+        FunctionTypeSyntax.prototype.accept = function (visitor) {
+            return visitor.visitFunctionType(this);
+        };
+
+        FunctionTypeSyntax.prototype.kind = function () {
+            return 123 /* FunctionType */;
+        };
+
+        FunctionTypeSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        FunctionTypeSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.typeParameterList;
+                case 1:
+                    return this.parameterList;
+                case 2:
+                    return this.equalsGreaterThanToken;
+                case 3:
+                    return this.type;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        FunctionTypeSyntax.prototype.isType = function () {
+            return true;
+        };
+
+        FunctionTypeSyntax.prototype.update = function (typeParameterList, parameterList, equalsGreaterThanToken, type) {
+            if (this.typeParameterList === typeParameterList && this.parameterList === parameterList && this.equalsGreaterThanToken === equalsGreaterThanToken && this.type === type) {
+                return this;
+            }
+
+            return new FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, this.parsedInStrictMode());
+        };
+
+        FunctionTypeSyntax.create = function (parameterList, equalsGreaterThanToken, type) {
+            return new FunctionTypeSyntax(null, parameterList, equalsGreaterThanToken, type, false);
+        };
+
+        FunctionTypeSyntax.create1 = function (type) {
+            return new FunctionTypeSyntax(null, ParameterListSyntax.create1(), TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), type, false);
+        };
+
+        FunctionTypeSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        FunctionTypeSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        FunctionTypeSyntax.prototype.withTypeParameterList = function (typeParameterList) {
+            return this.update(typeParameterList, this.parameterList, this.equalsGreaterThanToken, this.type);
+        };
+
+        FunctionTypeSyntax.prototype.withParameterList = function (parameterList) {
+            return this.update(this.typeParameterList, parameterList, this.equalsGreaterThanToken, this.type);
+        };
+
+        FunctionTypeSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) {
+            return this.update(this.typeParameterList, this.parameterList, equalsGreaterThanToken, this.type);
+        };
+
+        FunctionTypeSyntax.prototype.withType = function (type) {
+            return this.update(this.typeParameterList, this.parameterList, this.equalsGreaterThanToken, type);
+        };
+
+        FunctionTypeSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return FunctionTypeSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.FunctionTypeSyntax = FunctionTypeSyntax;
+
+    var ObjectTypeSyntax = (function (_super) {
+        __extends(ObjectTypeSyntax, _super);
+        function ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.openBraceToken = openBraceToken;
+            this.typeMembers = typeMembers;
+            this.closeBraceToken = closeBraceToken;
+        }
+        ObjectTypeSyntax.prototype.accept = function (visitor) {
+            return visitor.visitObjectType(this);
+        };
+
+        ObjectTypeSyntax.prototype.kind = function () {
+            return 122 /* ObjectType */;
+        };
+
+        ObjectTypeSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ObjectTypeSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.openBraceToken;
+                case 1:
+                    return this.typeMembers;
+                case 2:
+                    return this.closeBraceToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ObjectTypeSyntax.prototype.isType = function () {
+            return true;
+        };
+
+        ObjectTypeSyntax.prototype.update = function (openBraceToken, typeMembers, closeBraceToken) {
+            if (this.openBraceToken === openBraceToken && this.typeMembers === typeMembers && this.closeBraceToken === closeBraceToken) {
+                return this;
+            }
+
+            return new ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, this.parsedInStrictMode());
+        };
+
+        ObjectTypeSyntax.create = function (openBraceToken, closeBraceToken) {
+            return new ObjectTypeSyntax(openBraceToken, TypeScript.Syntax.emptySeparatedList, closeBraceToken, false);
+        };
+
+        ObjectTypeSyntax.create1 = function () {
+            return new ObjectTypeSyntax(TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false);
+        };
+
+        ObjectTypeSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ObjectTypeSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ObjectTypeSyntax.prototype.withOpenBraceToken = function (openBraceToken) {
+            return this.update(openBraceToken, this.typeMembers, this.closeBraceToken);
+        };
+
+        ObjectTypeSyntax.prototype.withTypeMembers = function (typeMembers) {
+            return this.update(this.openBraceToken, typeMembers, this.closeBraceToken);
+        };
+
+        ObjectTypeSyntax.prototype.withTypeMember = function (typeMember) {
+            return this.withTypeMembers(TypeScript.Syntax.separatedList([typeMember]));
+        };
+
+        ObjectTypeSyntax.prototype.withCloseBraceToken = function (closeBraceToken) {
+            return this.update(this.openBraceToken, this.typeMembers, closeBraceToken);
+        };
+
+        ObjectTypeSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ObjectTypeSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ObjectTypeSyntax = ObjectTypeSyntax;
+
+    var ArrayTypeSyntax = (function (_super) {
+        __extends(ArrayTypeSyntax, _super);
+        function ArrayTypeSyntax(type, openBracketToken, closeBracketToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.type = type;
+            this.openBracketToken = openBracketToken;
+            this.closeBracketToken = closeBracketToken;
+        }
+        ArrayTypeSyntax.prototype.accept = function (visitor) {
+            return visitor.visitArrayType(this);
+        };
+
+        ArrayTypeSyntax.prototype.kind = function () {
+            return 124 /* ArrayType */;
+        };
+
+        ArrayTypeSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ArrayTypeSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.type;
+                case 1:
+                    return this.openBracketToken;
+                case 2:
+                    return this.closeBracketToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ArrayTypeSyntax.prototype.isType = function () {
+            return true;
+        };
+
+        ArrayTypeSyntax.prototype.update = function (type, openBracketToken, closeBracketToken) {
+            if (this.type === type && this.openBracketToken === openBracketToken && this.closeBracketToken === closeBracketToken) {
+                return this;
+            }
+
+            return new ArrayTypeSyntax(type, openBracketToken, closeBracketToken, this.parsedInStrictMode());
+        };
+
+        ArrayTypeSyntax.create1 = function (type) {
+            return new ArrayTypeSyntax(type, TypeScript.Syntax.token(74 /* OpenBracketToken */), TypeScript.Syntax.token(75 /* CloseBracketToken */), false);
+        };
+
+        ArrayTypeSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ArrayTypeSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ArrayTypeSyntax.prototype.withType = function (type) {
+            return this.update(type, this.openBracketToken, this.closeBracketToken);
+        };
+
+        ArrayTypeSyntax.prototype.withOpenBracketToken = function (openBracketToken) {
+            return this.update(this.type, openBracketToken, this.closeBracketToken);
+        };
+
+        ArrayTypeSyntax.prototype.withCloseBracketToken = function (closeBracketToken) {
+            return this.update(this.type, this.openBracketToken, closeBracketToken);
+        };
+
+        ArrayTypeSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ArrayTypeSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ArrayTypeSyntax = ArrayTypeSyntax;
+
+    var GenericTypeSyntax = (function (_super) {
+        __extends(GenericTypeSyntax, _super);
+        function GenericTypeSyntax(name, typeArgumentList, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.name = name;
+            this.typeArgumentList = typeArgumentList;
+        }
+        GenericTypeSyntax.prototype.accept = function (visitor) {
+            return visitor.visitGenericType(this);
+        };
+
+        GenericTypeSyntax.prototype.kind = function () {
+            return 126 /* GenericType */;
+        };
+
+        GenericTypeSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        GenericTypeSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.name;
+                case 1:
+                    return this.typeArgumentList;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        GenericTypeSyntax.prototype.isType = function () {
+            return true;
+        };
+
+        GenericTypeSyntax.prototype.update = function (name, typeArgumentList) {
+            if (this.name === name && this.typeArgumentList === typeArgumentList) {
+                return this;
+            }
+
+            return new GenericTypeSyntax(name, typeArgumentList, this.parsedInStrictMode());
+        };
+
+        GenericTypeSyntax.create1 = function (name) {
+            return new GenericTypeSyntax(name, TypeArgumentListSyntax.create1(), false);
+        };
+
+        GenericTypeSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        GenericTypeSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        GenericTypeSyntax.prototype.withName = function (name) {
+            return this.update(name, this.typeArgumentList);
+        };
+
+        GenericTypeSyntax.prototype.withTypeArgumentList = function (typeArgumentList) {
+            return this.update(this.name, typeArgumentList);
+        };
+
+        GenericTypeSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return GenericTypeSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.GenericTypeSyntax = GenericTypeSyntax;
+
+    var TypeQuerySyntax = (function (_super) {
+        __extends(TypeQuerySyntax, _super);
+        function TypeQuerySyntax(typeOfKeyword, name, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.typeOfKeyword = typeOfKeyword;
+            this.name = name;
+        }
+        TypeQuerySyntax.prototype.accept = function (visitor) {
+            return visitor.visitTypeQuery(this);
+        };
+
+        TypeQuerySyntax.prototype.kind = function () {
+            return 127 /* TypeQuery */;
+        };
+
+        TypeQuerySyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        TypeQuerySyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.typeOfKeyword;
+                case 1:
+                    return this.name;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        TypeQuerySyntax.prototype.isType = function () {
+            return true;
+        };
+
+        TypeQuerySyntax.prototype.update = function (typeOfKeyword, name) {
+            if (this.typeOfKeyword === typeOfKeyword && this.name === name) {
+                return this;
+            }
+
+            return new TypeQuerySyntax(typeOfKeyword, name, this.parsedInStrictMode());
+        };
+
+        TypeQuerySyntax.create1 = function (name) {
+            return new TypeQuerySyntax(TypeScript.Syntax.token(39 /* TypeOfKeyword */), name, false);
+        };
+
+        TypeQuerySyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        TypeQuerySyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        TypeQuerySyntax.prototype.withTypeOfKeyword = function (typeOfKeyword) {
+            return this.update(typeOfKeyword, this.name);
+        };
+
+        TypeQuerySyntax.prototype.withName = function (name) {
+            return this.update(this.typeOfKeyword, name);
+        };
+
+        TypeQuerySyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return TypeQuerySyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.TypeQuerySyntax = TypeQuerySyntax;
+
+    var TypeAnnotationSyntax = (function (_super) {
+        __extends(TypeAnnotationSyntax, _super);
+        function TypeAnnotationSyntax(colonToken, type, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.colonToken = colonToken;
+            this.type = type;
+        }
+        TypeAnnotationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitTypeAnnotation(this);
+        };
+
+        TypeAnnotationSyntax.prototype.kind = function () {
+            return 244 /* TypeAnnotation */;
+        };
+
+        TypeAnnotationSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        TypeAnnotationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.colonToken;
+                case 1:
+                    return this.type;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        TypeAnnotationSyntax.prototype.update = function (colonToken, type) {
+            if (this.colonToken === colonToken && this.type === type) {
+                return this;
+            }
+
+            return new TypeAnnotationSyntax(colonToken, type, this.parsedInStrictMode());
+        };
+
+        TypeAnnotationSyntax.create1 = function (type) {
+            return new TypeAnnotationSyntax(TypeScript.Syntax.token(106 /* ColonToken */), type, false);
+        };
+
+        TypeAnnotationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        TypeAnnotationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        TypeAnnotationSyntax.prototype.withColonToken = function (colonToken) {
+            return this.update(colonToken, this.type);
+        };
+
+        TypeAnnotationSyntax.prototype.withType = function (type) {
+            return this.update(this.colonToken, type);
+        };
+
+        TypeAnnotationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return TypeAnnotationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.TypeAnnotationSyntax = TypeAnnotationSyntax;
+
+    var BlockSyntax = (function (_super) {
+        __extends(BlockSyntax, _super);
+        function BlockSyntax(openBraceToken, statements, closeBraceToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.openBraceToken = openBraceToken;
+            this.statements = statements;
+            this.closeBraceToken = closeBraceToken;
+        }
+        BlockSyntax.prototype.accept = function (visitor) {
+            return visitor.visitBlock(this);
+        };
+
+        BlockSyntax.prototype.kind = function () {
+            return 146 /* Block */;
+        };
+
+        BlockSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        BlockSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.openBraceToken;
+                case 1:
+                    return this.statements;
+                case 2:
+                    return this.closeBraceToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        BlockSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        BlockSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        BlockSyntax.prototype.update = function (openBraceToken, statements, closeBraceToken) {
+            if (this.openBraceToken === openBraceToken && this.statements === statements && this.closeBraceToken === closeBraceToken) {
+                return this;
+            }
+
+            return new BlockSyntax(openBraceToken, statements, closeBraceToken, this.parsedInStrictMode());
+        };
+
+        BlockSyntax.create = function (openBraceToken, closeBraceToken) {
+            return new BlockSyntax(openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false);
+        };
+
+        BlockSyntax.create1 = function () {
+            return new BlockSyntax(TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false);
+        };
+
+        BlockSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        BlockSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        BlockSyntax.prototype.withOpenBraceToken = function (openBraceToken) {
+            return this.update(openBraceToken, this.statements, this.closeBraceToken);
+        };
+
+        BlockSyntax.prototype.withStatements = function (statements) {
+            return this.update(this.openBraceToken, statements, this.closeBraceToken);
+        };
+
+        BlockSyntax.prototype.withStatement = function (statement) {
+            return this.withStatements(TypeScript.Syntax.list([statement]));
+        };
+
+        BlockSyntax.prototype.withCloseBraceToken = function (closeBraceToken) {
+            return this.update(this.openBraceToken, this.statements, closeBraceToken);
+        };
+
+        BlockSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.statements.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return BlockSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.BlockSyntax = BlockSyntax;
+
+    var ParameterSyntax = (function (_super) {
+        __extends(ParameterSyntax, _super);
+        function ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.dotDotDotToken = dotDotDotToken;
+            this.modifiers = modifiers;
+            this.identifier = identifier;
+            this.questionToken = questionToken;
+            this.typeAnnotation = typeAnnotation;
+            this.equalsValueClause = equalsValueClause;
+        }
+        ParameterSyntax.prototype.accept = function (visitor) {
+            return visitor.visitParameter(this);
+        };
+
+        ParameterSyntax.prototype.kind = function () {
+            return 242 /* Parameter */;
+        };
+
+        ParameterSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        ParameterSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.dotDotDotToken;
+                case 1:
+                    return this.modifiers;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.questionToken;
+                case 4:
+                    return this.typeAnnotation;
+                case 5:
+                    return this.equalsValueClause;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ParameterSyntax.prototype.update = function (dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) {
+            if (this.dotDotDotToken === dotDotDotToken && this.modifiers === modifiers && this.identifier === identifier && this.questionToken === questionToken && this.typeAnnotation === typeAnnotation && this.equalsValueClause === equalsValueClause) {
+                return this;
+            }
+
+            return new ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, this.parsedInStrictMode());
+        };
+
+        ParameterSyntax.create = function (identifier) {
+            return new ParameterSyntax(null, TypeScript.Syntax.emptyList, identifier, null, null, null, false);
+        };
+
+        ParameterSyntax.create1 = function (identifier) {
+            return new ParameterSyntax(null, TypeScript.Syntax.emptyList, identifier, null, null, null, false);
+        };
+
+        ParameterSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ParameterSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ParameterSyntax.prototype.withDotDotDotToken = function (dotDotDotToken) {
+            return this.update(dotDotDotToken, this.modifiers, this.identifier, this.questionToken, this.typeAnnotation, this.equalsValueClause);
+        };
+
+        ParameterSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(this.dotDotDotToken, modifiers, this.identifier, this.questionToken, this.typeAnnotation, this.equalsValueClause);
+        };
+
+        ParameterSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        ParameterSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.dotDotDotToken, this.modifiers, identifier, this.questionToken, this.typeAnnotation, this.equalsValueClause);
+        };
+
+        ParameterSyntax.prototype.withQuestionToken = function (questionToken) {
+            return this.update(this.dotDotDotToken, this.modifiers, this.identifier, questionToken, this.typeAnnotation, this.equalsValueClause);
+        };
+
+        ParameterSyntax.prototype.withTypeAnnotation = function (typeAnnotation) {
+            return this.update(this.dotDotDotToken, this.modifiers, this.identifier, this.questionToken, typeAnnotation, this.equalsValueClause);
+        };
+
+        ParameterSyntax.prototype.withEqualsValueClause = function (equalsValueClause) {
+            return this.update(this.dotDotDotToken, this.modifiers, this.identifier, this.questionToken, this.typeAnnotation, equalsValueClause);
+        };
+
+        ParameterSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.dotDotDotToken !== null) {
+                return true;
+            }
+            if (this.modifiers.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.questionToken !== null) {
+                return true;
+            }
+            if (this.typeAnnotation !== null) {
+                return true;
+            }
+            if (this.equalsValueClause !== null) {
+                return true;
+            }
+            return false;
+        };
+        return ParameterSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ParameterSyntax = ParameterSyntax;
+
+    var MemberAccessExpressionSyntax = (function (_super) {
+        __extends(MemberAccessExpressionSyntax, _super);
+        function MemberAccessExpressionSyntax(expression, dotToken, name, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.expression = expression;
+            this.dotToken = dotToken;
+            this.name = name;
+        }
+        MemberAccessExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitMemberAccessExpression(this);
+        };
+
+        MemberAccessExpressionSyntax.prototype.kind = function () {
+            return 212 /* MemberAccessExpression */;
+        };
+
+        MemberAccessExpressionSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        MemberAccessExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.expression;
+                case 1:
+                    return this.dotToken;
+                case 2:
+                    return this.name;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        MemberAccessExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        MemberAccessExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        MemberAccessExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        MemberAccessExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        MemberAccessExpressionSyntax.prototype.update = function (expression, dotToken, name) {
+            if (this.expression === expression && this.dotToken === dotToken && this.name === name) {
+                return this;
+            }
+
+            return new MemberAccessExpressionSyntax(expression, dotToken, name, this.parsedInStrictMode());
+        };
+
+        MemberAccessExpressionSyntax.create1 = function (expression, name) {
+            return new MemberAccessExpressionSyntax(expression, TypeScript.Syntax.token(76 /* DotToken */), name, false);
+        };
+
+        MemberAccessExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        MemberAccessExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        MemberAccessExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(expression, this.dotToken, this.name);
+        };
+
+        MemberAccessExpressionSyntax.prototype.withDotToken = function (dotToken) {
+            return this.update(this.expression, dotToken, this.name);
+        };
+
+        MemberAccessExpressionSyntax.prototype.withName = function (name) {
+            return this.update(this.expression, this.dotToken, name);
+        };
+
+        MemberAccessExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return MemberAccessExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.MemberAccessExpressionSyntax = MemberAccessExpressionSyntax;
+
+    var PostfixUnaryExpressionSyntax = (function (_super) {
+        __extends(PostfixUnaryExpressionSyntax, _super);
+        function PostfixUnaryExpressionSyntax(kind, operand, operatorToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.operand = operand;
+            this.operatorToken = operatorToken;
+
+            this._kind = kind;
+        }
+        PostfixUnaryExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitPostfixUnaryExpression(this);
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.operand;
+                case 1:
+                    return this.operatorToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.kind = function () {
+            return this._kind;
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.update = function (kind, operand, operatorToken) {
+            if (this._kind === kind && this.operand === operand && this.operatorToken === operatorToken) {
+                return this;
+            }
+
+            return new PostfixUnaryExpressionSyntax(kind, operand, operatorToken, this.parsedInStrictMode());
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.withKind = function (kind) {
+            return this.update(kind, this.operand, this.operatorToken);
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.withOperand = function (operand) {
+            return this.update(this._kind, operand, this.operatorToken);
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.withOperatorToken = function (operatorToken) {
+            return this.update(this._kind, this.operand, operatorToken);
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.operand.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return PostfixUnaryExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.PostfixUnaryExpressionSyntax = PostfixUnaryExpressionSyntax;
+
+    var ElementAccessExpressionSyntax = (function (_super) {
+        __extends(ElementAccessExpressionSyntax, _super);
+        function ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.expression = expression;
+            this.openBracketToken = openBracketToken;
+            this.argumentExpression = argumentExpression;
+            this.closeBracketToken = closeBracketToken;
+        }
+        ElementAccessExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitElementAccessExpression(this);
+        };
+
+        ElementAccessExpressionSyntax.prototype.kind = function () {
+            return 221 /* ElementAccessExpression */;
+        };
+
+        ElementAccessExpressionSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        ElementAccessExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.expression;
+                case 1:
+                    return this.openBracketToken;
+                case 2:
+                    return this.argumentExpression;
+                case 3:
+                    return this.closeBracketToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ElementAccessExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        ElementAccessExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        ElementAccessExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        ElementAccessExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        ElementAccessExpressionSyntax.prototype.update = function (expression, openBracketToken, argumentExpression, closeBracketToken) {
+            if (this.expression === expression && this.openBracketToken === openBracketToken && this.argumentExpression === argumentExpression && this.closeBracketToken === closeBracketToken) {
+                return this;
+            }
+
+            return new ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, this.parsedInStrictMode());
+        };
+
+        ElementAccessExpressionSyntax.create1 = function (expression, argumentExpression) {
+            return new ElementAccessExpressionSyntax(expression, TypeScript.Syntax.token(74 /* OpenBracketToken */), argumentExpression, TypeScript.Syntax.token(75 /* CloseBracketToken */), false);
+        };
+
+        ElementAccessExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ElementAccessExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ElementAccessExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(expression, this.openBracketToken, this.argumentExpression, this.closeBracketToken);
+        };
+
+        ElementAccessExpressionSyntax.prototype.withOpenBracketToken = function (openBracketToken) {
+            return this.update(this.expression, openBracketToken, this.argumentExpression, this.closeBracketToken);
+        };
+
+        ElementAccessExpressionSyntax.prototype.withArgumentExpression = function (argumentExpression) {
+            return this.update(this.expression, this.openBracketToken, argumentExpression, this.closeBracketToken);
+        };
+
+        ElementAccessExpressionSyntax.prototype.withCloseBracketToken = function (closeBracketToken) {
+            return this.update(this.expression, this.openBracketToken, this.argumentExpression, closeBracketToken);
+        };
+
+        ElementAccessExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.argumentExpression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ElementAccessExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ElementAccessExpressionSyntax = ElementAccessExpressionSyntax;
+
+    var InvocationExpressionSyntax = (function (_super) {
+        __extends(InvocationExpressionSyntax, _super);
+        function InvocationExpressionSyntax(expression, argumentList, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.expression = expression;
+            this.argumentList = argumentList;
+        }
+        InvocationExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitInvocationExpression(this);
+        };
+
+        InvocationExpressionSyntax.prototype.kind = function () {
+            return 213 /* InvocationExpression */;
+        };
+
+        InvocationExpressionSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        InvocationExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.expression;
+                case 1:
+                    return this.argumentList;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        InvocationExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        InvocationExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        InvocationExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        InvocationExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        InvocationExpressionSyntax.prototype.update = function (expression, argumentList) {
+            if (this.expression === expression && this.argumentList === argumentList) {
+                return this;
+            }
+
+            return new InvocationExpressionSyntax(expression, argumentList, this.parsedInStrictMode());
+        };
+
+        InvocationExpressionSyntax.create1 = function (expression) {
+            return new InvocationExpressionSyntax(expression, ArgumentListSyntax.create1(), false);
+        };
+
+        InvocationExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        InvocationExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        InvocationExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(expression, this.argumentList);
+        };
+
+        InvocationExpressionSyntax.prototype.withArgumentList = function (argumentList) {
+            return this.update(this.expression, argumentList);
+        };
+
+        InvocationExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.argumentList.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return InvocationExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.InvocationExpressionSyntax = InvocationExpressionSyntax;
+
+    var ArgumentListSyntax = (function (_super) {
+        __extends(ArgumentListSyntax, _super);
+        function ArgumentListSyntax(typeArgumentList, openParenToken, _arguments, closeParenToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.typeArgumentList = typeArgumentList;
+            this.openParenToken = openParenToken;
+            this.closeParenToken = closeParenToken;
+
+            this.arguments = _arguments;
+        }
+        ArgumentListSyntax.prototype.accept = function (visitor) {
+            return visitor.visitArgumentList(this);
+        };
+
+        ArgumentListSyntax.prototype.kind = function () {
+            return 226 /* ArgumentList */;
+        };
+
+        ArgumentListSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        ArgumentListSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.typeArgumentList;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.arguments;
+                case 3:
+                    return this.closeParenToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ArgumentListSyntax.prototype.update = function (typeArgumentList, openParenToken, _arguments, closeParenToken) {
+            if (this.typeArgumentList === typeArgumentList && this.openParenToken === openParenToken && this.arguments === _arguments && this.closeParenToken === closeParenToken) {
+                return this;
+            }
+
+            return new ArgumentListSyntax(typeArgumentList, openParenToken, _arguments, closeParenToken, this.parsedInStrictMode());
+        };
+
+        ArgumentListSyntax.create = function (openParenToken, closeParenToken) {
+            return new ArgumentListSyntax(null, openParenToken, TypeScript.Syntax.emptySeparatedList, closeParenToken, false);
+        };
+
+        ArgumentListSyntax.create1 = function () {
+            return new ArgumentListSyntax(null, TypeScript.Syntax.token(72 /* OpenParenToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(73 /* CloseParenToken */), false);
+        };
+
+        ArgumentListSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ArgumentListSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ArgumentListSyntax.prototype.withTypeArgumentList = function (typeArgumentList) {
+            return this.update(typeArgumentList, this.openParenToken, this.arguments, this.closeParenToken);
+        };
+
+        ArgumentListSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.typeArgumentList, openParenToken, this.arguments, this.closeParenToken);
+        };
+
+        ArgumentListSyntax.prototype.withArguments = function (_arguments) {
+            return this.update(this.typeArgumentList, this.openParenToken, _arguments, this.closeParenToken);
+        };
+
+        ArgumentListSyntax.prototype.withArgument = function (_argument) {
+            return this.withArguments(TypeScript.Syntax.separatedList([_argument]));
+        };
+
+        ArgumentListSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.typeArgumentList, this.openParenToken, this.arguments, closeParenToken);
+        };
+
+        ArgumentListSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.typeArgumentList !== null && this.typeArgumentList.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.arguments.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ArgumentListSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ArgumentListSyntax = ArgumentListSyntax;
+
+    var BinaryExpressionSyntax = (function (_super) {
+        __extends(BinaryExpressionSyntax, _super);
+        function BinaryExpressionSyntax(kind, left, operatorToken, right, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.left = left;
+            this.operatorToken = operatorToken;
+            this.right = right;
+
+            this._kind = kind;
+        }
+        BinaryExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitBinaryExpression(this);
+        };
+
+        BinaryExpressionSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        BinaryExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.left;
+                case 1:
+                    return this.operatorToken;
+                case 2:
+                    return this.right;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        BinaryExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        BinaryExpressionSyntax.prototype.kind = function () {
+            return this._kind;
+        };
+
+        BinaryExpressionSyntax.prototype.update = function (kind, left, operatorToken, right) {
+            if (this._kind === kind && this.left === left && this.operatorToken === operatorToken && this.right === right) {
+                return this;
+            }
+
+            return new BinaryExpressionSyntax(kind, left, operatorToken, right, this.parsedInStrictMode());
+        };
+
+        BinaryExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        BinaryExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        BinaryExpressionSyntax.prototype.withKind = function (kind) {
+            return this.update(kind, this.left, this.operatorToken, this.right);
+        };
+
+        BinaryExpressionSyntax.prototype.withLeft = function (left) {
+            return this.update(this._kind, left, this.operatorToken, this.right);
+        };
+
+        BinaryExpressionSyntax.prototype.withOperatorToken = function (operatorToken) {
+            return this.update(this._kind, this.left, operatorToken, this.right);
+        };
+
+        BinaryExpressionSyntax.prototype.withRight = function (right) {
+            return this.update(this._kind, this.left, this.operatorToken, right);
+        };
+
+        BinaryExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.left.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.right.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return BinaryExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.BinaryExpressionSyntax = BinaryExpressionSyntax;
+
+    var ConditionalExpressionSyntax = (function (_super) {
+        __extends(ConditionalExpressionSyntax, _super);
+        function ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.condition = condition;
+            this.questionToken = questionToken;
+            this.whenTrue = whenTrue;
+            this.colonToken = colonToken;
+            this.whenFalse = whenFalse;
+        }
+        ConditionalExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitConditionalExpression(this);
+        };
+
+        ConditionalExpressionSyntax.prototype.kind = function () {
+            return 186 /* ConditionalExpression */;
+        };
+
+        ConditionalExpressionSyntax.prototype.childCount = function () {
+            return 5;
+        };
+
+        ConditionalExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.condition;
+                case 1:
+                    return this.questionToken;
+                case 2:
+                    return this.whenTrue;
+                case 3:
+                    return this.colonToken;
+                case 4:
+                    return this.whenFalse;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ConditionalExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        ConditionalExpressionSyntax.prototype.update = function (condition, questionToken, whenTrue, colonToken, whenFalse) {
+            if (this.condition === condition && this.questionToken === questionToken && this.whenTrue === whenTrue && this.colonToken === colonToken && this.whenFalse === whenFalse) {
+                return this;
+            }
+
+            return new ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, this.parsedInStrictMode());
+        };
+
+        ConditionalExpressionSyntax.create1 = function (condition, whenTrue, whenFalse) {
+            return new ConditionalExpressionSyntax(condition, TypeScript.Syntax.token(105 /* QuestionToken */), whenTrue, TypeScript.Syntax.token(106 /* ColonToken */), whenFalse, false);
+        };
+
+        ConditionalExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ConditionalExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ConditionalExpressionSyntax.prototype.withCondition = function (condition) {
+            return this.update(condition, this.questionToken, this.whenTrue, this.colonToken, this.whenFalse);
+        };
+
+        ConditionalExpressionSyntax.prototype.withQuestionToken = function (questionToken) {
+            return this.update(this.condition, questionToken, this.whenTrue, this.colonToken, this.whenFalse);
+        };
+
+        ConditionalExpressionSyntax.prototype.withWhenTrue = function (whenTrue) {
+            return this.update(this.condition, this.questionToken, whenTrue, this.colonToken, this.whenFalse);
+        };
+
+        ConditionalExpressionSyntax.prototype.withColonToken = function (colonToken) {
+            return this.update(this.condition, this.questionToken, this.whenTrue, colonToken, this.whenFalse);
+        };
+
+        ConditionalExpressionSyntax.prototype.withWhenFalse = function (whenFalse) {
+            return this.update(this.condition, this.questionToken, this.whenTrue, this.colonToken, whenFalse);
+        };
+
+        ConditionalExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.condition.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.whenTrue.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.whenFalse.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ConditionalExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ConditionalExpressionSyntax = ConditionalExpressionSyntax;
+
+    var ConstructSignatureSyntax = (function (_super) {
+        __extends(ConstructSignatureSyntax, _super);
+        function ConstructSignatureSyntax(newKeyword, callSignature, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.newKeyword = newKeyword;
+            this.callSignature = callSignature;
+        }
+        ConstructSignatureSyntax.prototype.accept = function (visitor) {
+            return visitor.visitConstructSignature(this);
+        };
+
+        ConstructSignatureSyntax.prototype.kind = function () {
+            return 143 /* ConstructSignature */;
+        };
+
+        ConstructSignatureSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        ConstructSignatureSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.newKeyword;
+                case 1:
+                    return this.callSignature;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ConstructSignatureSyntax.prototype.isTypeMember = function () {
+            return true;
+        };
+
+        ConstructSignatureSyntax.prototype.update = function (newKeyword, callSignature) {
+            if (this.newKeyword === newKeyword && this.callSignature === callSignature) {
+                return this;
+            }
+
+            return new ConstructSignatureSyntax(newKeyword, callSignature, this.parsedInStrictMode());
+        };
+
+        ConstructSignatureSyntax.create1 = function () {
+            return new ConstructSignatureSyntax(TypeScript.Syntax.token(31 /* NewKeyword */), CallSignatureSyntax.create1(), false);
+        };
+
+        ConstructSignatureSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ConstructSignatureSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ConstructSignatureSyntax.prototype.withNewKeyword = function (newKeyword) {
+            return this.update(newKeyword, this.callSignature);
+        };
+
+        ConstructSignatureSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(this.newKeyword, callSignature);
+        };
+
+        ConstructSignatureSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ConstructSignatureSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ConstructSignatureSyntax = ConstructSignatureSyntax;
+
+    var MethodSignatureSyntax = (function (_super) {
+        __extends(MethodSignatureSyntax, _super);
+        function MethodSignatureSyntax(propertyName, questionToken, callSignature, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.propertyName = propertyName;
+            this.questionToken = questionToken;
+            this.callSignature = callSignature;
+        }
+        MethodSignatureSyntax.prototype.accept = function (visitor) {
+            return visitor.visitMethodSignature(this);
+        };
+
+        MethodSignatureSyntax.prototype.kind = function () {
+            return 145 /* MethodSignature */;
+        };
+
+        MethodSignatureSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        MethodSignatureSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.propertyName;
+                case 1:
+                    return this.questionToken;
+                case 2:
+                    return this.callSignature;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        MethodSignatureSyntax.prototype.isTypeMember = function () {
+            return true;
+        };
+
+        MethodSignatureSyntax.prototype.update = function (propertyName, questionToken, callSignature) {
+            if (this.propertyName === propertyName && this.questionToken === questionToken && this.callSignature === callSignature) {
+                return this;
+            }
+
+            return new MethodSignatureSyntax(propertyName, questionToken, callSignature, this.parsedInStrictMode());
+        };
+
+        MethodSignatureSyntax.create = function (propertyName, callSignature) {
+            return new MethodSignatureSyntax(propertyName, null, callSignature, false);
+        };
+
+        MethodSignatureSyntax.create1 = function (propertyName) {
+            return new MethodSignatureSyntax(propertyName, null, CallSignatureSyntax.create1(), false);
+        };
+
+        MethodSignatureSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        MethodSignatureSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        MethodSignatureSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(propertyName, this.questionToken, this.callSignature);
+        };
+
+        MethodSignatureSyntax.prototype.withQuestionToken = function (questionToken) {
+            return this.update(this.propertyName, questionToken, this.callSignature);
+        };
+
+        MethodSignatureSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(this.propertyName, this.questionToken, callSignature);
+        };
+
+        MethodSignatureSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.callSignature.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return MethodSignatureSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.MethodSignatureSyntax = MethodSignatureSyntax;
+
+    var IndexSignatureSyntax = (function (_super) {
+        __extends(IndexSignatureSyntax, _super);
+        function IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.openBracketToken = openBracketToken;
+            this.parameter = parameter;
+            this.closeBracketToken = closeBracketToken;
+            this.typeAnnotation = typeAnnotation;
+        }
+        IndexSignatureSyntax.prototype.accept = function (visitor) {
+            return visitor.visitIndexSignature(this);
+        };
+
+        IndexSignatureSyntax.prototype.kind = function () {
+            return 144 /* IndexSignature */;
+        };
+
+        IndexSignatureSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        IndexSignatureSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.openBracketToken;
+                case 1:
+                    return this.parameter;
+                case 2:
+                    return this.closeBracketToken;
+                case 3:
+                    return this.typeAnnotation;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        IndexSignatureSyntax.prototype.isTypeMember = function () {
+            return true;
+        };
+
+        IndexSignatureSyntax.prototype.update = function (openBracketToken, parameter, closeBracketToken, typeAnnotation) {
+            if (this.openBracketToken === openBracketToken && this.parameter === parameter && this.closeBracketToken === closeBracketToken && this.typeAnnotation === typeAnnotation) {
+                return this;
+            }
+
+            return new IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, this.parsedInStrictMode());
+        };
+
+        IndexSignatureSyntax.create = function (openBracketToken, parameter, closeBracketToken) {
+            return new IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, null, false);
+        };
+
+        IndexSignatureSyntax.create1 = function (parameter) {
+            return new IndexSignatureSyntax(TypeScript.Syntax.token(74 /* OpenBracketToken */), parameter, TypeScript.Syntax.token(75 /* CloseBracketToken */), null, false);
+        };
+
+        IndexSignatureSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        IndexSignatureSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        IndexSignatureSyntax.prototype.withOpenBracketToken = function (openBracketToken) {
+            return this.update(openBracketToken, this.parameter, this.closeBracketToken, this.typeAnnotation);
+        };
+
+        IndexSignatureSyntax.prototype.withParameter = function (parameter) {
+            return this.update(this.openBracketToken, parameter, this.closeBracketToken, this.typeAnnotation);
+        };
+
+        IndexSignatureSyntax.prototype.withCloseBracketToken = function (closeBracketToken) {
+            return this.update(this.openBracketToken, this.parameter, closeBracketToken, this.typeAnnotation);
+        };
+
+        IndexSignatureSyntax.prototype.withTypeAnnotation = function (typeAnnotation) {
+            return this.update(this.openBracketToken, this.parameter, this.closeBracketToken, typeAnnotation);
+        };
+
+        IndexSignatureSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return IndexSignatureSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.IndexSignatureSyntax = IndexSignatureSyntax;
+
+    var PropertySignatureSyntax = (function (_super) {
+        __extends(PropertySignatureSyntax, _super);
+        function PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.propertyName = propertyName;
+            this.questionToken = questionToken;
+            this.typeAnnotation = typeAnnotation;
+        }
+        PropertySignatureSyntax.prototype.accept = function (visitor) {
+            return visitor.visitPropertySignature(this);
+        };
+
+        PropertySignatureSyntax.prototype.kind = function () {
+            return 141 /* PropertySignature */;
+        };
+
+        PropertySignatureSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        PropertySignatureSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.propertyName;
+                case 1:
+                    return this.questionToken;
+                case 2:
+                    return this.typeAnnotation;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        PropertySignatureSyntax.prototype.isTypeMember = function () {
+            return true;
+        };
+
+        PropertySignatureSyntax.prototype.update = function (propertyName, questionToken, typeAnnotation) {
+            if (this.propertyName === propertyName && this.questionToken === questionToken && this.typeAnnotation === typeAnnotation) {
+                return this;
+            }
+
+            return new PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, this.parsedInStrictMode());
+        };
+
+        PropertySignatureSyntax.create = function (propertyName) {
+            return new PropertySignatureSyntax(propertyName, null, null, false);
+        };
+
+        PropertySignatureSyntax.create1 = function (propertyName) {
+            return new PropertySignatureSyntax(propertyName, null, null, false);
+        };
+
+        PropertySignatureSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        PropertySignatureSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        PropertySignatureSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(propertyName, this.questionToken, this.typeAnnotation);
+        };
+
+        PropertySignatureSyntax.prototype.withQuestionToken = function (questionToken) {
+            return this.update(this.propertyName, questionToken, this.typeAnnotation);
+        };
+
+        PropertySignatureSyntax.prototype.withTypeAnnotation = function (typeAnnotation) {
+            return this.update(this.propertyName, this.questionToken, typeAnnotation);
+        };
+
+        PropertySignatureSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return PropertySignatureSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.PropertySignatureSyntax = PropertySignatureSyntax;
+
+    var CallSignatureSyntax = (function (_super) {
+        __extends(CallSignatureSyntax, _super);
+        function CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.typeParameterList = typeParameterList;
+            this.parameterList = parameterList;
+            this.typeAnnotation = typeAnnotation;
+        }
+        CallSignatureSyntax.prototype.accept = function (visitor) {
+            return visitor.visitCallSignature(this);
+        };
+
+        CallSignatureSyntax.prototype.kind = function () {
+            return 142 /* CallSignature */;
+        };
+
+        CallSignatureSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        CallSignatureSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.typeParameterList;
+                case 1:
+                    return this.parameterList;
+                case 2:
+                    return this.typeAnnotation;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        CallSignatureSyntax.prototype.isTypeMember = function () {
+            return true;
+        };
+
+        CallSignatureSyntax.prototype.update = function (typeParameterList, parameterList, typeAnnotation) {
+            if (this.typeParameterList === typeParameterList && this.parameterList === parameterList && this.typeAnnotation === typeAnnotation) {
+                return this;
+            }
+
+            return new CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, this.parsedInStrictMode());
+        };
+
+        CallSignatureSyntax.create = function (parameterList) {
+            return new CallSignatureSyntax(null, parameterList, null, false);
+        };
+
+        CallSignatureSyntax.create1 = function () {
+            return new CallSignatureSyntax(null, ParameterListSyntax.create1(), null, false);
+        };
+
+        CallSignatureSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        CallSignatureSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        CallSignatureSyntax.prototype.withTypeParameterList = function (typeParameterList) {
+            return this.update(typeParameterList, this.parameterList, this.typeAnnotation);
+        };
+
+        CallSignatureSyntax.prototype.withParameterList = function (parameterList) {
+            return this.update(this.typeParameterList, parameterList, this.typeAnnotation);
+        };
+
+        CallSignatureSyntax.prototype.withTypeAnnotation = function (typeAnnotation) {
+            return this.update(this.typeParameterList, this.parameterList, typeAnnotation);
+        };
+
+        CallSignatureSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.typeParameterList !== null) {
+                return true;
+            }
+            if (this.parameterList.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.typeAnnotation !== null) {
+                return true;
+            }
+            return false;
+        };
+        return CallSignatureSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.CallSignatureSyntax = CallSignatureSyntax;
+
+    var ParameterListSyntax = (function (_super) {
+        __extends(ParameterListSyntax, _super);
+        function ParameterListSyntax(openParenToken, parameters, closeParenToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.openParenToken = openParenToken;
+            this.parameters = parameters;
+            this.closeParenToken = closeParenToken;
+        }
+        ParameterListSyntax.prototype.accept = function (visitor) {
+            return visitor.visitParameterList(this);
+        };
+
+        ParameterListSyntax.prototype.kind = function () {
+            return 227 /* ParameterList */;
+        };
+
+        ParameterListSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ParameterListSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.openParenToken;
+                case 1:
+                    return this.parameters;
+                case 2:
+                    return this.closeParenToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ParameterListSyntax.prototype.update = function (openParenToken, parameters, closeParenToken) {
+            if (this.openParenToken === openParenToken && this.parameters === parameters && this.closeParenToken === closeParenToken) {
+                return this;
+            }
+
+            return new ParameterListSyntax(openParenToken, parameters, closeParenToken, this.parsedInStrictMode());
+        };
+
+        ParameterListSyntax.create = function (openParenToken, closeParenToken) {
+            return new ParameterListSyntax(openParenToken, TypeScript.Syntax.emptySeparatedList, closeParenToken, false);
+        };
+
+        ParameterListSyntax.create1 = function () {
+            return new ParameterListSyntax(TypeScript.Syntax.token(72 /* OpenParenToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(73 /* CloseParenToken */), false);
+        };
+
+        ParameterListSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ParameterListSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ParameterListSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(openParenToken, this.parameters, this.closeParenToken);
+        };
+
+        ParameterListSyntax.prototype.withParameters = function (parameters) {
+            return this.update(this.openParenToken, parameters, this.closeParenToken);
+        };
+
+        ParameterListSyntax.prototype.withParameter = function (parameter) {
+            return this.withParameters(TypeScript.Syntax.separatedList([parameter]));
+        };
+
+        ParameterListSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.openParenToken, this.parameters, closeParenToken);
+        };
+
+        ParameterListSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.parameters.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ParameterListSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ParameterListSyntax = ParameterListSyntax;
+
+    var TypeParameterListSyntax = (function (_super) {
+        __extends(TypeParameterListSyntax, _super);
+        function TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.lessThanToken = lessThanToken;
+            this.typeParameters = typeParameters;
+            this.greaterThanToken = greaterThanToken;
+        }
+        TypeParameterListSyntax.prototype.accept = function (visitor) {
+            return visitor.visitTypeParameterList(this);
+        };
+
+        TypeParameterListSyntax.prototype.kind = function () {
+            return 229 /* TypeParameterList */;
+        };
+
+        TypeParameterListSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        TypeParameterListSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.lessThanToken;
+                case 1:
+                    return this.typeParameters;
+                case 2:
+                    return this.greaterThanToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        TypeParameterListSyntax.prototype.update = function (lessThanToken, typeParameters, greaterThanToken) {
+            if (this.lessThanToken === lessThanToken && this.typeParameters === typeParameters && this.greaterThanToken === greaterThanToken) {
+                return this;
+            }
+
+            return new TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, this.parsedInStrictMode());
+        };
+
+        TypeParameterListSyntax.create = function (lessThanToken, greaterThanToken) {
+            return new TypeParameterListSyntax(lessThanToken, TypeScript.Syntax.emptySeparatedList, greaterThanToken, false);
+        };
+
+        TypeParameterListSyntax.create1 = function () {
+            return new TypeParameterListSyntax(TypeScript.Syntax.token(80 /* LessThanToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(81 /* GreaterThanToken */), false);
+        };
+
+        TypeParameterListSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        TypeParameterListSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        TypeParameterListSyntax.prototype.withLessThanToken = function (lessThanToken) {
+            return this.update(lessThanToken, this.typeParameters, this.greaterThanToken);
+        };
+
+        TypeParameterListSyntax.prototype.withTypeParameters = function (typeParameters) {
+            return this.update(this.lessThanToken, typeParameters, this.greaterThanToken);
+        };
+
+        TypeParameterListSyntax.prototype.withTypeParameter = function (typeParameter) {
+            return this.withTypeParameters(TypeScript.Syntax.separatedList([typeParameter]));
+        };
+
+        TypeParameterListSyntax.prototype.withGreaterThanToken = function (greaterThanToken) {
+            return this.update(this.lessThanToken, this.typeParameters, greaterThanToken);
+        };
+
+        TypeParameterListSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return TypeParameterListSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.TypeParameterListSyntax = TypeParameterListSyntax;
+
+    var TypeParameterSyntax = (function (_super) {
+        __extends(TypeParameterSyntax, _super);
+        function TypeParameterSyntax(identifier, constraint, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.identifier = identifier;
+            this.constraint = constraint;
+        }
+        TypeParameterSyntax.prototype.accept = function (visitor) {
+            return visitor.visitTypeParameter(this);
+        };
+
+        TypeParameterSyntax.prototype.kind = function () {
+            return 238 /* TypeParameter */;
+        };
+
+        TypeParameterSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        TypeParameterSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.identifier;
+                case 1:
+                    return this.constraint;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        TypeParameterSyntax.prototype.update = function (identifier, constraint) {
+            if (this.identifier === identifier && this.constraint === constraint) {
+                return this;
+            }
+
+            return new TypeParameterSyntax(identifier, constraint, this.parsedInStrictMode());
+        };
+
+        TypeParameterSyntax.create = function (identifier) {
+            return new TypeParameterSyntax(identifier, null, false);
+        };
+
+        TypeParameterSyntax.create1 = function (identifier) {
+            return new TypeParameterSyntax(identifier, null, false);
+        };
+
+        TypeParameterSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        TypeParameterSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        TypeParameterSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(identifier, this.constraint);
+        };
+
+        TypeParameterSyntax.prototype.withConstraint = function (constraint) {
+            return this.update(this.identifier, constraint);
+        };
+
+        TypeParameterSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return TypeParameterSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.TypeParameterSyntax = TypeParameterSyntax;
+
+    var ConstraintSyntax = (function (_super) {
+        __extends(ConstraintSyntax, _super);
+        function ConstraintSyntax(extendsKeyword, type, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.extendsKeyword = extendsKeyword;
+            this.type = type;
+        }
+        ConstraintSyntax.prototype.accept = function (visitor) {
+            return visitor.visitConstraint(this);
+        };
+
+        ConstraintSyntax.prototype.kind = function () {
+            return 239 /* Constraint */;
+        };
+
+        ConstraintSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        ConstraintSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.extendsKeyword;
+                case 1:
+                    return this.type;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ConstraintSyntax.prototype.update = function (extendsKeyword, type) {
+            if (this.extendsKeyword === extendsKeyword && this.type === type) {
+                return this;
+            }
+
+            return new ConstraintSyntax(extendsKeyword, type, this.parsedInStrictMode());
+        };
+
+        ConstraintSyntax.create1 = function (type) {
+            return new ConstraintSyntax(TypeScript.Syntax.token(48 /* ExtendsKeyword */), type, false);
+        };
+
+        ConstraintSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ConstraintSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ConstraintSyntax.prototype.withExtendsKeyword = function (extendsKeyword) {
+            return this.update(extendsKeyword, this.type);
+        };
+
+        ConstraintSyntax.prototype.withType = function (type) {
+            return this.update(this.extendsKeyword, type);
+        };
+
+        ConstraintSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ConstraintSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ConstraintSyntax = ConstraintSyntax;
+
+    var ElseClauseSyntax = (function (_super) {
+        __extends(ElseClauseSyntax, _super);
+        function ElseClauseSyntax(elseKeyword, statement, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.elseKeyword = elseKeyword;
+            this.statement = statement;
+        }
+        ElseClauseSyntax.prototype.accept = function (visitor) {
+            return visitor.visitElseClause(this);
+        };
+
+        ElseClauseSyntax.prototype.kind = function () {
+            return 235 /* ElseClause */;
+        };
+
+        ElseClauseSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        ElseClauseSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.elseKeyword;
+                case 1:
+                    return this.statement;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ElseClauseSyntax.prototype.update = function (elseKeyword, statement) {
+            if (this.elseKeyword === elseKeyword && this.statement === statement) {
+                return this;
+            }
+
+            return new ElseClauseSyntax(elseKeyword, statement, this.parsedInStrictMode());
+        };
+
+        ElseClauseSyntax.create1 = function (statement) {
+            return new ElseClauseSyntax(TypeScript.Syntax.token(23 /* ElseKeyword */), statement, false);
+        };
+
+        ElseClauseSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ElseClauseSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ElseClauseSyntax.prototype.withElseKeyword = function (elseKeyword) {
+            return this.update(elseKeyword, this.statement);
+        };
+
+        ElseClauseSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.elseKeyword, statement);
+        };
+
+        ElseClauseSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ElseClauseSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ElseClauseSyntax = ElseClauseSyntax;
+
+    var IfStatementSyntax = (function (_super) {
+        __extends(IfStatementSyntax, _super);
+        function IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.ifKeyword = ifKeyword;
+            this.openParenToken = openParenToken;
+            this.condition = condition;
+            this.closeParenToken = closeParenToken;
+            this.statement = statement;
+            this.elseClause = elseClause;
+        }
+        IfStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitIfStatement(this);
+        };
+
+        IfStatementSyntax.prototype.kind = function () {
+            return 147 /* IfStatement */;
+        };
+
+        IfStatementSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        IfStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.ifKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.condition;
+                case 3:
+                    return this.closeParenToken;
+                case 4:
+                    return this.statement;
+                case 5:
+                    return this.elseClause;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        IfStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        IfStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        IfStatementSyntax.prototype.update = function (ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause) {
+            if (this.ifKeyword === ifKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.statement === statement && this.elseClause === elseClause) {
+                return this;
+            }
+
+            return new IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, this.parsedInStrictMode());
+        };
+
+        IfStatementSyntax.create = function (ifKeyword, openParenToken, condition, closeParenToken, statement) {
+            return new IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, null, false);
+        };
+
+        IfStatementSyntax.create1 = function (condition, statement) {
+            return new IfStatementSyntax(TypeScript.Syntax.token(28 /* IfKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, null, false);
+        };
+
+        IfStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        IfStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        IfStatementSyntax.prototype.withIfKeyword = function (ifKeyword) {
+            return this.update(ifKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement, this.elseClause);
+        };
+
+        IfStatementSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.ifKeyword, openParenToken, this.condition, this.closeParenToken, this.statement, this.elseClause);
+        };
+
+        IfStatementSyntax.prototype.withCondition = function (condition) {
+            return this.update(this.ifKeyword, this.openParenToken, condition, this.closeParenToken, this.statement, this.elseClause);
+        };
+
+        IfStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.ifKeyword, this.openParenToken, this.condition, closeParenToken, this.statement, this.elseClause);
+        };
+
+        IfStatementSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.ifKeyword, this.openParenToken, this.condition, this.closeParenToken, statement, this.elseClause);
+        };
+
+        IfStatementSyntax.prototype.withElseClause = function (elseClause) {
+            return this.update(this.ifKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement, elseClause);
+        };
+
+        IfStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.condition.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.elseClause !== null && this.elseClause.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return IfStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.IfStatementSyntax = IfStatementSyntax;
+
+    var ExpressionStatementSyntax = (function (_super) {
+        __extends(ExpressionStatementSyntax, _super);
+        function ExpressionStatementSyntax(expression, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.expression = expression;
+            this.semicolonToken = semicolonToken;
+        }
+        ExpressionStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitExpressionStatement(this);
+        };
+
+        ExpressionStatementSyntax.prototype.kind = function () {
+            return 149 /* ExpressionStatement */;
+        };
+
+        ExpressionStatementSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        ExpressionStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.expression;
+                case 1:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ExpressionStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        ExpressionStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ExpressionStatementSyntax.prototype.update = function (expression, semicolonToken) {
+            if (this.expression === expression && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new ExpressionStatementSyntax(expression, semicolonToken, this.parsedInStrictMode());
+        };
+
+        ExpressionStatementSyntax.create1 = function (expression) {
+            return new ExpressionStatementSyntax(expression, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        ExpressionStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ExpressionStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ExpressionStatementSyntax.prototype.withExpression = function (expression) {
+            return this.update(expression, this.semicolonToken);
+        };
+
+        ExpressionStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.expression, semicolonToken);
+        };
+
+        ExpressionStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ExpressionStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ExpressionStatementSyntax = ExpressionStatementSyntax;
+
+    var ConstructorDeclarationSyntax = (function (_super) {
+        __extends(ConstructorDeclarationSyntax, _super);
+        function ConstructorDeclarationSyntax(modifiers, constructorKeyword, callSignature, block, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.constructorKeyword = constructorKeyword;
+            this.callSignature = callSignature;
+            this.block = block;
+            this.semicolonToken = semicolonToken;
+        }
+        ConstructorDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitConstructorDeclaration(this);
+        };
+
+        ConstructorDeclarationSyntax.prototype.kind = function () {
+            return 137 /* ConstructorDeclaration */;
+        };
+
+        ConstructorDeclarationSyntax.prototype.childCount = function () {
+            return 5;
+        };
+
+        ConstructorDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.constructorKeyword;
+                case 2:
+                    return this.callSignature;
+                case 3:
+                    return this.block;
+                case 4:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ConstructorDeclarationSyntax.prototype.isClassElement = function () {
+            return true;
+        };
+
+        ConstructorDeclarationSyntax.prototype.update = function (modifiers, constructorKeyword, callSignature, block, semicolonToken) {
+            if (this.modifiers === modifiers && this.constructorKeyword === constructorKeyword && this.callSignature === callSignature && this.block === block && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new ConstructorDeclarationSyntax(modifiers, constructorKeyword, callSignature, block, semicolonToken, this.parsedInStrictMode());
+        };
+
+        ConstructorDeclarationSyntax.create = function (constructorKeyword, callSignature) {
+            return new ConstructorDeclarationSyntax(TypeScript.Syntax.emptyList, constructorKeyword, callSignature, null, null, false);
+        };
+
+        ConstructorDeclarationSyntax.create1 = function () {
+            return new ConstructorDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(62 /* ConstructorKeyword */), CallSignatureSyntax.create1(), null, null, false);
+        };
+
+        ConstructorDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ConstructorDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ConstructorDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.constructorKeyword, this.callSignature, this.block, this.semicolonToken);
+        };
+
+        ConstructorDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        ConstructorDeclarationSyntax.prototype.withConstructorKeyword = function (constructorKeyword) {
+            return this.update(this.modifiers, constructorKeyword, this.callSignature, this.block, this.semicolonToken);
+        };
+
+        ConstructorDeclarationSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(this.modifiers, this.constructorKeyword, callSignature, this.block, this.semicolonToken);
+        };
+
+        ConstructorDeclarationSyntax.prototype.withBlock = function (block) {
+            return this.update(this.modifiers, this.constructorKeyword, this.callSignature, block, this.semicolonToken);
+        };
+
+        ConstructorDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.modifiers, this.constructorKeyword, this.callSignature, this.block, semicolonToken);
+        };
+
+        ConstructorDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ConstructorDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ConstructorDeclarationSyntax = ConstructorDeclarationSyntax;
+
+    var MemberFunctionDeclarationSyntax = (function (_super) {
+        __extends(MemberFunctionDeclarationSyntax, _super);
+        function MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.propertyName = propertyName;
+            this.callSignature = callSignature;
+            this.block = block;
+            this.semicolonToken = semicolonToken;
+        }
+        MemberFunctionDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitMemberFunctionDeclaration(this);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.kind = function () {
+            return 135 /* MemberFunctionDeclaration */;
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.childCount = function () {
+            return 5;
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.propertyName;
+                case 2:
+                    return this.callSignature;
+                case 3:
+                    return this.block;
+                case 4:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.isMemberDeclaration = function () {
+            return true;
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.isClassElement = function () {
+            return true;
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.update = function (modifiers, propertyName, callSignature, block, semicolonToken) {
+            if (this.modifiers === modifiers && this.propertyName === propertyName && this.callSignature === callSignature && this.block === block && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, this.parsedInStrictMode());
+        };
+
+        MemberFunctionDeclarationSyntax.create = function (propertyName, callSignature) {
+            return new MemberFunctionDeclarationSyntax(TypeScript.Syntax.emptyList, propertyName, callSignature, null, null, false);
+        };
+
+        MemberFunctionDeclarationSyntax.create1 = function (propertyName) {
+            return new MemberFunctionDeclarationSyntax(TypeScript.Syntax.emptyList, propertyName, CallSignatureSyntax.create1(), null, null, false);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.propertyName, this.callSignature, this.block, this.semicolonToken);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(this.modifiers, propertyName, this.callSignature, this.block, this.semicolonToken);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(this.modifiers, this.propertyName, callSignature, this.block, this.semicolonToken);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withBlock = function (block) {
+            return this.update(this.modifiers, this.propertyName, this.callSignature, block, this.semicolonToken);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.modifiers, this.propertyName, this.callSignature, this.block, semicolonToken);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return MemberFunctionDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.MemberFunctionDeclarationSyntax = MemberFunctionDeclarationSyntax;
+
+    var GetAccessorSyntax = (function (_super) {
+        __extends(GetAccessorSyntax, _super);
+        function GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.getKeyword = getKeyword;
+            this.propertyName = propertyName;
+            this.parameterList = parameterList;
+            this.typeAnnotation = typeAnnotation;
+            this.block = block;
+        }
+        GetAccessorSyntax.prototype.accept = function (visitor) {
+            return visitor.visitGetAccessor(this);
+        };
+
+        GetAccessorSyntax.prototype.kind = function () {
+            return 139 /* GetAccessor */;
+        };
+
+        GetAccessorSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        GetAccessorSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.getKeyword;
+                case 2:
+                    return this.propertyName;
+                case 3:
+                    return this.parameterList;
+                case 4:
+                    return this.typeAnnotation;
+                case 5:
+                    return this.block;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        GetAccessorSyntax.prototype.isMemberDeclaration = function () {
+            return true;
+        };
+
+        GetAccessorSyntax.prototype.isPropertyAssignment = function () {
+            return true;
+        };
+
+        GetAccessorSyntax.prototype.isClassElement = function () {
+            return true;
+        };
+
+        GetAccessorSyntax.prototype.update = function (modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block) {
+            if (this.modifiers === modifiers && this.getKeyword === getKeyword && this.propertyName === propertyName && this.parameterList === parameterList && this.typeAnnotation === typeAnnotation && this.block === block) {
+                return this;
+            }
+
+            return new GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, this.parsedInStrictMode());
+        };
+
+        GetAccessorSyntax.create = function (getKeyword, propertyName, parameterList, block) {
+            return new GetAccessorSyntax(TypeScript.Syntax.emptyList, getKeyword, propertyName, parameterList, null, block, false);
+        };
+
+        GetAccessorSyntax.create1 = function (propertyName) {
+            return new GetAccessorSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(64 /* GetKeyword */), propertyName, ParameterListSyntax.create1(), null, BlockSyntax.create1(), false);
+        };
+
+        GetAccessorSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        GetAccessorSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        GetAccessorSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.getKeyword, this.propertyName, this.parameterList, this.typeAnnotation, this.block);
+        };
+
+        GetAccessorSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        GetAccessorSyntax.prototype.withGetKeyword = function (getKeyword) {
+            return this.update(this.modifiers, getKeyword, this.propertyName, this.parameterList, this.typeAnnotation, this.block);
+        };
+
+        GetAccessorSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(this.modifiers, this.getKeyword, propertyName, this.parameterList, this.typeAnnotation, this.block);
+        };
+
+        GetAccessorSyntax.prototype.withParameterList = function (parameterList) {
+            return this.update(this.modifiers, this.getKeyword, this.propertyName, parameterList, this.typeAnnotation, this.block);
+        };
+
+        GetAccessorSyntax.prototype.withTypeAnnotation = function (typeAnnotation) {
+            return this.update(this.modifiers, this.getKeyword, this.propertyName, this.parameterList, typeAnnotation, this.block);
+        };
+
+        GetAccessorSyntax.prototype.withBlock = function (block) {
+            return this.update(this.modifiers, this.getKeyword, this.propertyName, this.parameterList, this.typeAnnotation, block);
+        };
+
+        GetAccessorSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.modifiers.childCount() > 0) {
+                return true;
+            }
+            if (this.parameterList.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.typeAnnotation !== null) {
+                return true;
+            }
+            if (this.block.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return GetAccessorSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.GetAccessorSyntax = GetAccessorSyntax;
+
+    var SetAccessorSyntax = (function (_super) {
+        __extends(SetAccessorSyntax, _super);
+        function SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.setKeyword = setKeyword;
+            this.propertyName = propertyName;
+            this.parameterList = parameterList;
+            this.block = block;
+        }
+        SetAccessorSyntax.prototype.accept = function (visitor) {
+            return visitor.visitSetAccessor(this);
+        };
+
+        SetAccessorSyntax.prototype.kind = function () {
+            return 140 /* SetAccessor */;
+        };
+
+        SetAccessorSyntax.prototype.childCount = function () {
+            return 5;
+        };
+
+        SetAccessorSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.setKeyword;
+                case 2:
+                    return this.propertyName;
+                case 3:
+                    return this.parameterList;
+                case 4:
+                    return this.block;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        SetAccessorSyntax.prototype.isMemberDeclaration = function () {
+            return true;
+        };
+
+        SetAccessorSyntax.prototype.isPropertyAssignment = function () {
+            return true;
+        };
+
+        SetAccessorSyntax.prototype.isClassElement = function () {
+            return true;
+        };
+
+        SetAccessorSyntax.prototype.update = function (modifiers, setKeyword, propertyName, parameterList, block) {
+            if (this.modifiers === modifiers && this.setKeyword === setKeyword && this.propertyName === propertyName && this.parameterList === parameterList && this.block === block) {
+                return this;
+            }
+
+            return new SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, this.parsedInStrictMode());
+        };
+
+        SetAccessorSyntax.create = function (setKeyword, propertyName, parameterList, block) {
+            return new SetAccessorSyntax(TypeScript.Syntax.emptyList, setKeyword, propertyName, parameterList, block, false);
+        };
+
+        SetAccessorSyntax.create1 = function (propertyName) {
+            return new SetAccessorSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(68 /* SetKeyword */), propertyName, ParameterListSyntax.create1(), BlockSyntax.create1(), false);
+        };
+
+        SetAccessorSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        SetAccessorSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        SetAccessorSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.setKeyword, this.propertyName, this.parameterList, this.block);
+        };
+
+        SetAccessorSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        SetAccessorSyntax.prototype.withSetKeyword = function (setKeyword) {
+            return this.update(this.modifiers, setKeyword, this.propertyName, this.parameterList, this.block);
+        };
+
+        SetAccessorSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(this.modifiers, this.setKeyword, propertyName, this.parameterList, this.block);
+        };
+
+        SetAccessorSyntax.prototype.withParameterList = function (parameterList) {
+            return this.update(this.modifiers, this.setKeyword, this.propertyName, parameterList, this.block);
+        };
+
+        SetAccessorSyntax.prototype.withBlock = function (block) {
+            return this.update(this.modifiers, this.setKeyword, this.propertyName, this.parameterList, block);
+        };
+
+        SetAccessorSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return SetAccessorSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.SetAccessorSyntax = SetAccessorSyntax;
+
+    var MemberVariableDeclarationSyntax = (function (_super) {
+        __extends(MemberVariableDeclarationSyntax, _super);
+        function MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.variableDeclarator = variableDeclarator;
+            this.semicolonToken = semicolonToken;
+        }
+        MemberVariableDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitMemberVariableDeclaration(this);
+        };
+
+        MemberVariableDeclarationSyntax.prototype.kind = function () {
+            return 136 /* MemberVariableDeclaration */;
+        };
+
+        MemberVariableDeclarationSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        MemberVariableDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.variableDeclarator;
+                case 2:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        MemberVariableDeclarationSyntax.prototype.isMemberDeclaration = function () {
+            return true;
+        };
+
+        MemberVariableDeclarationSyntax.prototype.isClassElement = function () {
+            return true;
+        };
+
+        MemberVariableDeclarationSyntax.prototype.update = function (modifiers, variableDeclarator, semicolonToken) {
+            if (this.modifiers === modifiers && this.variableDeclarator === variableDeclarator && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, this.parsedInStrictMode());
+        };
+
+        MemberVariableDeclarationSyntax.create = function (variableDeclarator, semicolonToken) {
+            return new MemberVariableDeclarationSyntax(TypeScript.Syntax.emptyList, variableDeclarator, semicolonToken, false);
+        };
+
+        MemberVariableDeclarationSyntax.create1 = function (variableDeclarator) {
+            return new MemberVariableDeclarationSyntax(TypeScript.Syntax.emptyList, variableDeclarator, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        MemberVariableDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        MemberVariableDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        MemberVariableDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.variableDeclarator, this.semicolonToken);
+        };
+
+        MemberVariableDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        MemberVariableDeclarationSyntax.prototype.withVariableDeclarator = function (variableDeclarator) {
+            return this.update(this.modifiers, variableDeclarator, this.semicolonToken);
+        };
+
+        MemberVariableDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.modifiers, this.variableDeclarator, semicolonToken);
+        };
+
+        MemberVariableDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return MemberVariableDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.MemberVariableDeclarationSyntax = MemberVariableDeclarationSyntax;
+
+    var IndexMemberDeclarationSyntax = (function (_super) {
+        __extends(IndexMemberDeclarationSyntax, _super);
+        function IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.indexSignature = indexSignature;
+            this.semicolonToken = semicolonToken;
+        }
+        IndexMemberDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitIndexMemberDeclaration(this);
+        };
+
+        IndexMemberDeclarationSyntax.prototype.kind = function () {
+            return 138 /* IndexMemberDeclaration */;
+        };
+
+        IndexMemberDeclarationSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        IndexMemberDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.indexSignature;
+                case 2:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        IndexMemberDeclarationSyntax.prototype.isClassElement = function () {
+            return true;
+        };
+
+        IndexMemberDeclarationSyntax.prototype.update = function (modifiers, indexSignature, semicolonToken) {
+            if (this.modifiers === modifiers && this.indexSignature === indexSignature && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, this.parsedInStrictMode());
+        };
+
+        IndexMemberDeclarationSyntax.create = function (indexSignature, semicolonToken) {
+            return new IndexMemberDeclarationSyntax(TypeScript.Syntax.emptyList, indexSignature, semicolonToken, false);
+        };
+
+        IndexMemberDeclarationSyntax.create1 = function (indexSignature) {
+            return new IndexMemberDeclarationSyntax(TypeScript.Syntax.emptyList, indexSignature, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        IndexMemberDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        IndexMemberDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        IndexMemberDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.indexSignature, this.semicolonToken);
+        };
+
+        IndexMemberDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        IndexMemberDeclarationSyntax.prototype.withIndexSignature = function (indexSignature) {
+            return this.update(this.modifiers, indexSignature, this.semicolonToken);
+        };
+
+        IndexMemberDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.modifiers, this.indexSignature, semicolonToken);
+        };
+
+        IndexMemberDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return IndexMemberDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.IndexMemberDeclarationSyntax = IndexMemberDeclarationSyntax;
+
+    var ThrowStatementSyntax = (function (_super) {
+        __extends(ThrowStatementSyntax, _super);
+        function ThrowStatementSyntax(throwKeyword, expression, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.throwKeyword = throwKeyword;
+            this.expression = expression;
+            this.semicolonToken = semicolonToken;
+        }
+        ThrowStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitThrowStatement(this);
+        };
+
+        ThrowStatementSyntax.prototype.kind = function () {
+            return 157 /* ThrowStatement */;
+        };
+
+        ThrowStatementSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ThrowStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.throwKeyword;
+                case 1:
+                    return this.expression;
+                case 2:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ThrowStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        ThrowStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ThrowStatementSyntax.prototype.update = function (throwKeyword, expression, semicolonToken) {
+            if (this.throwKeyword === throwKeyword && this.expression === expression && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new ThrowStatementSyntax(throwKeyword, expression, semicolonToken, this.parsedInStrictMode());
+        };
+
+        ThrowStatementSyntax.create1 = function (expression) {
+            return new ThrowStatementSyntax(TypeScript.Syntax.token(36 /* ThrowKeyword */), expression, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        ThrowStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ThrowStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ThrowStatementSyntax.prototype.withThrowKeyword = function (throwKeyword) {
+            return this.update(throwKeyword, this.expression, this.semicolonToken);
+        };
+
+        ThrowStatementSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.throwKeyword, expression, this.semicolonToken);
+        };
+
+        ThrowStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.throwKeyword, this.expression, semicolonToken);
+        };
+
+        ThrowStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ThrowStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ThrowStatementSyntax = ThrowStatementSyntax;
+
+    var ReturnStatementSyntax = (function (_super) {
+        __extends(ReturnStatementSyntax, _super);
+        function ReturnStatementSyntax(returnKeyword, expression, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.returnKeyword = returnKeyword;
+            this.expression = expression;
+            this.semicolonToken = semicolonToken;
+        }
+        ReturnStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitReturnStatement(this);
+        };
+
+        ReturnStatementSyntax.prototype.kind = function () {
+            return 150 /* ReturnStatement */;
+        };
+
+        ReturnStatementSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ReturnStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.returnKeyword;
+                case 1:
+                    return this.expression;
+                case 2:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ReturnStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        ReturnStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ReturnStatementSyntax.prototype.update = function (returnKeyword, expression, semicolonToken) {
+            if (this.returnKeyword === returnKeyword && this.expression === expression && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new ReturnStatementSyntax(returnKeyword, expression, semicolonToken, this.parsedInStrictMode());
+        };
+
+        ReturnStatementSyntax.create = function (returnKeyword, semicolonToken) {
+            return new ReturnStatementSyntax(returnKeyword, null, semicolonToken, false);
+        };
+
+        ReturnStatementSyntax.create1 = function () {
+            return new ReturnStatementSyntax(TypeScript.Syntax.token(33 /* ReturnKeyword */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        ReturnStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ReturnStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ReturnStatementSyntax.prototype.withReturnKeyword = function (returnKeyword) {
+            return this.update(returnKeyword, this.expression, this.semicolonToken);
+        };
+
+        ReturnStatementSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.returnKeyword, expression, this.semicolonToken);
+        };
+
+        ReturnStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.returnKeyword, this.expression, semicolonToken);
+        };
+
+        ReturnStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression !== null && this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ReturnStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ReturnStatementSyntax = ReturnStatementSyntax;
+
+    var ObjectCreationExpressionSyntax = (function (_super) {
+        __extends(ObjectCreationExpressionSyntax, _super);
+        function ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.newKeyword = newKeyword;
+            this.expression = expression;
+            this.argumentList = argumentList;
+        }
+        ObjectCreationExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitObjectCreationExpression(this);
+        };
+
+        ObjectCreationExpressionSyntax.prototype.kind = function () {
+            return 216 /* ObjectCreationExpression */;
+        };
+
+        ObjectCreationExpressionSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ObjectCreationExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.newKeyword;
+                case 1:
+                    return this.expression;
+                case 2:
+                    return this.argumentList;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ObjectCreationExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        ObjectCreationExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        ObjectCreationExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        ObjectCreationExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        ObjectCreationExpressionSyntax.prototype.update = function (newKeyword, expression, argumentList) {
+            if (this.newKeyword === newKeyword && this.expression === expression && this.argumentList === argumentList) {
+                return this;
+            }
+
+            return new ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, this.parsedInStrictMode());
+        };
+
+        ObjectCreationExpressionSyntax.create = function (newKeyword, expression) {
+            return new ObjectCreationExpressionSyntax(newKeyword, expression, null, false);
+        };
+
+        ObjectCreationExpressionSyntax.create1 = function (expression) {
+            return new ObjectCreationExpressionSyntax(TypeScript.Syntax.token(31 /* NewKeyword */), expression, null, false);
+        };
+
+        ObjectCreationExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ObjectCreationExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ObjectCreationExpressionSyntax.prototype.withNewKeyword = function (newKeyword) {
+            return this.update(newKeyword, this.expression, this.argumentList);
+        };
+
+        ObjectCreationExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.newKeyword, expression, this.argumentList);
+        };
+
+        ObjectCreationExpressionSyntax.prototype.withArgumentList = function (argumentList) {
+            return this.update(this.newKeyword, this.expression, argumentList);
+        };
+
+        ObjectCreationExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.argumentList !== null && this.argumentList.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ObjectCreationExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ObjectCreationExpressionSyntax = ObjectCreationExpressionSyntax;
+
+    var SwitchStatementSyntax = (function (_super) {
+        __extends(SwitchStatementSyntax, _super);
+        function SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.switchKeyword = switchKeyword;
+            this.openParenToken = openParenToken;
+            this.expression = expression;
+            this.closeParenToken = closeParenToken;
+            this.openBraceToken = openBraceToken;
+            this.switchClauses = switchClauses;
+            this.closeBraceToken = closeBraceToken;
+        }
+        SwitchStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitSwitchStatement(this);
+        };
+
+        SwitchStatementSyntax.prototype.kind = function () {
+            return 151 /* SwitchStatement */;
+        };
+
+        SwitchStatementSyntax.prototype.childCount = function () {
+            return 7;
+        };
+
+        SwitchStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.switchKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.expression;
+                case 3:
+                    return this.closeParenToken;
+                case 4:
+                    return this.openBraceToken;
+                case 5:
+                    return this.switchClauses;
+                case 6:
+                    return this.closeBraceToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        SwitchStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        SwitchStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        SwitchStatementSyntax.prototype.update = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken) {
+            if (this.switchKeyword === switchKeyword && this.openParenToken === openParenToken && this.expression === expression && this.closeParenToken === closeParenToken && this.openBraceToken === openBraceToken && this.switchClauses === switchClauses && this.closeBraceToken === closeBraceToken) {
+                return this;
+            }
+
+            return new SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, this.parsedInStrictMode());
+        };
+
+        SwitchStatementSyntax.create = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, closeBraceToken) {
+            return new SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false);
+        };
+
+        SwitchStatementSyntax.create1 = function (expression) {
+            return new SwitchStatementSyntax(TypeScript.Syntax.token(34 /* SwitchKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), expression, TypeScript.Syntax.token(73 /* CloseParenToken */), TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false);
+        };
+
+        SwitchStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        SwitchStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        SwitchStatementSyntax.prototype.withSwitchKeyword = function (switchKeyword) {
+            return this.update(switchKeyword, this.openParenToken, this.expression, this.closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken);
+        };
+
+        SwitchStatementSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.switchKeyword, openParenToken, this.expression, this.closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken);
+        };
+
+        SwitchStatementSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.switchKeyword, this.openParenToken, expression, this.closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken);
+        };
+
+        SwitchStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.switchKeyword, this.openParenToken, this.expression, closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken);
+        };
+
+        SwitchStatementSyntax.prototype.withOpenBraceToken = function (openBraceToken) {
+            return this.update(this.switchKeyword, this.openParenToken, this.expression, this.closeParenToken, openBraceToken, this.switchClauses, this.closeBraceToken);
+        };
+
+        SwitchStatementSyntax.prototype.withSwitchClauses = function (switchClauses) {
+            return this.update(this.switchKeyword, this.openParenToken, this.expression, this.closeParenToken, this.openBraceToken, switchClauses, this.closeBraceToken);
+        };
+
+        SwitchStatementSyntax.prototype.withSwitchClause = function (switchClause) {
+            return this.withSwitchClauses(TypeScript.Syntax.list([switchClause]));
+        };
+
+        SwitchStatementSyntax.prototype.withCloseBraceToken = function (closeBraceToken) {
+            return this.update(this.switchKeyword, this.openParenToken, this.expression, this.closeParenToken, this.openBraceToken, this.switchClauses, closeBraceToken);
+        };
+
+        SwitchStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.switchClauses.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return SwitchStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.SwitchStatementSyntax = SwitchStatementSyntax;
+
+    var CaseSwitchClauseSyntax = (function (_super) {
+        __extends(CaseSwitchClauseSyntax, _super);
+        function CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.caseKeyword = caseKeyword;
+            this.expression = expression;
+            this.colonToken = colonToken;
+            this.statements = statements;
+        }
+        CaseSwitchClauseSyntax.prototype.accept = function (visitor) {
+            return visitor.visitCaseSwitchClause(this);
+        };
+
+        CaseSwitchClauseSyntax.prototype.kind = function () {
+            return 233 /* CaseSwitchClause */;
+        };
+
+        CaseSwitchClauseSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        CaseSwitchClauseSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.caseKeyword;
+                case 1:
+                    return this.expression;
+                case 2:
+                    return this.colonToken;
+                case 3:
+                    return this.statements;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        CaseSwitchClauseSyntax.prototype.isSwitchClause = function () {
+            return true;
+        };
+
+        CaseSwitchClauseSyntax.prototype.update = function (caseKeyword, expression, colonToken, statements) {
+            if (this.caseKeyword === caseKeyword && this.expression === expression && this.colonToken === colonToken && this.statements === statements) {
+                return this;
+            }
+
+            return new CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, this.parsedInStrictMode());
+        };
+
+        CaseSwitchClauseSyntax.create = function (caseKeyword, expression, colonToken) {
+            return new CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, TypeScript.Syntax.emptyList, false);
+        };
+
+        CaseSwitchClauseSyntax.create1 = function (expression) {
+            return new CaseSwitchClauseSyntax(TypeScript.Syntax.token(16 /* CaseKeyword */), expression, TypeScript.Syntax.token(106 /* ColonToken */), TypeScript.Syntax.emptyList, false);
+        };
+
+        CaseSwitchClauseSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        CaseSwitchClauseSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        CaseSwitchClauseSyntax.prototype.withCaseKeyword = function (caseKeyword) {
+            return this.update(caseKeyword, this.expression, this.colonToken, this.statements);
+        };
+
+        CaseSwitchClauseSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.caseKeyword, expression, this.colonToken, this.statements);
+        };
+
+        CaseSwitchClauseSyntax.prototype.withColonToken = function (colonToken) {
+            return this.update(this.caseKeyword, this.expression, colonToken, this.statements);
+        };
+
+        CaseSwitchClauseSyntax.prototype.withStatements = function (statements) {
+            return this.update(this.caseKeyword, this.expression, this.colonToken, statements);
+        };
+
+        CaseSwitchClauseSyntax.prototype.withStatement = function (statement) {
+            return this.withStatements(TypeScript.Syntax.list([statement]));
+        };
+
+        CaseSwitchClauseSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.statements.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return CaseSwitchClauseSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.CaseSwitchClauseSyntax = CaseSwitchClauseSyntax;
+
+    var DefaultSwitchClauseSyntax = (function (_super) {
+        __extends(DefaultSwitchClauseSyntax, _super);
+        function DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.defaultKeyword = defaultKeyword;
+            this.colonToken = colonToken;
+            this.statements = statements;
+        }
+        DefaultSwitchClauseSyntax.prototype.accept = function (visitor) {
+            return visitor.visitDefaultSwitchClause(this);
+        };
+
+        DefaultSwitchClauseSyntax.prototype.kind = function () {
+            return 234 /* DefaultSwitchClause */;
+        };
+
+        DefaultSwitchClauseSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        DefaultSwitchClauseSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.defaultKeyword;
+                case 1:
+                    return this.colonToken;
+                case 2:
+                    return this.statements;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        DefaultSwitchClauseSyntax.prototype.isSwitchClause = function () {
+            return true;
+        };
+
+        DefaultSwitchClauseSyntax.prototype.update = function (defaultKeyword, colonToken, statements) {
+            if (this.defaultKeyword === defaultKeyword && this.colonToken === colonToken && this.statements === statements) {
+                return this;
+            }
+
+            return new DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, this.parsedInStrictMode());
+        };
+
+        DefaultSwitchClauseSyntax.create = function (defaultKeyword, colonToken) {
+            return new DefaultSwitchClauseSyntax(defaultKeyword, colonToken, TypeScript.Syntax.emptyList, false);
+        };
+
+        DefaultSwitchClauseSyntax.create1 = function () {
+            return new DefaultSwitchClauseSyntax(TypeScript.Syntax.token(20 /* DefaultKeyword */), TypeScript.Syntax.token(106 /* ColonToken */), TypeScript.Syntax.emptyList, false);
+        };
+
+        DefaultSwitchClauseSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        DefaultSwitchClauseSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        DefaultSwitchClauseSyntax.prototype.withDefaultKeyword = function (defaultKeyword) {
+            return this.update(defaultKeyword, this.colonToken, this.statements);
+        };
+
+        DefaultSwitchClauseSyntax.prototype.withColonToken = function (colonToken) {
+            return this.update(this.defaultKeyword, colonToken, this.statements);
+        };
+
+        DefaultSwitchClauseSyntax.prototype.withStatements = function (statements) {
+            return this.update(this.defaultKeyword, this.colonToken, statements);
+        };
+
+        DefaultSwitchClauseSyntax.prototype.withStatement = function (statement) {
+            return this.withStatements(TypeScript.Syntax.list([statement]));
+        };
+
+        DefaultSwitchClauseSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.statements.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return DefaultSwitchClauseSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.DefaultSwitchClauseSyntax = DefaultSwitchClauseSyntax;
+
+    var BreakStatementSyntax = (function (_super) {
+        __extends(BreakStatementSyntax, _super);
+        function BreakStatementSyntax(breakKeyword, identifier, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.breakKeyword = breakKeyword;
+            this.identifier = identifier;
+            this.semicolonToken = semicolonToken;
+        }
+        BreakStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitBreakStatement(this);
+        };
+
+        BreakStatementSyntax.prototype.kind = function () {
+            return 152 /* BreakStatement */;
+        };
+
+        BreakStatementSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        BreakStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.breakKeyword;
+                case 1:
+                    return this.identifier;
+                case 2:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        BreakStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        BreakStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        BreakStatementSyntax.prototype.update = function (breakKeyword, identifier, semicolonToken) {
+            if (this.breakKeyword === breakKeyword && this.identifier === identifier && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new BreakStatementSyntax(breakKeyword, identifier, semicolonToken, this.parsedInStrictMode());
+        };
+
+        BreakStatementSyntax.create = function (breakKeyword, semicolonToken) {
+            return new BreakStatementSyntax(breakKeyword, null, semicolonToken, false);
+        };
+
+        BreakStatementSyntax.create1 = function () {
+            return new BreakStatementSyntax(TypeScript.Syntax.token(15 /* BreakKeyword */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        BreakStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        BreakStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        BreakStatementSyntax.prototype.withBreakKeyword = function (breakKeyword) {
+            return this.update(breakKeyword, this.identifier, this.semicolonToken);
+        };
+
+        BreakStatementSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.breakKeyword, identifier, this.semicolonToken);
+        };
+
+        BreakStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.breakKeyword, this.identifier, semicolonToken);
+        };
+
+        BreakStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            return false;
+        };
+        return BreakStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.BreakStatementSyntax = BreakStatementSyntax;
+
+    var ContinueStatementSyntax = (function (_super) {
+        __extends(ContinueStatementSyntax, _super);
+        function ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.continueKeyword = continueKeyword;
+            this.identifier = identifier;
+            this.semicolonToken = semicolonToken;
+        }
+        ContinueStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitContinueStatement(this);
+        };
+
+        ContinueStatementSyntax.prototype.kind = function () {
+            return 153 /* ContinueStatement */;
+        };
+
+        ContinueStatementSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ContinueStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.continueKeyword;
+                case 1:
+                    return this.identifier;
+                case 2:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ContinueStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        ContinueStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ContinueStatementSyntax.prototype.update = function (continueKeyword, identifier, semicolonToken) {
+            if (this.continueKeyword === continueKeyword && this.identifier === identifier && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, this.parsedInStrictMode());
+        };
+
+        ContinueStatementSyntax.create = function (continueKeyword, semicolonToken) {
+            return new ContinueStatementSyntax(continueKeyword, null, semicolonToken, false);
+        };
+
+        ContinueStatementSyntax.create1 = function () {
+            return new ContinueStatementSyntax(TypeScript.Syntax.token(18 /* ContinueKeyword */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        ContinueStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ContinueStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ContinueStatementSyntax.prototype.withContinueKeyword = function (continueKeyword) {
+            return this.update(continueKeyword, this.identifier, this.semicolonToken);
+        };
+
+        ContinueStatementSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.continueKeyword, identifier, this.semicolonToken);
+        };
+
+        ContinueStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.continueKeyword, this.identifier, semicolonToken);
+        };
+
+        ContinueStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            return false;
+        };
+        return ContinueStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ContinueStatementSyntax = ContinueStatementSyntax;
+
+    var ForStatementSyntax = (function (_super) {
+        __extends(ForStatementSyntax, _super);
+        function ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.forKeyword = forKeyword;
+            this.openParenToken = openParenToken;
+            this.variableDeclaration = variableDeclaration;
+            this.initializer = initializer;
+            this.firstSemicolonToken = firstSemicolonToken;
+            this.condition = condition;
+            this.secondSemicolonToken = secondSemicolonToken;
+            this.incrementor = incrementor;
+            this.closeParenToken = closeParenToken;
+            this.statement = statement;
+        }
+        ForStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitForStatement(this);
+        };
+
+        ForStatementSyntax.prototype.kind = function () {
+            return 154 /* ForStatement */;
+        };
+
+        ForStatementSyntax.prototype.childCount = function () {
+            return 10;
+        };
+
+        ForStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.forKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.variableDeclaration;
+                case 3:
+                    return this.initializer;
+                case 4:
+                    return this.firstSemicolonToken;
+                case 5:
+                    return this.condition;
+                case 6:
+                    return this.secondSemicolonToken;
+                case 7:
+                    return this.incrementor;
+                case 8:
+                    return this.closeParenToken;
+                case 9:
+                    return this.statement;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ForStatementSyntax.prototype.isIterationStatement = function () {
+            return true;
+        };
+
+        ForStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        ForStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ForStatementSyntax.prototype.update = function (forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement) {
+            if (this.forKeyword === forKeyword && this.openParenToken === openParenToken && this.variableDeclaration === variableDeclaration && this.initializer === initializer && this.firstSemicolonToken === firstSemicolonToken && this.condition === condition && this.secondSemicolonToken === secondSemicolonToken && this.incrementor === incrementor && this.closeParenToken === closeParenToken && this.statement === statement) {
+                return this;
+            }
+
+            return new ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, this.parsedInStrictMode());
+        };
+
+        ForStatementSyntax.create = function (forKeyword, openParenToken, firstSemicolonToken, secondSemicolonToken, closeParenToken, statement) {
+            return new ForStatementSyntax(forKeyword, openParenToken, null, null, firstSemicolonToken, null, secondSemicolonToken, null, closeParenToken, statement, false);
+        };
+
+        ForStatementSyntax.create1 = function (statement) {
+            return new ForStatementSyntax(TypeScript.Syntax.token(26 /* ForKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), null, null, TypeScript.Syntax.token(78 /* SemicolonToken */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), null, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false);
+        };
+
+        ForStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ForStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ForStatementSyntax.prototype.withForKeyword = function (forKeyword) {
+            return this.update(forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.forKeyword, openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withVariableDeclaration = function (variableDeclaration) {
+            return this.update(this.forKeyword, this.openParenToken, variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withInitializer = function (initializer) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withFirstSemicolonToken = function (firstSemicolonToken) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withCondition = function (condition) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withSecondSemicolonToken = function (secondSemicolonToken) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withIncrementor = function (incrementor) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, statement);
+        };
+
+        ForStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.variableDeclaration !== null && this.variableDeclaration.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.initializer !== null && this.initializer.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.condition !== null && this.condition.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.incrementor !== null && this.incrementor.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ForStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ForStatementSyntax = ForStatementSyntax;
+
+    var ForInStatementSyntax = (function (_super) {
+        __extends(ForInStatementSyntax, _super);
+        function ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.forKeyword = forKeyword;
+            this.openParenToken = openParenToken;
+            this.variableDeclaration = variableDeclaration;
+            this.left = left;
+            this.inKeyword = inKeyword;
+            this.expression = expression;
+            this.closeParenToken = closeParenToken;
+            this.statement = statement;
+        }
+        ForInStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitForInStatement(this);
+        };
+
+        ForInStatementSyntax.prototype.kind = function () {
+            return 155 /* ForInStatement */;
+        };
+
+        ForInStatementSyntax.prototype.childCount = function () {
+            return 8;
+        };
+
+        ForInStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.forKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.variableDeclaration;
+                case 3:
+                    return this.left;
+                case 4:
+                    return this.inKeyword;
+                case 5:
+                    return this.expression;
+                case 6:
+                    return this.closeParenToken;
+                case 7:
+                    return this.statement;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ForInStatementSyntax.prototype.isIterationStatement = function () {
+            return true;
+        };
+
+        ForInStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        ForInStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ForInStatementSyntax.prototype.update = function (forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement) {
+            if (this.forKeyword === forKeyword && this.openParenToken === openParenToken && this.variableDeclaration === variableDeclaration && this.left === left && this.inKeyword === inKeyword && this.expression === expression && this.closeParenToken === closeParenToken && this.statement === statement) {
+                return this;
+            }
+
+            return new ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, this.parsedInStrictMode());
+        };
+
+        ForInStatementSyntax.create = function (forKeyword, openParenToken, inKeyword, expression, closeParenToken, statement) {
+            return new ForInStatementSyntax(forKeyword, openParenToken, null, null, inKeyword, expression, closeParenToken, statement, false);
+        };
+
+        ForInStatementSyntax.create1 = function (expression, statement) {
+            return new ForInStatementSyntax(TypeScript.Syntax.token(26 /* ForKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), null, null, TypeScript.Syntax.token(29 /* InKeyword */), expression, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false);
+        };
+
+        ForInStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ForInStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ForInStatementSyntax.prototype.withForKeyword = function (forKeyword) {
+            return this.update(forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, this.statement);
+        };
+
+        ForInStatementSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.forKeyword, openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, this.statement);
+        };
+
+        ForInStatementSyntax.prototype.withVariableDeclaration = function (variableDeclaration) {
+            return this.update(this.forKeyword, this.openParenToken, variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, this.statement);
+        };
+
+        ForInStatementSyntax.prototype.withLeft = function (left) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, left, this.inKeyword, this.expression, this.closeParenToken, this.statement);
+        };
+
+        ForInStatementSyntax.prototype.withInKeyword = function (inKeyword) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, inKeyword, this.expression, this.closeParenToken, this.statement);
+        };
+
+        ForInStatementSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, expression, this.closeParenToken, this.statement);
+        };
+
+        ForInStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, closeParenToken, this.statement);
+        };
+
+        ForInStatementSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, statement);
+        };
+
+        ForInStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.variableDeclaration !== null && this.variableDeclaration.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.left !== null && this.left.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ForInStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ForInStatementSyntax = ForInStatementSyntax;
+
+    var WhileStatementSyntax = (function (_super) {
+        __extends(WhileStatementSyntax, _super);
+        function WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.whileKeyword = whileKeyword;
+            this.openParenToken = openParenToken;
+            this.condition = condition;
+            this.closeParenToken = closeParenToken;
+            this.statement = statement;
+        }
+        WhileStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitWhileStatement(this);
+        };
+
+        WhileStatementSyntax.prototype.kind = function () {
+            return 158 /* WhileStatement */;
+        };
+
+        WhileStatementSyntax.prototype.childCount = function () {
+            return 5;
+        };
+
+        WhileStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.whileKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.condition;
+                case 3:
+                    return this.closeParenToken;
+                case 4:
+                    return this.statement;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        WhileStatementSyntax.prototype.isIterationStatement = function () {
+            return true;
+        };
+
+        WhileStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        WhileStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        WhileStatementSyntax.prototype.update = function (whileKeyword, openParenToken, condition, closeParenToken, statement) {
+            if (this.whileKeyword === whileKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.statement === statement) {
+                return this;
+            }
+
+            return new WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, this.parsedInStrictMode());
+        };
+
+        WhileStatementSyntax.create1 = function (condition, statement) {
+            return new WhileStatementSyntax(TypeScript.Syntax.token(42 /* WhileKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false);
+        };
+
+        WhileStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        WhileStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        WhileStatementSyntax.prototype.withWhileKeyword = function (whileKeyword) {
+            return this.update(whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement);
+        };
+
+        WhileStatementSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.whileKeyword, openParenToken, this.condition, this.closeParenToken, this.statement);
+        };
+
+        WhileStatementSyntax.prototype.withCondition = function (condition) {
+            return this.update(this.whileKeyword, this.openParenToken, condition, this.closeParenToken, this.statement);
+        };
+
+        WhileStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.whileKeyword, this.openParenToken, this.condition, closeParenToken, this.statement);
+        };
+
+        WhileStatementSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, statement);
+        };
+
+        WhileStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.condition.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return WhileStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.WhileStatementSyntax = WhileStatementSyntax;
+
+    var WithStatementSyntax = (function (_super) {
+        __extends(WithStatementSyntax, _super);
+        function WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.withKeyword = withKeyword;
+            this.openParenToken = openParenToken;
+            this.condition = condition;
+            this.closeParenToken = closeParenToken;
+            this.statement = statement;
+        }
+        WithStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitWithStatement(this);
+        };
+
+        WithStatementSyntax.prototype.kind = function () {
+            return 163 /* WithStatement */;
+        };
+
+        WithStatementSyntax.prototype.childCount = function () {
+            return 5;
+        };
+
+        WithStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.withKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.condition;
+                case 3:
+                    return this.closeParenToken;
+                case 4:
+                    return this.statement;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        WithStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        WithStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        WithStatementSyntax.prototype.update = function (withKeyword, openParenToken, condition, closeParenToken, statement) {
+            if (this.withKeyword === withKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.statement === statement) {
+                return this;
+            }
+
+            return new WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, this.parsedInStrictMode());
+        };
+
+        WithStatementSyntax.create1 = function (condition, statement) {
+            return new WithStatementSyntax(TypeScript.Syntax.token(43 /* WithKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false);
+        };
+
+        WithStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        WithStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        WithStatementSyntax.prototype.withWithKeyword = function (withKeyword) {
+            return this.update(withKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement);
+        };
+
+        WithStatementSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.withKeyword, openParenToken, this.condition, this.closeParenToken, this.statement);
+        };
+
+        WithStatementSyntax.prototype.withCondition = function (condition) {
+            return this.update(this.withKeyword, this.openParenToken, condition, this.closeParenToken, this.statement);
+        };
+
+        WithStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.withKeyword, this.openParenToken, this.condition, closeParenToken, this.statement);
+        };
+
+        WithStatementSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.withKeyword, this.openParenToken, this.condition, this.closeParenToken, statement);
+        };
+
+        WithStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.condition.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return WithStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.WithStatementSyntax = WithStatementSyntax;
+
+    var EnumDeclarationSyntax = (function (_super) {
+        __extends(EnumDeclarationSyntax, _super);
+        function EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.enumKeyword = enumKeyword;
+            this.identifier = identifier;
+            this.openBraceToken = openBraceToken;
+            this.enumElements = enumElements;
+            this.closeBraceToken = closeBraceToken;
+        }
+        EnumDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitEnumDeclaration(this);
+        };
+
+        EnumDeclarationSyntax.prototype.kind = function () {
+            return 132 /* EnumDeclaration */;
+        };
+
+        EnumDeclarationSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        EnumDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.enumKeyword;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.openBraceToken;
+                case 4:
+                    return this.enumElements;
+                case 5:
+                    return this.closeBraceToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        EnumDeclarationSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        EnumDeclarationSyntax.prototype.update = function (modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken) {
+            if (this.modifiers === modifiers && this.enumKeyword === enumKeyword && this.identifier === identifier && this.openBraceToken === openBraceToken && this.enumElements === enumElements && this.closeBraceToken === closeBraceToken) {
+                return this;
+            }
+
+            return new EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, this.parsedInStrictMode());
+        };
+
+        EnumDeclarationSyntax.create = function (enumKeyword, identifier, openBraceToken, closeBraceToken) {
+            return new EnumDeclarationSyntax(TypeScript.Syntax.emptyList, enumKeyword, identifier, openBraceToken, TypeScript.Syntax.emptySeparatedList, closeBraceToken, false);
+        };
+
+        EnumDeclarationSyntax.create1 = function (identifier) {
+            return new EnumDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(46 /* EnumKeyword */), identifier, TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false);
+        };
+
+        EnumDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        EnumDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        EnumDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.enumKeyword, this.identifier, this.openBraceToken, this.enumElements, this.closeBraceToken);
+        };
+
+        EnumDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        EnumDeclarationSyntax.prototype.withEnumKeyword = function (enumKeyword) {
+            return this.update(this.modifiers, enumKeyword, this.identifier, this.openBraceToken, this.enumElements, this.closeBraceToken);
+        };
+
+        EnumDeclarationSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.modifiers, this.enumKeyword, identifier, this.openBraceToken, this.enumElements, this.closeBraceToken);
+        };
+
+        EnumDeclarationSyntax.prototype.withOpenBraceToken = function (openBraceToken) {
+            return this.update(this.modifiers, this.enumKeyword, this.identifier, openBraceToken, this.enumElements, this.closeBraceToken);
+        };
+
+        EnumDeclarationSyntax.prototype.withEnumElements = function (enumElements) {
+            return this.update(this.modifiers, this.enumKeyword, this.identifier, this.openBraceToken, enumElements, this.closeBraceToken);
+        };
+
+        EnumDeclarationSyntax.prototype.withEnumElement = function (enumElement) {
+            return this.withEnumElements(TypeScript.Syntax.separatedList([enumElement]));
+        };
+
+        EnumDeclarationSyntax.prototype.withCloseBraceToken = function (closeBraceToken) {
+            return this.update(this.modifiers, this.enumKeyword, this.identifier, this.openBraceToken, this.enumElements, closeBraceToken);
+        };
+
+        EnumDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return EnumDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.EnumDeclarationSyntax = EnumDeclarationSyntax;
+
+    var EnumElementSyntax = (function (_super) {
+        __extends(EnumElementSyntax, _super);
+        function EnumElementSyntax(propertyName, equalsValueClause, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.propertyName = propertyName;
+            this.equalsValueClause = equalsValueClause;
+        }
+        EnumElementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitEnumElement(this);
+        };
+
+        EnumElementSyntax.prototype.kind = function () {
+            return 243 /* EnumElement */;
+        };
+
+        EnumElementSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        EnumElementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.propertyName;
+                case 1:
+                    return this.equalsValueClause;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        EnumElementSyntax.prototype.update = function (propertyName, equalsValueClause) {
+            if (this.propertyName === propertyName && this.equalsValueClause === equalsValueClause) {
+                return this;
+            }
+
+            return new EnumElementSyntax(propertyName, equalsValueClause, this.parsedInStrictMode());
+        };
+
+        EnumElementSyntax.create = function (propertyName) {
+            return new EnumElementSyntax(propertyName, null, false);
+        };
+
+        EnumElementSyntax.create1 = function (propertyName) {
+            return new EnumElementSyntax(propertyName, null, false);
+        };
+
+        EnumElementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        EnumElementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        EnumElementSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(propertyName, this.equalsValueClause);
+        };
+
+        EnumElementSyntax.prototype.withEqualsValueClause = function (equalsValueClause) {
+            return this.update(this.propertyName, equalsValueClause);
+        };
+
+        EnumElementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.equalsValueClause !== null && this.equalsValueClause.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return EnumElementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.EnumElementSyntax = EnumElementSyntax;
+
+    var CastExpressionSyntax = (function (_super) {
+        __extends(CastExpressionSyntax, _super);
+        function CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.lessThanToken = lessThanToken;
+            this.type = type;
+            this.greaterThanToken = greaterThanToken;
+            this.expression = expression;
+        }
+        CastExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitCastExpression(this);
+        };
+
+        CastExpressionSyntax.prototype.kind = function () {
+            return 220 /* CastExpression */;
+        };
+
+        CastExpressionSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        CastExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.lessThanToken;
+                case 1:
+                    return this.type;
+                case 2:
+                    return this.greaterThanToken;
+                case 3:
+                    return this.expression;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        CastExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        CastExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        CastExpressionSyntax.prototype.update = function (lessThanToken, type, greaterThanToken, expression) {
+            if (this.lessThanToken === lessThanToken && this.type === type && this.greaterThanToken === greaterThanToken && this.expression === expression) {
+                return this;
+            }
+
+            return new CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, this.parsedInStrictMode());
+        };
+
+        CastExpressionSyntax.create1 = function (type, expression) {
+            return new CastExpressionSyntax(TypeScript.Syntax.token(80 /* LessThanToken */), type, TypeScript.Syntax.token(81 /* GreaterThanToken */), expression, false);
+        };
+
+        CastExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        CastExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        CastExpressionSyntax.prototype.withLessThanToken = function (lessThanToken) {
+            return this.update(lessThanToken, this.type, this.greaterThanToken, this.expression);
+        };
+
+        CastExpressionSyntax.prototype.withType = function (type) {
+            return this.update(this.lessThanToken, type, this.greaterThanToken, this.expression);
+        };
+
+        CastExpressionSyntax.prototype.withGreaterThanToken = function (greaterThanToken) {
+            return this.update(this.lessThanToken, this.type, greaterThanToken, this.expression);
+        };
+
+        CastExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.lessThanToken, this.type, this.greaterThanToken, expression);
+        };
+
+        CastExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return CastExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.CastExpressionSyntax = CastExpressionSyntax;
+
+    var ObjectLiteralExpressionSyntax = (function (_super) {
+        __extends(ObjectLiteralExpressionSyntax, _super);
+        function ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.openBraceToken = openBraceToken;
+            this.propertyAssignments = propertyAssignments;
+            this.closeBraceToken = closeBraceToken;
+        }
+        ObjectLiteralExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitObjectLiteralExpression(this);
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.kind = function () {
+            return 215 /* ObjectLiteralExpression */;
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.openBraceToken;
+                case 1:
+                    return this.propertyAssignments;
+                case 2:
+                    return this.closeBraceToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.isPrimaryExpression = function () {
+            return true;
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.update = function (openBraceToken, propertyAssignments, closeBraceToken) {
+            if (this.openBraceToken === openBraceToken && this.propertyAssignments === propertyAssignments && this.closeBraceToken === closeBraceToken) {
+                return this;
+            }
+
+            return new ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, this.parsedInStrictMode());
+        };
+
+        ObjectLiteralExpressionSyntax.create = function (openBraceToken, closeBraceToken) {
+            return new ObjectLiteralExpressionSyntax(openBraceToken, TypeScript.Syntax.emptySeparatedList, closeBraceToken, false);
+        };
+
+        ObjectLiteralExpressionSyntax.create1 = function () {
+            return new ObjectLiteralExpressionSyntax(TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false);
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.withOpenBraceToken = function (openBraceToken) {
+            return this.update(openBraceToken, this.propertyAssignments, this.closeBraceToken);
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.withPropertyAssignments = function (propertyAssignments) {
+            return this.update(this.openBraceToken, propertyAssignments, this.closeBraceToken);
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.withPropertyAssignment = function (propertyAssignment) {
+            return this.withPropertyAssignments(TypeScript.Syntax.separatedList([propertyAssignment]));
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.withCloseBraceToken = function (closeBraceToken) {
+            return this.update(this.openBraceToken, this.propertyAssignments, closeBraceToken);
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.propertyAssignments.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ObjectLiteralExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ObjectLiteralExpressionSyntax = ObjectLiteralExpressionSyntax;
+
+    var SimplePropertyAssignmentSyntax = (function (_super) {
+        __extends(SimplePropertyAssignmentSyntax, _super);
+        function SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.propertyName = propertyName;
+            this.colonToken = colonToken;
+            this.expression = expression;
+        }
+        SimplePropertyAssignmentSyntax.prototype.accept = function (visitor) {
+            return visitor.visitSimplePropertyAssignment(this);
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.kind = function () {
+            return 240 /* SimplePropertyAssignment */;
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.propertyName;
+                case 1:
+                    return this.colonToken;
+                case 2:
+                    return this.expression;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.isPropertyAssignment = function () {
+            return true;
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.update = function (propertyName, colonToken, expression) {
+            if (this.propertyName === propertyName && this.colonToken === colonToken && this.expression === expression) {
+                return this;
+            }
+
+            return new SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, this.parsedInStrictMode());
+        };
+
+        SimplePropertyAssignmentSyntax.create1 = function (propertyName, expression) {
+            return new SimplePropertyAssignmentSyntax(propertyName, TypeScript.Syntax.token(106 /* ColonToken */), expression, false);
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(propertyName, this.colonToken, this.expression);
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.withColonToken = function (colonToken) {
+            return this.update(this.propertyName, colonToken, this.expression);
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.propertyName, this.colonToken, expression);
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return SimplePropertyAssignmentSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.SimplePropertyAssignmentSyntax = SimplePropertyAssignmentSyntax;
+
+    var FunctionPropertyAssignmentSyntax = (function (_super) {
+        __extends(FunctionPropertyAssignmentSyntax, _super);
+        function FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.propertyName = propertyName;
+            this.callSignature = callSignature;
+            this.block = block;
+        }
+        FunctionPropertyAssignmentSyntax.prototype.accept = function (visitor) {
+            return visitor.visitFunctionPropertyAssignment(this);
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.kind = function () {
+            return 241 /* FunctionPropertyAssignment */;
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.propertyName;
+                case 1:
+                    return this.callSignature;
+                case 2:
+                    return this.block;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.isPropertyAssignment = function () {
+            return true;
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.update = function (propertyName, callSignature, block) {
+            if (this.propertyName === propertyName && this.callSignature === callSignature && this.block === block) {
+                return this;
+            }
+
+            return new FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, this.parsedInStrictMode());
+        };
+
+        FunctionPropertyAssignmentSyntax.create1 = function (propertyName) {
+            return new FunctionPropertyAssignmentSyntax(propertyName, CallSignatureSyntax.create1(), BlockSyntax.create1(), false);
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(propertyName, this.callSignature, this.block);
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(this.propertyName, callSignature, this.block);
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.withBlock = function (block) {
+            return this.update(this.propertyName, this.callSignature, block);
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.callSignature.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.block.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return FunctionPropertyAssignmentSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.FunctionPropertyAssignmentSyntax = FunctionPropertyAssignmentSyntax;
+
+    var FunctionExpressionSyntax = (function (_super) {
+        __extends(FunctionExpressionSyntax, _super);
+        function FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.functionKeyword = functionKeyword;
+            this.identifier = identifier;
+            this.callSignature = callSignature;
+            this.block = block;
+        }
+        FunctionExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitFunctionExpression(this);
+        };
+
+        FunctionExpressionSyntax.prototype.kind = function () {
+            return 222 /* FunctionExpression */;
+        };
+
+        FunctionExpressionSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        FunctionExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.functionKeyword;
+                case 1:
+                    return this.identifier;
+                case 2:
+                    return this.callSignature;
+                case 3:
+                    return this.block;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        FunctionExpressionSyntax.prototype.isPrimaryExpression = function () {
+            return true;
+        };
+
+        FunctionExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        FunctionExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        FunctionExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        FunctionExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        FunctionExpressionSyntax.prototype.update = function (functionKeyword, identifier, callSignature, block) {
+            if (this.functionKeyword === functionKeyword && this.identifier === identifier && this.callSignature === callSignature && this.block === block) {
+                return this;
+            }
+
+            return new FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, this.parsedInStrictMode());
+        };
+
+        FunctionExpressionSyntax.create = function (functionKeyword, callSignature, block) {
+            return new FunctionExpressionSyntax(functionKeyword, null, callSignature, block, false);
+        };
+
+        FunctionExpressionSyntax.create1 = function () {
+            return new FunctionExpressionSyntax(TypeScript.Syntax.token(27 /* FunctionKeyword */), null, CallSignatureSyntax.create1(), BlockSyntax.create1(), false);
+        };
+
+        FunctionExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        FunctionExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        FunctionExpressionSyntax.prototype.withFunctionKeyword = function (functionKeyword) {
+            return this.update(functionKeyword, this.identifier, this.callSignature, this.block);
+        };
+
+        FunctionExpressionSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.functionKeyword, identifier, this.callSignature, this.block);
+        };
+
+        FunctionExpressionSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(this.functionKeyword, this.identifier, callSignature, this.block);
+        };
+
+        FunctionExpressionSyntax.prototype.withBlock = function (block) {
+            return this.update(this.functionKeyword, this.identifier, this.callSignature, block);
+        };
+
+        FunctionExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.callSignature.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.block.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return FunctionExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.FunctionExpressionSyntax = FunctionExpressionSyntax;
+
+    var EmptyStatementSyntax = (function (_super) {
+        __extends(EmptyStatementSyntax, _super);
+        function EmptyStatementSyntax(semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.semicolonToken = semicolonToken;
+        }
+        EmptyStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitEmptyStatement(this);
+        };
+
+        EmptyStatementSyntax.prototype.kind = function () {
+            return 156 /* EmptyStatement */;
+        };
+
+        EmptyStatementSyntax.prototype.childCount = function () {
+            return 1;
+        };
+
+        EmptyStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        EmptyStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        EmptyStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        EmptyStatementSyntax.prototype.update = function (semicolonToken) {
+            if (this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new EmptyStatementSyntax(semicolonToken, this.parsedInStrictMode());
+        };
+
+        EmptyStatementSyntax.create1 = function () {
+            return new EmptyStatementSyntax(TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        EmptyStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        EmptyStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        EmptyStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(semicolonToken);
+        };
+
+        EmptyStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            return false;
+        };
+        return EmptyStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.EmptyStatementSyntax = EmptyStatementSyntax;
+
+    var TryStatementSyntax = (function (_super) {
+        __extends(TryStatementSyntax, _super);
+        function TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.tryKeyword = tryKeyword;
+            this.block = block;
+            this.catchClause = catchClause;
+            this.finallyClause = finallyClause;
+        }
+        TryStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitTryStatement(this);
+        };
+
+        TryStatementSyntax.prototype.kind = function () {
+            return 159 /* TryStatement */;
+        };
+
+        TryStatementSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        TryStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.tryKeyword;
+                case 1:
+                    return this.block;
+                case 2:
+                    return this.catchClause;
+                case 3:
+                    return this.finallyClause;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        TryStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        TryStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        TryStatementSyntax.prototype.update = function (tryKeyword, block, catchClause, finallyClause) {
+            if (this.tryKeyword === tryKeyword && this.block === block && this.catchClause === catchClause && this.finallyClause === finallyClause) {
+                return this;
+            }
+
+            return new TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, this.parsedInStrictMode());
+        };
+
+        TryStatementSyntax.create = function (tryKeyword, block) {
+            return new TryStatementSyntax(tryKeyword, block, null, null, false);
+        };
+
+        TryStatementSyntax.create1 = function () {
+            return new TryStatementSyntax(TypeScript.Syntax.token(38 /* TryKeyword */), BlockSyntax.create1(), null, null, false);
+        };
+
+        TryStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        TryStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        TryStatementSyntax.prototype.withTryKeyword = function (tryKeyword) {
+            return this.update(tryKeyword, this.block, this.catchClause, this.finallyClause);
+        };
+
+        TryStatementSyntax.prototype.withBlock = function (block) {
+            return this.update(this.tryKeyword, block, this.catchClause, this.finallyClause);
+        };
+
+        TryStatementSyntax.prototype.withCatchClause = function (catchClause) {
+            return this.update(this.tryKeyword, this.block, catchClause, this.finallyClause);
+        };
+
+        TryStatementSyntax.prototype.withFinallyClause = function (finallyClause) {
+            return this.update(this.tryKeyword, this.block, this.catchClause, finallyClause);
+        };
+
+        TryStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.block.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.catchClause !== null && this.catchClause.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.finallyClause !== null && this.finallyClause.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return TryStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.TryStatementSyntax = TryStatementSyntax;
+
+    var CatchClauseSyntax = (function (_super) {
+        __extends(CatchClauseSyntax, _super);
+        function CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.catchKeyword = catchKeyword;
+            this.openParenToken = openParenToken;
+            this.identifier = identifier;
+            this.typeAnnotation = typeAnnotation;
+            this.closeParenToken = closeParenToken;
+            this.block = block;
+        }
+        CatchClauseSyntax.prototype.accept = function (visitor) {
+            return visitor.visitCatchClause(this);
+        };
+
+        CatchClauseSyntax.prototype.kind = function () {
+            return 236 /* CatchClause */;
+        };
+
+        CatchClauseSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        CatchClauseSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.catchKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.typeAnnotation;
+                case 4:
+                    return this.closeParenToken;
+                case 5:
+                    return this.block;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        CatchClauseSyntax.prototype.update = function (catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block) {
+            if (this.catchKeyword === catchKeyword && this.openParenToken === openParenToken && this.identifier === identifier && this.typeAnnotation === typeAnnotation && this.closeParenToken === closeParenToken && this.block === block) {
+                return this;
+            }
+
+            return new CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, this.parsedInStrictMode());
+        };
+
+        CatchClauseSyntax.create = function (catchKeyword, openParenToken, identifier, closeParenToken, block) {
+            return new CatchClauseSyntax(catchKeyword, openParenToken, identifier, null, closeParenToken, block, false);
+        };
+
+        CatchClauseSyntax.create1 = function (identifier) {
+            return new CatchClauseSyntax(TypeScript.Syntax.token(17 /* CatchKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), identifier, null, TypeScript.Syntax.token(73 /* CloseParenToken */), BlockSyntax.create1(), false);
+        };
+
+        CatchClauseSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        CatchClauseSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        CatchClauseSyntax.prototype.withCatchKeyword = function (catchKeyword) {
+            return this.update(catchKeyword, this.openParenToken, this.identifier, this.typeAnnotation, this.closeParenToken, this.block);
+        };
+
+        CatchClauseSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.catchKeyword, openParenToken, this.identifier, this.typeAnnotation, this.closeParenToken, this.block);
+        };
+
+        CatchClauseSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.catchKeyword, this.openParenToken, identifier, this.typeAnnotation, this.closeParenToken, this.block);
+        };
+
+        CatchClauseSyntax.prototype.withTypeAnnotation = function (typeAnnotation) {
+            return this.update(this.catchKeyword, this.openParenToken, this.identifier, typeAnnotation, this.closeParenToken, this.block);
+        };
+
+        CatchClauseSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.catchKeyword, this.openParenToken, this.identifier, this.typeAnnotation, closeParenToken, this.block);
+        };
+
+        CatchClauseSyntax.prototype.withBlock = function (block) {
+            return this.update(this.catchKeyword, this.openParenToken, this.identifier, this.typeAnnotation, this.closeParenToken, block);
+        };
+
+        CatchClauseSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.typeAnnotation !== null && this.typeAnnotation.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.block.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return CatchClauseSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.CatchClauseSyntax = CatchClauseSyntax;
+
+    var FinallyClauseSyntax = (function (_super) {
+        __extends(FinallyClauseSyntax, _super);
+        function FinallyClauseSyntax(finallyKeyword, block, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.finallyKeyword = finallyKeyword;
+            this.block = block;
+        }
+        FinallyClauseSyntax.prototype.accept = function (visitor) {
+            return visitor.visitFinallyClause(this);
+        };
+
+        FinallyClauseSyntax.prototype.kind = function () {
+            return 237 /* FinallyClause */;
+        };
+
+        FinallyClauseSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        FinallyClauseSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.finallyKeyword;
+                case 1:
+                    return this.block;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        FinallyClauseSyntax.prototype.update = function (finallyKeyword, block) {
+            if (this.finallyKeyword === finallyKeyword && this.block === block) {
+                return this;
+            }
+
+            return new FinallyClauseSyntax(finallyKeyword, block, this.parsedInStrictMode());
+        };
+
+        FinallyClauseSyntax.create1 = function () {
+            return new FinallyClauseSyntax(TypeScript.Syntax.token(25 /* FinallyKeyword */), BlockSyntax.create1(), false);
+        };
+
+        FinallyClauseSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        FinallyClauseSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        FinallyClauseSyntax.prototype.withFinallyKeyword = function (finallyKeyword) {
+            return this.update(finallyKeyword, this.block);
+        };
+
+        FinallyClauseSyntax.prototype.withBlock = function (block) {
+            return this.update(this.finallyKeyword, block);
+        };
+
+        FinallyClauseSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.block.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return FinallyClauseSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.FinallyClauseSyntax = FinallyClauseSyntax;
+
+    var LabeledStatementSyntax = (function (_super) {
+        __extends(LabeledStatementSyntax, _super);
+        function LabeledStatementSyntax(identifier, colonToken, statement, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.identifier = identifier;
+            this.colonToken = colonToken;
+            this.statement = statement;
+        }
+        LabeledStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitLabeledStatement(this);
+        };
+
+        LabeledStatementSyntax.prototype.kind = function () {
+            return 160 /* LabeledStatement */;
+        };
+
+        LabeledStatementSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        LabeledStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.identifier;
+                case 1:
+                    return this.colonToken;
+                case 2:
+                    return this.statement;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        LabeledStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        LabeledStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        LabeledStatementSyntax.prototype.update = function (identifier, colonToken, statement) {
+            if (this.identifier === identifier && this.colonToken === colonToken && this.statement === statement) {
+                return this;
+            }
+
+            return new LabeledStatementSyntax(identifier, colonToken, statement, this.parsedInStrictMode());
+        };
+
+        LabeledStatementSyntax.create1 = function (identifier, statement) {
+            return new LabeledStatementSyntax(identifier, TypeScript.Syntax.token(106 /* ColonToken */), statement, false);
+        };
+
+        LabeledStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        LabeledStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        LabeledStatementSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(identifier, this.colonToken, this.statement);
+        };
+
+        LabeledStatementSyntax.prototype.withColonToken = function (colonToken) {
+            return this.update(this.identifier, colonToken, this.statement);
+        };
+
+        LabeledStatementSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.identifier, this.colonToken, statement);
+        };
+
+        LabeledStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return LabeledStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.LabeledStatementSyntax = LabeledStatementSyntax;
+
+    var DoStatementSyntax = (function (_super) {
+        __extends(DoStatementSyntax, _super);
+        function DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.doKeyword = doKeyword;
+            this.statement = statement;
+            this.whileKeyword = whileKeyword;
+            this.openParenToken = openParenToken;
+            this.condition = condition;
+            this.closeParenToken = closeParenToken;
+            this.semicolonToken = semicolonToken;
+        }
+        DoStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitDoStatement(this);
+        };
+
+        DoStatementSyntax.prototype.kind = function () {
+            return 161 /* DoStatement */;
+        };
+
+        DoStatementSyntax.prototype.childCount = function () {
+            return 7;
+        };
+
+        DoStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.doKeyword;
+                case 1:
+                    return this.statement;
+                case 2:
+                    return this.whileKeyword;
+                case 3:
+                    return this.openParenToken;
+                case 4:
+                    return this.condition;
+                case 5:
+                    return this.closeParenToken;
+                case 6:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        DoStatementSyntax.prototype.isIterationStatement = function () {
+            return true;
+        };
+
+        DoStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        DoStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        DoStatementSyntax.prototype.update = function (doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken) {
+            if (this.doKeyword === doKeyword && this.statement === statement && this.whileKeyword === whileKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, this.parsedInStrictMode());
+        };
+
+        DoStatementSyntax.create1 = function (statement, condition) {
+            return new DoStatementSyntax(TypeScript.Syntax.token(22 /* DoKeyword */), statement, TypeScript.Syntax.token(42 /* WhileKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        DoStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        DoStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        DoStatementSyntax.prototype.withDoKeyword = function (doKeyword) {
+            return this.update(doKeyword, this.statement, this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.semicolonToken);
+        };
+
+        DoStatementSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.doKeyword, statement, this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.semicolonToken);
+        };
+
+        DoStatementSyntax.prototype.withWhileKeyword = function (whileKeyword) {
+            return this.update(this.doKeyword, this.statement, whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.semicolonToken);
+        };
+
+        DoStatementSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.doKeyword, this.statement, this.whileKeyword, openParenToken, this.condition, this.closeParenToken, this.semicolonToken);
+        };
+
+        DoStatementSyntax.prototype.withCondition = function (condition) {
+            return this.update(this.doKeyword, this.statement, this.whileKeyword, this.openParenToken, condition, this.closeParenToken, this.semicolonToken);
+        };
+
+        DoStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.doKeyword, this.statement, this.whileKeyword, this.openParenToken, this.condition, closeParenToken, this.semicolonToken);
+        };
+
+        DoStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.doKeyword, this.statement, this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, semicolonToken);
+        };
+
+        DoStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.condition.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return DoStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.DoStatementSyntax = DoStatementSyntax;
+
+    var TypeOfExpressionSyntax = (function (_super) {
+        __extends(TypeOfExpressionSyntax, _super);
+        function TypeOfExpressionSyntax(typeOfKeyword, expression, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.typeOfKeyword = typeOfKeyword;
+            this.expression = expression;
+        }
+        TypeOfExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitTypeOfExpression(this);
+        };
+
+        TypeOfExpressionSyntax.prototype.kind = function () {
+            return 171 /* TypeOfExpression */;
+        };
+
+        TypeOfExpressionSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        TypeOfExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.typeOfKeyword;
+                case 1:
+                    return this.expression;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        TypeOfExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        TypeOfExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        TypeOfExpressionSyntax.prototype.update = function (typeOfKeyword, expression) {
+            if (this.typeOfKeyword === typeOfKeyword && this.expression === expression) {
+                return this;
+            }
+
+            return new TypeOfExpressionSyntax(typeOfKeyword, expression, this.parsedInStrictMode());
+        };
+
+        TypeOfExpressionSyntax.create1 = function (expression) {
+            return new TypeOfExpressionSyntax(TypeScript.Syntax.token(39 /* TypeOfKeyword */), expression, false);
+        };
+
+        TypeOfExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        TypeOfExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        TypeOfExpressionSyntax.prototype.withTypeOfKeyword = function (typeOfKeyword) {
+            return this.update(typeOfKeyword, this.expression);
+        };
+
+        TypeOfExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.typeOfKeyword, expression);
+        };
+
+        TypeOfExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return TypeOfExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.TypeOfExpressionSyntax = TypeOfExpressionSyntax;
+
+    var DeleteExpressionSyntax = (function (_super) {
+        __extends(DeleteExpressionSyntax, _super);
+        function DeleteExpressionSyntax(deleteKeyword, expression, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.deleteKeyword = deleteKeyword;
+            this.expression = expression;
+        }
+        DeleteExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitDeleteExpression(this);
+        };
+
+        DeleteExpressionSyntax.prototype.kind = function () {
+            return 170 /* DeleteExpression */;
+        };
+
+        DeleteExpressionSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        DeleteExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.deleteKeyword;
+                case 1:
+                    return this.expression;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        DeleteExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        DeleteExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        DeleteExpressionSyntax.prototype.update = function (deleteKeyword, expression) {
+            if (this.deleteKeyword === deleteKeyword && this.expression === expression) {
+                return this;
+            }
+
+            return new DeleteExpressionSyntax(deleteKeyword, expression, this.parsedInStrictMode());
+        };
+
+        DeleteExpressionSyntax.create1 = function (expression) {
+            return new DeleteExpressionSyntax(TypeScript.Syntax.token(21 /* DeleteKeyword */), expression, false);
+        };
+
+        DeleteExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        DeleteExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        DeleteExpressionSyntax.prototype.withDeleteKeyword = function (deleteKeyword) {
+            return this.update(deleteKeyword, this.expression);
+        };
+
+        DeleteExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.deleteKeyword, expression);
+        };
+
+        DeleteExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return DeleteExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.DeleteExpressionSyntax = DeleteExpressionSyntax;
+
+    var VoidExpressionSyntax = (function (_super) {
+        __extends(VoidExpressionSyntax, _super);
+        function VoidExpressionSyntax(voidKeyword, expression, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.voidKeyword = voidKeyword;
+            this.expression = expression;
+        }
+        VoidExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitVoidExpression(this);
+        };
+
+        VoidExpressionSyntax.prototype.kind = function () {
+            return 172 /* VoidExpression */;
+        };
+
+        VoidExpressionSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        VoidExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.voidKeyword;
+                case 1:
+                    return this.expression;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        VoidExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        VoidExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        VoidExpressionSyntax.prototype.update = function (voidKeyword, expression) {
+            if (this.voidKeyword === voidKeyword && this.expression === expression) {
+                return this;
+            }
+
+            return new VoidExpressionSyntax(voidKeyword, expression, this.parsedInStrictMode());
+        };
+
+        VoidExpressionSyntax.create1 = function (expression) {
+            return new VoidExpressionSyntax(TypeScript.Syntax.token(41 /* VoidKeyword */), expression, false);
+        };
+
+        VoidExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        VoidExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        VoidExpressionSyntax.prototype.withVoidKeyword = function (voidKeyword) {
+            return this.update(voidKeyword, this.expression);
+        };
+
+        VoidExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.voidKeyword, expression);
+        };
+
+        VoidExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return VoidExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.VoidExpressionSyntax = VoidExpressionSyntax;
+
+    var DebuggerStatementSyntax = (function (_super) {
+        __extends(DebuggerStatementSyntax, _super);
+        function DebuggerStatementSyntax(debuggerKeyword, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.debuggerKeyword = debuggerKeyword;
+            this.semicolonToken = semicolonToken;
+        }
+        DebuggerStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitDebuggerStatement(this);
+        };
+
+        DebuggerStatementSyntax.prototype.kind = function () {
+            return 162 /* DebuggerStatement */;
+        };
+
+        DebuggerStatementSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        DebuggerStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.debuggerKeyword;
+                case 1:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        DebuggerStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        DebuggerStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        DebuggerStatementSyntax.prototype.update = function (debuggerKeyword, semicolonToken) {
+            if (this.debuggerKeyword === debuggerKeyword && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new DebuggerStatementSyntax(debuggerKeyword, semicolonToken, this.parsedInStrictMode());
+        };
+
+        DebuggerStatementSyntax.create1 = function () {
+            return new DebuggerStatementSyntax(TypeScript.Syntax.token(19 /* DebuggerKeyword */), TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        DebuggerStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        DebuggerStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        DebuggerStatementSyntax.prototype.withDebuggerKeyword = function (debuggerKeyword) {
+            return this.update(debuggerKeyword, this.semicolonToken);
+        };
+
+        DebuggerStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.debuggerKeyword, semicolonToken);
+        };
+
+        DebuggerStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            return false;
+        };
+        return DebuggerStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.DebuggerStatementSyntax = DebuggerStatementSyntax;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxRewriter = (function () {
+        function SyntaxRewriter() {
+        }
+        SyntaxRewriter.prototype.visitToken = function (token) {
+            return token;
+        };
+
+        SyntaxRewriter.prototype.visitNode = function (node) {
+            return node.accept(this);
+        };
+
+        SyntaxRewriter.prototype.visitNodeOrToken = function (node) {
+            return node.isToken() ? this.visitToken(node) : this.visitNode(node);
+        };
+
+        SyntaxRewriter.prototype.visitList = function (list) {
+            var newItems = null;
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var item = list.childAt(i);
+                var newItem = this.visitNodeOrToken(item);
+
+                if (item !== newItem && newItems === null) {
+                    newItems = [];
+                    for (var j = 0; j < i; j++) {
+                        newItems.push(list.childAt(j));
+                    }
+                }
+
+                if (newItems) {
+                    newItems.push(newItem);
+                }
+            }
+
+            return newItems === null ? list : TypeScript.Syntax.list(newItems);
+        };
+
+        SyntaxRewriter.prototype.visitSeparatedList = function (list) {
+            var newItems = null;
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var item = list.childAt(i);
+                var newItem = item.isToken() ? this.visitToken(item) : this.visitNode(item);
+
+                if (item !== newItem && newItems === null) {
+                    newItems = [];
+                    for (var j = 0; j < i; j++) {
+                        newItems.push(list.childAt(j));
+                    }
+                }
+
+                if (newItems) {
+                    newItems.push(newItem);
+                }
+            }
+
+            return newItems === null ? list : TypeScript.Syntax.separatedList(newItems);
+        };
+
+        SyntaxRewriter.prototype.visitSourceUnit = function (node) {
+            return node.update(this.visitList(node.moduleElements), this.visitToken(node.endOfFileToken));
+        };
+
+        SyntaxRewriter.prototype.visitExternalModuleReference = function (node) {
+            return node.update(this.visitToken(node.requireKeyword), this.visitToken(node.openParenToken), this.visitToken(node.stringLiteral), this.visitToken(node.closeParenToken));
+        };
+
+        SyntaxRewriter.prototype.visitModuleNameModuleReference = function (node) {
+            return node.update(this.visitNodeOrToken(node.moduleName));
+        };
+
+        SyntaxRewriter.prototype.visitImportDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.importKeyword), this.visitToken(node.identifier), this.visitToken(node.equalsToken), this.visitNodeOrToken(node.moduleReference), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitExportAssignment = function (node) {
+            return node.update(this.visitToken(node.exportKeyword), this.visitToken(node.equalsToken), this.visitToken(node.identifier), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitClassDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.classKeyword), this.visitToken(node.identifier), node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitList(node.heritageClauses), this.visitToken(node.openBraceToken), this.visitList(node.classElements), this.visitToken(node.closeBraceToken));
+        };
+
+        SyntaxRewriter.prototype.visitInterfaceDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.interfaceKeyword), this.visitToken(node.identifier), node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitList(node.heritageClauses), this.visitNode(node.body));
+        };
+
+        SyntaxRewriter.prototype.visitHeritageClause = function (node) {
+            return node.update(node.kind(), this.visitToken(node.extendsOrImplementsKeyword), this.visitSeparatedList(node.typeNames));
+        };
+
+        SyntaxRewriter.prototype.visitModuleDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.moduleKeyword), node.name === null ? null : this.visitNodeOrToken(node.name), node.stringLiteral === null ? null : this.visitToken(node.stringLiteral), this.visitToken(node.openBraceToken), this.visitList(node.moduleElements), this.visitToken(node.closeBraceToken));
+        };
+
+        SyntaxRewriter.prototype.visitFunctionDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.functionKeyword), this.visitToken(node.identifier), this.visitNode(node.callSignature), node.block === null ? null : this.visitNode(node.block), node.semicolonToken === null ? null : this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitVariableStatement = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitNode(node.variableDeclaration), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitVariableDeclaration = function (node) {
+            return node.update(this.visitToken(node.varKeyword), this.visitSeparatedList(node.variableDeclarators));
+        };
+
+        SyntaxRewriter.prototype.visitVariableDeclarator = function (node) {
+            return node.update(this.visitToken(node.propertyName), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), node.equalsValueClause === null ? null : this.visitNode(node.equalsValueClause));
+        };
+
+        SyntaxRewriter.prototype.visitEqualsValueClause = function (node) {
+            return node.update(this.visitToken(node.equalsToken), this.visitNodeOrToken(node.value));
+        };
+
+        SyntaxRewriter.prototype.visitPrefixUnaryExpression = function (node) {
+            return node.update(node.kind(), this.visitToken(node.operatorToken), this.visitNodeOrToken(node.operand));
+        };
+
+        SyntaxRewriter.prototype.visitArrayLiteralExpression = function (node) {
+            return node.update(this.visitToken(node.openBracketToken), this.visitSeparatedList(node.expressions), this.visitToken(node.closeBracketToken));
+        };
+
+        SyntaxRewriter.prototype.visitOmittedExpression = function (node) {
+            return node;
+        };
+
+        SyntaxRewriter.prototype.visitParenthesizedExpression = function (node) {
+            return node.update(this.visitToken(node.openParenToken), this.visitNodeOrToken(node.expression), this.visitToken(node.closeParenToken));
+        };
+
+        SyntaxRewriter.prototype.visitSimpleArrowFunctionExpression = function (node) {
+            return node.update(this.visitToken(node.identifier), this.visitToken(node.equalsGreaterThanToken), node.block === null ? null : this.visitNode(node.block), node.expression === null ? null : this.visitNodeOrToken(node.expression));
+        };
+
+        SyntaxRewriter.prototype.visitParenthesizedArrowFunctionExpression = function (node) {
+            return node.update(this.visitNode(node.callSignature), this.visitToken(node.equalsGreaterThanToken), node.block === null ? null : this.visitNode(node.block), node.expression === null ? null : this.visitNodeOrToken(node.expression));
+        };
+
+        SyntaxRewriter.prototype.visitQualifiedName = function (node) {
+            return node.update(this.visitNodeOrToken(node.left), this.visitToken(node.dotToken), this.visitToken(node.right));
+        };
+
+        SyntaxRewriter.prototype.visitTypeArgumentList = function (node) {
+            return node.update(this.visitToken(node.lessThanToken), this.visitSeparatedList(node.typeArguments), this.visitToken(node.greaterThanToken));
+        };
+
+        SyntaxRewriter.prototype.visitConstructorType = function (node) {
+            return node.update(this.visitToken(node.newKeyword), node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitNode(node.parameterList), this.visitToken(node.equalsGreaterThanToken), this.visitNodeOrToken(node.type));
+        };
+
+        SyntaxRewriter.prototype.visitFunctionType = function (node) {
+            return node.update(node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitNode(node.parameterList), this.visitToken(node.equalsGreaterThanToken), this.visitNodeOrToken(node.type));
+        };
+
+        SyntaxRewriter.prototype.visitObjectType = function (node) {
+            return node.update(this.visitToken(node.openBraceToken), this.visitSeparatedList(node.typeMembers), this.visitToken(node.closeBraceToken));
+        };
+
+        SyntaxRewriter.prototype.visitArrayType = function (node) {
+            return node.update(this.visitNodeOrToken(node.type), this.visitToken(node.openBracketToken), this.visitToken(node.closeBracketToken));
+        };
+
+        SyntaxRewriter.prototype.visitGenericType = function (node) {
+            return node.update(this.visitNodeOrToken(node.name), this.visitNode(node.typeArgumentList));
+        };
+
+        SyntaxRewriter.prototype.visitTypeQuery = function (node) {
+            return node.update(this.visitToken(node.typeOfKeyword), this.visitNodeOrToken(node.name));
+        };
+
+        SyntaxRewriter.prototype.visitTypeAnnotation = function (node) {
+            return node.update(this.visitToken(node.colonToken), this.visitNodeOrToken(node.type));
+        };
+
+        SyntaxRewriter.prototype.visitBlock = function (node) {
+            return node.update(this.visitToken(node.openBraceToken), this.visitList(node.statements), this.visitToken(node.closeBraceToken));
+        };
+
+        SyntaxRewriter.prototype.visitParameter = function (node) {
+            return node.update(node.dotDotDotToken === null ? null : this.visitToken(node.dotDotDotToken), this.visitList(node.modifiers), this.visitToken(node.identifier), node.questionToken === null ? null : this.visitToken(node.questionToken), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), node.equalsValueClause === null ? null : this.visitNode(node.equalsValueClause));
+        };
+
+        SyntaxRewriter.prototype.visitMemberAccessExpression = function (node) {
+            return node.update(this.visitNodeOrToken(node.expression), this.visitToken(node.dotToken), this.visitToken(node.name));
+        };
+
+        SyntaxRewriter.prototype.visitPostfixUnaryExpression = function (node) {
+            return node.update(node.kind(), this.visitNodeOrToken(node.operand), this.visitToken(node.operatorToken));
+        };
+
+        SyntaxRewriter.prototype.visitElementAccessExpression = function (node) {
+            return node.update(this.visitNodeOrToken(node.expression), this.visitToken(node.openBracketToken), this.visitNodeOrToken(node.argumentExpression), this.visitToken(node.closeBracketToken));
+        };
+
+        SyntaxRewriter.prototype.visitInvocationExpression = function (node) {
+            return node.update(this.visitNodeOrToken(node.expression), this.visitNode(node.argumentList));
+        };
+
+        SyntaxRewriter.prototype.visitArgumentList = function (node) {
+            return node.update(node.typeArgumentList === null ? null : this.visitNode(node.typeArgumentList), this.visitToken(node.openParenToken), this.visitSeparatedList(node.arguments), this.visitToken(node.closeParenToken));
+        };
+
+        SyntaxRewriter.prototype.visitBinaryExpression = function (node) {
+            return node.update(node.kind(), this.visitNodeOrToken(node.left), this.visitToken(node.operatorToken), this.visitNodeOrToken(node.right));
+        };
+
+        SyntaxRewriter.prototype.visitConditionalExpression = function (node) {
+            return node.update(this.visitNodeOrToken(node.condition), this.visitToken(node.questionToken), this.visitNodeOrToken(node.whenTrue), this.visitToken(node.colonToken), this.visitNodeOrToken(node.whenFalse));
+        };
+
+        SyntaxRewriter.prototype.visitConstructSignature = function (node) {
+            return node.update(this.visitToken(node.newKeyword), this.visitNode(node.callSignature));
+        };
+
+        SyntaxRewriter.prototype.visitMethodSignature = function (node) {
+            return node.update(this.visitToken(node.propertyName), node.questionToken === null ? null : this.visitToken(node.questionToken), this.visitNode(node.callSignature));
+        };
+
+        SyntaxRewriter.prototype.visitIndexSignature = function (node) {
+            return node.update(this.visitToken(node.openBracketToken), this.visitNode(node.parameter), this.visitToken(node.closeBracketToken), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation));
+        };
+
+        SyntaxRewriter.prototype.visitPropertySignature = function (node) {
+            return node.update(this.visitToken(node.propertyName), node.questionToken === null ? null : this.visitToken(node.questionToken), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation));
+        };
+
+        SyntaxRewriter.prototype.visitCallSignature = function (node) {
+            return node.update(node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitNode(node.parameterList), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation));
+        };
+
+        SyntaxRewriter.prototype.visitParameterList = function (node) {
+            return node.update(this.visitToken(node.openParenToken), this.visitSeparatedList(node.parameters), this.visitToken(node.closeParenToken));
+        };
+
+        SyntaxRewriter.prototype.visitTypeParameterList = function (node) {
+            return node.update(this.visitToken(node.lessThanToken), this.visitSeparatedList(node.typeParameters), this.visitToken(node.greaterThanToken));
+        };
+
+        SyntaxRewriter.prototype.visitTypeParameter = function (node) {
+            return node.update(this.visitToken(node.identifier), node.constraint === null ? null : this.visitNode(node.constraint));
+        };
+
+        SyntaxRewriter.prototype.visitConstraint = function (node) {
+            return node.update(this.visitToken(node.extendsKeyword), this.visitNodeOrToken(node.type));
+        };
+
+        SyntaxRewriter.prototype.visitElseClause = function (node) {
+            return node.update(this.visitToken(node.elseKeyword), this.visitNodeOrToken(node.statement));
+        };
+
+        SyntaxRewriter.prototype.visitIfStatement = function (node) {
+            return node.update(this.visitToken(node.ifKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement), node.elseClause === null ? null : this.visitNode(node.elseClause));
+        };
+
+        SyntaxRewriter.prototype.visitExpressionStatement = function (node) {
+            return node.update(this.visitNodeOrToken(node.expression), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitConstructorDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.constructorKeyword), this.visitNode(node.callSignature), node.block === null ? null : this.visitNode(node.block), node.semicolonToken === null ? null : this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitMemberFunctionDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.propertyName), this.visitNode(node.callSignature), node.block === null ? null : this.visitNode(node.block), node.semicolonToken === null ? null : this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitGetAccessor = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.getKeyword), this.visitToken(node.propertyName), this.visitNode(node.parameterList), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), this.visitNode(node.block));
+        };
+
+        SyntaxRewriter.prototype.visitSetAccessor = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.setKeyword), this.visitToken(node.propertyName), this.visitNode(node.parameterList), this.visitNode(node.block));
+        };
+
+        SyntaxRewriter.prototype.visitMemberVariableDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitNode(node.variableDeclarator), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitIndexMemberDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitNode(node.indexSignature), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitThrowStatement = function (node) {
+            return node.update(this.visitToken(node.throwKeyword), this.visitNodeOrToken(node.expression), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitReturnStatement = function (node) {
+            return node.update(this.visitToken(node.returnKeyword), node.expression === null ? null : this.visitNodeOrToken(node.expression), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitObjectCreationExpression = function (node) {
+            return node.update(this.visitToken(node.newKeyword), this.visitNodeOrToken(node.expression), node.argumentList === null ? null : this.visitNode(node.argumentList));
+        };
+
+        SyntaxRewriter.prototype.visitSwitchStatement = function (node) {
+            return node.update(this.visitToken(node.switchKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.expression), this.visitToken(node.closeParenToken), this.visitToken(node.openBraceToken), this.visitList(node.switchClauses), this.visitToken(node.closeBraceToken));
+        };
+
+        SyntaxRewriter.prototype.visitCaseSwitchClause = function (node) {
+            return node.update(this.visitToken(node.caseKeyword), this.visitNodeOrToken(node.expression), this.visitToken(node.colonToken), this.visitList(node.statements));
+        };
+
+        SyntaxRewriter.prototype.visitDefaultSwitchClause = function (node) {
+            return node.update(this.visitToken(node.defaultKeyword), this.visitToken(node.colonToken), this.visitList(node.statements));
+        };
+
+        SyntaxRewriter.prototype.visitBreakStatement = function (node) {
+            return node.update(this.visitToken(node.breakKeyword), node.identifier === null ? null : this.visitToken(node.identifier), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitContinueStatement = function (node) {
+            return node.update(this.visitToken(node.continueKeyword), node.identifier === null ? null : this.visitToken(node.identifier), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitForStatement = function (node) {
+            return node.update(this.visitToken(node.forKeyword), this.visitToken(node.openParenToken), node.variableDeclaration === null ? null : this.visitNode(node.variableDeclaration), node.initializer === null ? null : this.visitNodeOrToken(node.initializer), this.visitToken(node.firstSemicolonToken), node.condition === null ? null : this.visitNodeOrToken(node.condition), this.visitToken(node.secondSemicolonToken), node.incrementor === null ? null : this.visitNodeOrToken(node.incrementor), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement));
+        };
+
+        SyntaxRewriter.prototype.visitForInStatement = function (node) {
+            return node.update(this.visitToken(node.forKeyword), this.visitToken(node.openParenToken), node.variableDeclaration === null ? null : this.visitNode(node.variableDeclaration), node.left === null ? null : this.visitNodeOrToken(node.left), this.visitToken(node.inKeyword), this.visitNodeOrToken(node.expression), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement));
+        };
+
+        SyntaxRewriter.prototype.visitWhileStatement = function (node) {
+            return node.update(this.visitToken(node.whileKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement));
+        };
+
+        SyntaxRewriter.prototype.visitWithStatement = function (node) {
+            return node.update(this.visitToken(node.withKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement));
+        };
+
+        SyntaxRewriter.prototype.visitEnumDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.enumKeyword), this.visitToken(node.identifier), this.visitToken(node.openBraceToken), this.visitSeparatedList(node.enumElements), this.visitToken(node.closeBraceToken));
+        };
+
+        SyntaxRewriter.prototype.visitEnumElement = function (node) {
+            return node.update(this.visitToken(node.propertyName), node.equalsValueClause === null ? null : this.visitNode(node.equalsValueClause));
+        };
+
+        SyntaxRewriter.prototype.visitCastExpression = function (node) {
+            return node.update(this.visitToken(node.lessThanToken), this.visitNodeOrToken(node.type), this.visitToken(node.greaterThanToken), this.visitNodeOrToken(node.expression));
+        };
+
+        SyntaxRewriter.prototype.visitObjectLiteralExpression = function (node) {
+            return node.update(this.visitToken(node.openBraceToken), this.visitSeparatedList(node.propertyAssignments), this.visitToken(node.closeBraceToken));
+        };
+
+        SyntaxRewriter.prototype.visitSimplePropertyAssignment = function (node) {
+            return node.update(this.visitToken(node.propertyName), this.visitToken(node.colonToken), this.visitNodeOrToken(node.expression));
+        };
+
+        SyntaxRewriter.prototype.visitFunctionPropertyAssignment = function (node) {
+            return node.update(this.visitToken(node.propertyName), this.visitNode(node.callSignature), this.visitNode(node.block));
+        };
+
+        SyntaxRewriter.prototype.visitFunctionExpression = function (node) {
+            return node.update(this.visitToken(node.functionKeyword), node.identifier === null ? null : this.visitToken(node.identifier), this.visitNode(node.callSignature), this.visitNode(node.block));
+        };
+
+        SyntaxRewriter.prototype.visitEmptyStatement = function (node) {
+            return node.update(this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitTryStatement = function (node) {
+            return node.update(this.visitToken(node.tryKeyword), this.visitNode(node.block), node.catchClause === null ? null : this.visitNode(node.catchClause), node.finallyClause === null ? null : this.visitNode(node.finallyClause));
+        };
+
+        SyntaxRewriter.prototype.visitCatchClause = function (node) {
+            return node.update(this.visitToken(node.catchKeyword), this.visitToken(node.openParenToken), this.visitToken(node.identifier), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), this.visitToken(node.closeParenToken), this.visitNode(node.block));
+        };
+
+        SyntaxRewriter.prototype.visitFinallyClause = function (node) {
+            return node.update(this.visitToken(node.finallyKeyword), this.visitNode(node.block));
+        };
+
+        SyntaxRewriter.prototype.visitLabeledStatement = function (node) {
+            return node.update(this.visitToken(node.identifier), this.visitToken(node.colonToken), this.visitNodeOrToken(node.statement));
+        };
+
+        SyntaxRewriter.prototype.visitDoStatement = function (node) {
+            return node.update(this.visitToken(node.doKeyword), this.visitNodeOrToken(node.statement), this.visitToken(node.whileKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitTypeOfExpression = function (node) {
+            return node.update(this.visitToken(node.typeOfKeyword), this.visitNodeOrToken(node.expression));
+        };
+
+        SyntaxRewriter.prototype.visitDeleteExpression = function (node) {
+            return node.update(this.visitToken(node.deleteKeyword), this.visitNodeOrToken(node.expression));
+        };
+
+        SyntaxRewriter.prototype.visitVoidExpression = function (node) {
+            return node.update(this.visitToken(node.voidKeyword), this.visitNodeOrToken(node.expression));
+        };
+
+        SyntaxRewriter.prototype.visitDebuggerStatement = function (node) {
+            return node.update(this.visitToken(node.debuggerKeyword), this.visitToken(node.semicolonToken));
+        };
+        return SyntaxRewriter;
+    })();
+    TypeScript.SyntaxRewriter = SyntaxRewriter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxDedenter = (function (_super) {
+        __extends(SyntaxDedenter, _super);
+        function SyntaxDedenter(dedentFirstToken, dedentationAmount, minimumIndent, options) {
+            _super.call(this);
+            this.dedentationAmount = dedentationAmount;
+            this.minimumIndent = minimumIndent;
+            this.options = options;
+            this.lastTriviaWasNewLine = dedentFirstToken;
+        }
+        SyntaxDedenter.prototype.abort = function () {
+            this.lastTriviaWasNewLine = false;
+            this.dedentationAmount = 0;
+        };
+
+        SyntaxDedenter.prototype.isAborted = function () {
+            return this.dedentationAmount === 0;
+        };
+
+        SyntaxDedenter.prototype.visitToken = function (token) {
+            if (token.width() === 0) {
+                return token;
+            }
+
+            var result = token;
+            if (this.lastTriviaWasNewLine) {
+                result = token.withLeadingTrivia(this.dedentTriviaList(token.leadingTrivia()));
+            }
+
+            if (this.isAborted()) {
+                return token;
+            }
+
+            this.lastTriviaWasNewLine = token.hasTrailingNewLine();
+            return result;
+        };
+
+        SyntaxDedenter.prototype.dedentTriviaList = function (triviaList) {
+            var result = [];
+            var dedentNextWhitespace = true;
+
+            for (var i = 0, n = triviaList.count(); i < n && !this.isAborted(); i++) {
+                var trivia = triviaList.syntaxTriviaAt(i);
+
+                var dedentThisTrivia = dedentNextWhitespace;
+                dedentNextWhitespace = false;
+
+                if (dedentThisTrivia) {
+                    if (trivia.kind() === 4 /* WhitespaceTrivia */) {
+                        var hasFollowingNewLine = (i < triviaList.count() - 1) && triviaList.syntaxTriviaAt(i + 1).kind() === 5 /* NewLineTrivia */;
+                        result.push(this.dedentWhitespace(trivia, hasFollowingNewLine));
+                        continue;
+                    } else if (trivia.kind() !== 5 /* NewLineTrivia */) {
+                        this.abort();
+                        break;
+                    }
+                }
+
+                if (trivia.kind() === 6 /* MultiLineCommentTrivia */) {
+                    result.push(this.dedentMultiLineComment(trivia));
+                    continue;
+                }
+
+                result.push(trivia);
+                if (trivia.kind() === 5 /* NewLineTrivia */) {
+                    dedentNextWhitespace = true;
+                }
+            }
+
+            if (dedentNextWhitespace) {
+                this.abort();
+            }
+
+            if (this.isAborted()) {
+                return triviaList;
+            }
+
+            return TypeScript.Syntax.triviaList(result);
+        };
+
+        SyntaxDedenter.prototype.dedentSegment = function (segment, hasFollowingNewLineTrivia) {
+            var firstNonWhitespacePosition = TypeScript.Indentation.firstNonWhitespacePosition(segment);
+
+            if (firstNonWhitespacePosition === segment.length) {
+                if (hasFollowingNewLineTrivia) {
+                    return "";
+                }
+            } else if (TypeScript.CharacterInfo.isLineTerminator(segment.charCodeAt(firstNonWhitespacePosition))) {
+                return segment.substring(firstNonWhitespacePosition);
+            }
+
+            var firstNonWhitespaceColumn = TypeScript.Indentation.columnForPositionInString(segment, firstNonWhitespacePosition, this.options);
+
+            var newFirstNonWhitespaceColumn = TypeScript.MathPrototype.min(firstNonWhitespaceColumn, TypeScript.MathPrototype.max(firstNonWhitespaceColumn - this.dedentationAmount, this.minimumIndent));
+
+            if (newFirstNonWhitespaceColumn === firstNonWhitespaceColumn) {
+                this.abort();
+                return segment;
+            }
+
+            this.dedentationAmount = firstNonWhitespaceColumn - newFirstNonWhitespaceColumn;
+            TypeScript.Debug.assert(this.dedentationAmount >= 0);
+
+            var indentationString = TypeScript.Indentation.indentationString(newFirstNonWhitespaceColumn, this.options);
+
+            return indentationString + segment.substring(firstNonWhitespacePosition);
+        };
+
+        SyntaxDedenter.prototype.dedentWhitespace = function (trivia, hasFollowingNewLineTrivia) {
+            var newIndentation = this.dedentSegment(trivia.fullText(), hasFollowingNewLineTrivia);
+            return TypeScript.Syntax.whitespace(newIndentation);
+        };
+
+        SyntaxDedenter.prototype.dedentMultiLineComment = function (trivia) {
+            var segments = TypeScript.Syntax.splitMultiLineCommentTriviaIntoMultipleLines(trivia);
+            if (segments.length === 1) {
+                return trivia;
+            }
+
+            for (var i = 1; i < segments.length; i++) {
+                var segment = segments[i];
+                segments[i] = this.dedentSegment(segment, false);
+            }
+
+            var result = segments.join("");
+
+            return TypeScript.Syntax.multiLineComment(result);
+        };
+
+        SyntaxDedenter.dedentNode = function (node, dedentFirstToken, dedentAmount, minimumIndent, options) {
+            var dedenter = new SyntaxDedenter(dedentFirstToken, dedentAmount, minimumIndent, options);
+            var result = node.accept(dedenter);
+
+            if (dedenter.isAborted()) {
+                return node;
+            }
+
+            return result;
+        };
+        return SyntaxDedenter;
+    })(TypeScript.SyntaxRewriter);
+    TypeScript.SyntaxDedenter = SyntaxDedenter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxIndenter = (function (_super) {
+        __extends(SyntaxIndenter, _super);
+        function SyntaxIndenter(indentFirstToken, indentationAmount, options) {
+            _super.call(this);
+            this.indentationAmount = indentationAmount;
+            this.options = options;
+            this.lastTriviaWasNewLine = indentFirstToken;
+            this.indentationTrivia = TypeScript.Indentation.indentationTrivia(this.indentationAmount, this.options);
+        }
+        SyntaxIndenter.prototype.visitToken = function (token) {
+            if (token.width() === 0) {
+                return token;
+            }
+
+            var result = token;
+            if (this.lastTriviaWasNewLine) {
+                result = token.withLeadingTrivia(this.indentTriviaList(token.leadingTrivia()));
+            }
+
+            this.lastTriviaWasNewLine = token.hasTrailingNewLine();
+            return result;
+        };
+
+        SyntaxIndenter.prototype.indentTriviaList = function (triviaList) {
+            var result = [];
+
+            var indentNextTrivia = true;
+            for (var i = 0, n = triviaList.count(); i < n; i++) {
+                var trivia = triviaList.syntaxTriviaAt(i);
+
+                var indentThisTrivia = indentNextTrivia;
+                indentNextTrivia = false;
+
+                switch (trivia.kind()) {
+                    case 6 /* MultiLineCommentTrivia */:
+                        this.indentMultiLineComment(trivia, indentThisTrivia, result);
+                        continue;
+
+                    case 7 /* SingleLineCommentTrivia */:
+                    case 8 /* SkippedTokenTrivia */:
+                        this.indentSingleLineOrSkippedText(trivia, indentThisTrivia, result);
+                        continue;
+
+                    case 4 /* WhitespaceTrivia */:
+                        this.indentWhitespace(trivia, indentThisTrivia, result);
+                        continue;
+
+                    case 5 /* NewLineTrivia */:
+                        result.push(trivia);
+                        indentNextTrivia = true;
+                        continue;
+
+                    default:
+                        throw TypeScript.Errors.invalidOperation();
+                }
+            }
+
+            if (indentNextTrivia) {
+                result.push(this.indentationTrivia);
+            }
+
+            return TypeScript.Syntax.triviaList(result);
+        };
+
+        SyntaxIndenter.prototype.indentSegment = function (segment) {
+            var firstNonWhitespacePosition = TypeScript.Indentation.firstNonWhitespacePosition(segment);
+
+            if (firstNonWhitespacePosition < segment.length && TypeScript.CharacterInfo.isLineTerminator(segment.charCodeAt(firstNonWhitespacePosition))) {
+                return segment;
+            }
+
+            var firstNonWhitespaceColumn = TypeScript.Indentation.columnForPositionInString(segment, firstNonWhitespacePosition, this.options);
+
+            var newFirstNonWhitespaceColumn = firstNonWhitespaceColumn + this.indentationAmount;
+
+            var indentationString = TypeScript.Indentation.indentationString(newFirstNonWhitespaceColumn, this.options);
+
+            return indentationString + segment.substring(firstNonWhitespacePosition);
+        };
+
+        SyntaxIndenter.prototype.indentWhitespace = function (trivia, indentThisTrivia, result) {
+            if (!indentThisTrivia) {
+                result.push(trivia);
+                return;
+            }
+
+            var newIndentation = this.indentSegment(trivia.fullText());
+            result.push(TypeScript.Syntax.whitespace(newIndentation));
+        };
+
+        SyntaxIndenter.prototype.indentSingleLineOrSkippedText = function (trivia, indentThisTrivia, result) {
+            if (indentThisTrivia) {
+                result.push(this.indentationTrivia);
+            }
+
+            result.push(trivia);
+        };
+
+        SyntaxIndenter.prototype.indentMultiLineComment = function (trivia, indentThisTrivia, result) {
+            if (indentThisTrivia) {
+                result.push(this.indentationTrivia);
+            }
+
+            var segments = TypeScript.Syntax.splitMultiLineCommentTriviaIntoMultipleLines(trivia);
+
+            for (var i = 1; i < segments.length; i++) {
+                segments[i] = this.indentSegment(segments[i]);
+            }
+
+            var newText = segments.join("");
+            result.push(TypeScript.Syntax.multiLineComment(newText));
+        };
+
+        SyntaxIndenter.indentNode = function (node, indentFirstToken, indentAmount, options) {
+            var indenter = new SyntaxIndenter(indentFirstToken, indentAmount, options);
+            return node.accept(indenter);
+        };
+
+        SyntaxIndenter.indentNodes = function (nodes, indentFirstToken, indentAmount, options) {
+            var indenter = new SyntaxIndenter(indentFirstToken, indentAmount, options);
+            var result = TypeScript.ArrayUtilities.select(nodes, function (n) {
+                return n.accept(indenter);
+            });
+
+            return result;
+        };
+        return SyntaxIndenter;
+    })(TypeScript.SyntaxRewriter);
+    TypeScript.SyntaxIndenter = SyntaxIndenter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        var VariableWidthTokenWithNoTrivia = (function () {
+            function VariableWidthTokenWithNoTrivia(fullText, kind) {
+                this._fullText = fullText;
+                this.tokenKind = kind;
+            }
+            VariableWidthTokenWithNoTrivia.prototype.clone = function () {
+                return new VariableWidthTokenWithNoTrivia(this._fullText, this.tokenKind);
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.isNode = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.isToken = function () {
+                return true;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.isList = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.width = function () {
+                return this.fullWidth() - this.leadingTriviaWidth() - this.trailingTriviaWidth();
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.text = function () {
+                return this.fullText().substr(this.leadingTriviaWidth(), this.width());
+            };
+            VariableWidthTokenWithNoTrivia.prototype.fullText = function () {
+                return this._fullText;
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.value = function () {
+                if (this._value === undefined) {
+                    this._value = Syntax.value(this);
+                }
+
+                return this._value;
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.valueText = function () {
+                if (this._valueText === undefined) {
+                    this._valueText = Syntax.valueText(this);
+                }
+
+                return this._valueText;
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.hasLeadingTrivia = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.hasLeadingComment = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.hasLeadingNewLine = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.leadingTriviaWidth = function () {
+                return 0;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.leadingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.hasTrailingTrivia = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.hasTrailingComment = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.hasTrailingNewLine = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.trailingTriviaWidth = function () {
+                return 0;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.trailingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            VariableWidthTokenWithNoTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            VariableWidthTokenWithNoTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            VariableWidthTokenWithNoTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            VariableWidthTokenWithNoTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return VariableWidthTokenWithNoTrivia;
+        })();
+        Syntax.VariableWidthTokenWithNoTrivia = VariableWidthTokenWithNoTrivia;
+
+        var VariableWidthTokenWithLeadingTrivia = (function () {
+            function VariableWidthTokenWithLeadingTrivia(fullText, kind, leadingTriviaInfo) {
+                this._fullText = fullText;
+                this.tokenKind = kind;
+                this._leadingTriviaInfo = leadingTriviaInfo;
+            }
+            VariableWidthTokenWithLeadingTrivia.prototype.clone = function () {
+                return new VariableWidthTokenWithLeadingTrivia(this._fullText, this.tokenKind, this._leadingTriviaInfo);
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.isNode = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.isToken = function () {
+                return true;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.isList = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.width = function () {
+                return this.fullWidth() - this.leadingTriviaWidth() - this.trailingTriviaWidth();
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.text = function () {
+                return this.fullText().substr(this.leadingTriviaWidth(), this.width());
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.fullText = function () {
+                return this._fullText;
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.value = function () {
+                if (this._value === undefined) {
+                    this._value = Syntax.value(this);
+                }
+
+                return this._value;
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.valueText = function () {
+                if (this._valueText === undefined) {
+                    this._valueText = Syntax.valueText(this);
+                }
+
+                return this._valueText;
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingTrivia = function () {
+                return true;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingComment = function () {
+                return hasTriviaComment(this._leadingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingNewLine = function () {
+                return hasTriviaNewLine(this._leadingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.leadingTriviaWidth = function () {
+                return getTriviaWidth(this._leadingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.leadingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), 0, getTriviaWidth(this._leadingTriviaInfo), false);
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingTrivia = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingComment = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingNewLine = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.trailingTriviaWidth = function () {
+                return 0;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.trailingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return VariableWidthTokenWithLeadingTrivia;
+        })();
+        Syntax.VariableWidthTokenWithLeadingTrivia = VariableWidthTokenWithLeadingTrivia;
+
+        var VariableWidthTokenWithTrailingTrivia = (function () {
+            function VariableWidthTokenWithTrailingTrivia(fullText, kind, trailingTriviaInfo) {
+                this._fullText = fullText;
+                this.tokenKind = kind;
+                this._trailingTriviaInfo = trailingTriviaInfo;
+            }
+            VariableWidthTokenWithTrailingTrivia.prototype.clone = function () {
+                return new VariableWidthTokenWithTrailingTrivia(this._fullText, this.tokenKind, this._trailingTriviaInfo);
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.isNode = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.isToken = function () {
+                return true;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.isList = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.width = function () {
+                return this.fullWidth() - this.leadingTriviaWidth() - this.trailingTriviaWidth();
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.text = function () {
+                return this.fullText().substr(this.leadingTriviaWidth(), this.width());
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.fullText = function () {
+                return this._fullText;
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.value = function () {
+                if (this._value === undefined) {
+                    this._value = Syntax.value(this);
+                }
+
+                return this._value;
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.valueText = function () {
+                if (this._valueText === undefined) {
+                    this._valueText = Syntax.valueText(this);
+                }
+
+                return this._valueText;
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingTrivia = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingComment = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingNewLine = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.leadingTriviaWidth = function () {
+                return 0;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.leadingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingTrivia = function () {
+                return true;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingComment = function () {
+                return hasTriviaComment(this._trailingTriviaInfo);
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingNewLine = function () {
+                return hasTriviaNewLine(this._trailingTriviaInfo);
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.trailingTriviaWidth = function () {
+                return getTriviaWidth(this._trailingTriviaInfo);
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.trailingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), this.leadingTriviaWidth() + this.width(), getTriviaWidth(this._trailingTriviaInfo), true);
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return VariableWidthTokenWithTrailingTrivia;
+        })();
+        Syntax.VariableWidthTokenWithTrailingTrivia = VariableWidthTokenWithTrailingTrivia;
+
+        var VariableWidthTokenWithLeadingAndTrailingTrivia = (function () {
+            function VariableWidthTokenWithLeadingAndTrailingTrivia(fullText, kind, leadingTriviaInfo, trailingTriviaInfo) {
+                this._fullText = fullText;
+                this.tokenKind = kind;
+                this._leadingTriviaInfo = leadingTriviaInfo;
+                this._trailingTriviaInfo = trailingTriviaInfo;
+            }
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.clone = function () {
+                return new VariableWidthTokenWithLeadingAndTrailingTrivia(this._fullText, this.tokenKind, this._leadingTriviaInfo, this._trailingTriviaInfo);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isNode = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isToken = function () {
+                return true;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isList = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.width = function () {
+                return this.fullWidth() - this.leadingTriviaWidth() - this.trailingTriviaWidth();
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.text = function () {
+                return this.fullText().substr(this.leadingTriviaWidth(), this.width());
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.fullText = function () {
+                return this._fullText;
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.value = function () {
+                if (this._value === undefined) {
+                    this._value = Syntax.value(this);
+                }
+
+                return this._value;
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.valueText = function () {
+                if (this._valueText === undefined) {
+                    this._valueText = Syntax.valueText(this);
+                }
+
+                return this._valueText;
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingTrivia = function () {
+                return true;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingComment = function () {
+                return hasTriviaComment(this._leadingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingNewLine = function () {
+                return hasTriviaNewLine(this._leadingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTriviaWidth = function () {
+                return getTriviaWidth(this._leadingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), 0, getTriviaWidth(this._leadingTriviaInfo), false);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingTrivia = function () {
+                return true;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingComment = function () {
+                return hasTriviaComment(this._trailingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingNewLine = function () {
+                return hasTriviaNewLine(this._trailingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTriviaWidth = function () {
+                return getTriviaWidth(this._trailingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), this.leadingTriviaWidth() + this.width(), getTriviaWidth(this._trailingTriviaInfo), true);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return VariableWidthTokenWithLeadingAndTrailingTrivia;
+        })();
+        Syntax.VariableWidthTokenWithLeadingAndTrailingTrivia = VariableWidthTokenWithLeadingAndTrailingTrivia;
+
+        var FixedWidthTokenWithNoTrivia = (function () {
+            function FixedWidthTokenWithNoTrivia(kind) {
+                this.tokenKind = kind;
+            }
+            FixedWidthTokenWithNoTrivia.prototype.clone = function () {
+                return new FixedWidthTokenWithNoTrivia(this.tokenKind);
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.isNode = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.isToken = function () {
+                return true;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.isList = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.width = function () {
+                return this.text().length;
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.text = function () {
+                return TypeScript.SyntaxFacts.getText(this.tokenKind);
+            };
+            FixedWidthTokenWithNoTrivia.prototype.fullText = function () {
+                return this.text();
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.value = function () {
+                return Syntax.value(this);
+            };
+            FixedWidthTokenWithNoTrivia.prototype.valueText = function () {
+                return Syntax.valueText(this);
+            };
+            FixedWidthTokenWithNoTrivia.prototype.hasLeadingTrivia = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.hasLeadingComment = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.hasLeadingNewLine = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.leadingTriviaWidth = function () {
+                return 0;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.leadingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.hasTrailingTrivia = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.hasTrailingComment = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.hasTrailingNewLine = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.trailingTriviaWidth = function () {
+                return 0;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.trailingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            FixedWidthTokenWithNoTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            FixedWidthTokenWithNoTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            FixedWidthTokenWithNoTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            FixedWidthTokenWithNoTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return FixedWidthTokenWithNoTrivia;
+        })();
+        Syntax.FixedWidthTokenWithNoTrivia = FixedWidthTokenWithNoTrivia;
+
+        var FixedWidthTokenWithLeadingTrivia = (function () {
+            function FixedWidthTokenWithLeadingTrivia(fullText, kind, leadingTriviaInfo) {
+                this._fullText = fullText;
+                this.tokenKind = kind;
+                this._leadingTriviaInfo = leadingTriviaInfo;
+            }
+            FixedWidthTokenWithLeadingTrivia.prototype.clone = function () {
+                return new FixedWidthTokenWithLeadingTrivia(this._fullText, this.tokenKind, this._leadingTriviaInfo);
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.isNode = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.isToken = function () {
+                return true;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.isList = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.width = function () {
+                return this.text().length;
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.text = function () {
+                return TypeScript.SyntaxFacts.getText(this.tokenKind);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.fullText = function () {
+                return this._fullText;
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.value = function () {
+                return Syntax.value(this);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.valueText = function () {
+                return Syntax.valueText(this);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingTrivia = function () {
+                return true;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingComment = function () {
+                return hasTriviaComment(this._leadingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingNewLine = function () {
+                return hasTriviaNewLine(this._leadingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.leadingTriviaWidth = function () {
+                return getTriviaWidth(this._leadingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.leadingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), 0, getTriviaWidth(this._leadingTriviaInfo), false);
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingTrivia = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingComment = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingNewLine = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.trailingTriviaWidth = function () {
+                return 0;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.trailingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return FixedWidthTokenWithLeadingTrivia;
+        })();
+        Syntax.FixedWidthTokenWithLeadingTrivia = FixedWidthTokenWithLeadingTrivia;
+
+        var FixedWidthTokenWithTrailingTrivia = (function () {
+            function FixedWidthTokenWithTrailingTrivia(fullText, kind, trailingTriviaInfo) {
+                this._fullText = fullText;
+                this.tokenKind = kind;
+                this._trailingTriviaInfo = trailingTriviaInfo;
+            }
+            FixedWidthTokenWithTrailingTrivia.prototype.clone = function () {
+                return new FixedWidthTokenWithTrailingTrivia(this._fullText, this.tokenKind, this._trailingTriviaInfo);
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.isNode = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.isToken = function () {
+                return true;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.isList = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.width = function () {
+                return this.text().length;
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.text = function () {
+                return TypeScript.SyntaxFacts.getText(this.tokenKind);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.fullText = function () {
+                return this._fullText;
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.value = function () {
+                return Syntax.value(this);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.valueText = function () {
+                return Syntax.valueText(this);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingTrivia = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingComment = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingNewLine = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.leadingTriviaWidth = function () {
+                return 0;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.leadingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingTrivia = function () {
+                return true;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingComment = function () {
+                return hasTriviaComment(this._trailingTriviaInfo);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingNewLine = function () {
+                return hasTriviaNewLine(this._trailingTriviaInfo);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.trailingTriviaWidth = function () {
+                return getTriviaWidth(this._trailingTriviaInfo);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.trailingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), this.leadingTriviaWidth() + this.width(), getTriviaWidth(this._trailingTriviaInfo), true);
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return FixedWidthTokenWithTrailingTrivia;
+        })();
+        Syntax.FixedWidthTokenWithTrailingTrivia = FixedWidthTokenWithTrailingTrivia;
+
+        var FixedWidthTokenWithLeadingAndTrailingTrivia = (function () {
+            function FixedWidthTokenWithLeadingAndTrailingTrivia(fullText, kind, leadingTriviaInfo, trailingTriviaInfo) {
+                this._fullText = fullText;
+                this.tokenKind = kind;
+                this._leadingTriviaInfo = leadingTriviaInfo;
+                this._trailingTriviaInfo = trailingTriviaInfo;
+            }
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.clone = function () {
+                return new FixedWidthTokenWithLeadingAndTrailingTrivia(this._fullText, this.tokenKind, this._leadingTriviaInfo, this._trailingTriviaInfo);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isNode = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isToken = function () {
+                return true;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isList = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.width = function () {
+                return this.text().length;
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.text = function () {
+                return TypeScript.SyntaxFacts.getText(this.tokenKind);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.fullText = function () {
+                return this._fullText;
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.value = function () {
+                return Syntax.value(this);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.valueText = function () {
+                return Syntax.valueText(this);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingTrivia = function () {
+                return true;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingComment = function () {
+                return hasTriviaComment(this._leadingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingNewLine = function () {
+                return hasTriviaNewLine(this._leadingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTriviaWidth = function () {
+                return getTriviaWidth(this._leadingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), 0, getTriviaWidth(this._leadingTriviaInfo), false);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingTrivia = function () {
+                return true;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingComment = function () {
+                return hasTriviaComment(this._trailingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingNewLine = function () {
+                return hasTriviaNewLine(this._trailingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTriviaWidth = function () {
+                return getTriviaWidth(this._trailingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), this.leadingTriviaWidth() + this.width(), getTriviaWidth(this._trailingTriviaInfo), true);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return FixedWidthTokenWithLeadingAndTrailingTrivia;
+        })();
+        Syntax.FixedWidthTokenWithLeadingAndTrailingTrivia = FixedWidthTokenWithLeadingAndTrailingTrivia;
+
+        function collectTokenTextElements(token, elements) {
+            token.leadingTrivia().collectTextElements(elements);
+            elements.push(token.text());
+            token.trailingTrivia().collectTextElements(elements);
+        }
+
+        function getTriviaWidth(value) {
+            return value >>> 2 /* TriviaFullWidthShift */;
+        }
+
+        function hasTriviaComment(value) {
+            return (value & 2 /* TriviaCommentMask */) !== 0;
+        }
+
+        function hasTriviaNewLine(value) {
+            return (value & 1 /* TriviaNewLineMask */) !== 0;
+        }
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        function isExpression(token) {
+            switch (token.tokenKind) {
+                case 11 /* IdentifierName */:
+                case 12 /* RegularExpressionLiteral */:
+                case 13 /* NumericLiteral */:
+                case 14 /* StringLiteral */:
+                case 24 /* FalseKeyword */:
+                case 32 /* NullKeyword */:
+                case 35 /* ThisKeyword */:
+                case 37 /* TrueKeyword */:
+                case 50 /* SuperKeyword */:
+                    return true;
+            }
+
+            return false;
+        }
+        Syntax.isExpression = isExpression;
+
+        function realizeToken(token) {
+            return new RealizedToken(token.tokenKind, token.leadingTrivia(), token.text(), token.value(), token.valueText(), token.trailingTrivia());
+        }
+        Syntax.realizeToken = realizeToken;
+
+        function convertToIdentifierName(token) {
+            TypeScript.Debug.assert(TypeScript.SyntaxFacts.isAnyKeyword(token.tokenKind));
+            return new RealizedToken(11 /* IdentifierName */, token.leadingTrivia(), token.text(), token.text(), token.text(), token.trailingTrivia());
+        }
+        Syntax.convertToIdentifierName = convertToIdentifierName;
+
+        function tokenToJSON(token) {
+            var result = {};
+
+            for (var name in TypeScript.SyntaxKind) {
+                if (TypeScript.SyntaxKind[name] === token.kind()) {
+                    result.kind = name;
+                    break;
+                }
+            }
+
+            result.width = token.width();
+            if (token.fullWidth() !== token.width()) {
+                result.fullWidth = token.fullWidth();
+            }
+
+            result.text = token.text();
+
+            var value = token.value();
+            if (value !== null) {
+                result.value = value;
+                result.valueText = token.valueText();
+            }
+
+            if (token.hasLeadingTrivia()) {
+                result.hasLeadingTrivia = true;
+            }
+
+            if (token.hasLeadingComment()) {
+                result.hasLeadingComment = true;
+            }
+
+            if (token.hasLeadingNewLine()) {
+                result.hasLeadingNewLine = true;
+            }
+
+            if (token.hasLeadingSkippedText()) {
+                result.hasLeadingSkippedText = true;
+            }
+
+            if (token.hasTrailingTrivia()) {
+                result.hasTrailingTrivia = true;
+            }
+
+            if (token.hasTrailingComment()) {
+                result.hasTrailingComment = true;
+            }
+
+            if (token.hasTrailingNewLine()) {
+                result.hasTrailingNewLine = true;
+            }
+
+            if (token.hasTrailingSkippedText()) {
+                result.hasTrailingSkippedText = true;
+            }
+
+            var trivia = token.leadingTrivia();
+            if (trivia.count() > 0) {
+                result.leadingTrivia = trivia;
+            }
+
+            trivia = token.trailingTrivia();
+            if (trivia.count() > 0) {
+                result.trailingTrivia = trivia;
+            }
+
+            return result;
+        }
+        Syntax.tokenToJSON = tokenToJSON;
+
+        function value(token) {
+            return value1(token.tokenKind, token.text());
+        }
+        Syntax.value = value;
+
+        function hexValue(text, start, length) {
+            var intChar = 0;
+            for (var i = 0; i < length; i++) {
+                var ch2 = text.charCodeAt(start + i);
+                if (!TypeScript.CharacterInfo.isHexDigit(ch2)) {
+                    break;
+                }
+
+                intChar = (intChar << 4) + TypeScript.CharacterInfo.hexValue(ch2);
+            }
+
+            return intChar;
+        }
+
+        var characterArray = [];
+
+        function convertEscapes(text) {
+            characterArray.length = 0;
+            var result = "";
+
+            for (var i = 0, n = text.length; i < n; i++) {
+                var ch = text.charCodeAt(i);
+
+                if (ch === 92 /* backslash */) {
+                    i++;
+                    if (i < n) {
+                        ch = text.charCodeAt(i);
+                        switch (ch) {
+                            case 48 /* _0 */:
+                                characterArray.push(0 /* nullCharacter */);
+                                continue;
+
+                            case 98 /* b */:
+                                characterArray.push(8 /* backspace */);
+                                continue;
+
+                            case 102 /* f */:
+                                characterArray.push(12 /* formFeed */);
+                                continue;
+
+                            case 110 /* n */:
+                                characterArray.push(10 /* lineFeed */);
+                                continue;
+
+                            case 114 /* r */:
+                                characterArray.push(13 /* carriageReturn */);
+                                continue;
+
+                            case 116 /* t */:
+                                characterArray.push(9 /* tab */);
+                                continue;
+
+                            case 118 /* v */:
+                                characterArray.push(11 /* verticalTab */);
+                                continue;
+
+                            case 120 /* x */:
+                                characterArray.push(hexValue(text, i + 1, 2));
+                                i += 2;
+                                continue;
+
+                            case 117 /* u */:
+                                characterArray.push(hexValue(text, i + 1, 4));
+                                i += 4;
+                                continue;
+
+                            case 13 /* carriageReturn */:
+                                var nextIndex = i + 1;
+                                if (nextIndex < text.length && text.charCodeAt(nextIndex) === 10 /* lineFeed */) {
+                                    i++;
+                                }
+                                continue;
+
+                            case 10 /* lineFeed */:
+                            case 8233 /* paragraphSeparator */:
+                            case 8232 /* lineSeparator */:
+                                continue;
+
+                            default:
+                        }
+                    }
+                }
+
+                characterArray.push(ch);
+
+                if (i && !(i % 1024)) {
+                    result = result.concat(String.fromCharCode.apply(null, characterArray));
+                    characterArray.length = 0;
+                }
+            }
+
+            if (characterArray.length) {
+                result = result.concat(String.fromCharCode.apply(null, characterArray));
+            }
+
+            return result;
+        }
+
+        function massageEscapes(text) {
+            return text.indexOf("\\") >= 0 ? convertEscapes(text) : text;
+        }
+        Syntax.massageEscapes = massageEscapes;
+
+        function value1(kind, text) {
+            if (kind === 11 /* IdentifierName */) {
+                return massageEscapes(text);
+            }
+
+            switch (kind) {
+                case 37 /* TrueKeyword */:
+                    return true;
+                case 24 /* FalseKeyword */:
+                    return false;
+                case 32 /* NullKeyword */:
+                    return null;
+            }
+
+            if (TypeScript.SyntaxFacts.isAnyKeyword(kind) || TypeScript.SyntaxFacts.isAnyPunctuation(kind)) {
+                return TypeScript.SyntaxFacts.getText(kind);
+            }
+
+            if (kind === 13 /* NumericLiteral */) {
+                return TypeScript.IntegerUtilities.isHexInteger(text) ? parseInt(text, 16) : parseFloat(text);
+            } else if (kind === 14 /* StringLiteral */) {
+                if (text.length > 1 && text.charCodeAt(text.length - 1) === text.charCodeAt(0)) {
+                    return massageEscapes(text.substr(1, text.length - 2));
+                } else {
+                    return massageEscapes(text.substr(1));
+                }
+            } else if (kind === 12 /* RegularExpressionLiteral */) {
+                return regularExpressionValue(text);
+            } else if (kind === 10 /* EndOfFileToken */ || kind === 9 /* ErrorToken */) {
+                return null;
+            } else {
+                throw TypeScript.Errors.invalidOperation();
+            }
+        }
+
+        function regularExpressionValue(text) {
+            try  {
+                var lastSlash = text.lastIndexOf("/");
+                var body = text.substring(1, lastSlash);
+                var flags = text.substring(lastSlash + 1);
+                return new RegExp(body, flags);
+            } catch (e) {
+                return null;
+            }
+        }
+
+        function valueText1(kind, text) {
+            var value = value1(kind, text);
+            return value === null ? "" : value.toString();
+        }
+
+        function valueText(token) {
+            var value = token.value();
+            return value === null ? "" : value.toString();
+        }
+        Syntax.valueText = valueText;
+
+        var EmptyToken = (function () {
+            function EmptyToken(kind) {
+                this.tokenKind = kind;
+            }
+            EmptyToken.prototype.clone = function () {
+                return new EmptyToken(this.tokenKind);
+            };
+
+            EmptyToken.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            EmptyToken.prototype.isToken = function () {
+                return true;
+            };
+            EmptyToken.prototype.isNode = function () {
+                return false;
+            };
+            EmptyToken.prototype.isList = function () {
+                return false;
+            };
+            EmptyToken.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            EmptyToken.prototype.childCount = function () {
+                return 0;
+            };
+
+            EmptyToken.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            };
+
+            EmptyToken.prototype.toJSON = function (key) {
+                return tokenToJSON(this);
+            };
+            EmptyToken.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+
+            EmptyToken.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            EmptyToken.prototype.firstToken = function () {
+                return this;
+            };
+            EmptyToken.prototype.lastToken = function () {
+                return this;
+            };
+            EmptyToken.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+
+            EmptyToken.prototype.isIncrementallyUnusable = function () {
+                return true;
+            };
+
+            EmptyToken.prototype.fullWidth = function () {
+                return 0;
+            };
+            EmptyToken.prototype.width = function () {
+                return 0;
+            };
+            EmptyToken.prototype.text = function () {
+                return "";
+            };
+            EmptyToken.prototype.fullText = function () {
+                return "";
+            };
+            EmptyToken.prototype.value = function () {
+                return null;
+            };
+            EmptyToken.prototype.valueText = function () {
+                return "";
+            };
+
+            EmptyToken.prototype.hasLeadingTrivia = function () {
+                return false;
+            };
+            EmptyToken.prototype.hasLeadingComment = function () {
+                return false;
+            };
+            EmptyToken.prototype.hasLeadingNewLine = function () {
+                return false;
+            };
+            EmptyToken.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            EmptyToken.prototype.leadingTriviaWidth = function () {
+                return 0;
+            };
+            EmptyToken.prototype.hasTrailingTrivia = function () {
+                return false;
+            };
+            EmptyToken.prototype.hasTrailingComment = function () {
+                return false;
+            };
+            EmptyToken.prototype.hasTrailingNewLine = function () {
+                return false;
+            };
+            EmptyToken.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            EmptyToken.prototype.hasSkippedToken = function () {
+                return false;
+            };
+
+            EmptyToken.prototype.trailingTriviaWidth = function () {
+                return 0;
+            };
+            EmptyToken.prototype.leadingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+            EmptyToken.prototype.trailingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+            EmptyToken.prototype.realize = function () {
+                return realizeToken(this);
+            };
+            EmptyToken.prototype.collectTextElements = function (elements) {
+            };
+
+            EmptyToken.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            EmptyToken.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            EmptyToken.prototype.isExpression = function () {
+                return isExpression(this);
+            };
+
+            EmptyToken.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            EmptyToken.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            EmptyToken.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            EmptyToken.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return EmptyToken;
+        })();
+
+        function emptyToken(kind) {
+            return new EmptyToken(kind);
+        }
+        Syntax.emptyToken = emptyToken;
+
+        var RealizedToken = (function () {
+            function RealizedToken(tokenKind, leadingTrivia, text, value, valueText, trailingTrivia) {
+                this.tokenKind = tokenKind;
+                this._leadingTrivia = leadingTrivia;
+                this._text = text;
+                this._value = value;
+                this._valueText = valueText;
+                this._trailingTrivia = trailingTrivia;
+            }
+            RealizedToken.prototype.clone = function () {
+                return new RealizedToken(this.tokenKind, this._leadingTrivia, this._text, this._value, this._valueText, this._trailingTrivia);
+            };
+
+            RealizedToken.prototype.kind = function () {
+                return this.tokenKind;
+            };
+            RealizedToken.prototype.toJSON = function (key) {
+                return tokenToJSON(this);
+            };
+            RealizedToken.prototype.firstToken = function () {
+                return this;
+            };
+            RealizedToken.prototype.lastToken = function () {
+                return this;
+            };
+            RealizedToken.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+
+            RealizedToken.prototype.isIncrementallyUnusable = function () {
+                return true;
+            };
+
+            RealizedToken.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+
+            RealizedToken.prototype.childCount = function () {
+                return 0;
+            };
+
+            RealizedToken.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            };
+
+            RealizedToken.prototype.isToken = function () {
+                return true;
+            };
+            RealizedToken.prototype.isNode = function () {
+                return false;
+            };
+            RealizedToken.prototype.isList = function () {
+                return false;
+            };
+            RealizedToken.prototype.isSeparatedList = function () {
+                return false;
+            };
+            RealizedToken.prototype.isTrivia = function () {
+                return false;
+            };
+            RealizedToken.prototype.isTriviaList = function () {
+                return false;
+            };
+
+            RealizedToken.prototype.fullWidth = function () {
+                return this._leadingTrivia.fullWidth() + this.width() + this._trailingTrivia.fullWidth();
+            };
+            RealizedToken.prototype.width = function () {
+                return this.text().length;
+            };
+
+            RealizedToken.prototype.text = function () {
+                return this._text;
+            };
+            RealizedToken.prototype.fullText = function () {
+                return this._leadingTrivia.fullText() + this.text() + this._trailingTrivia.fullText();
+            };
+
+            RealizedToken.prototype.value = function () {
+                return this._value;
+            };
+            RealizedToken.prototype.valueText = function () {
+                return this._valueText;
+            };
+
+            RealizedToken.prototype.hasLeadingTrivia = function () {
+                return this._leadingTrivia.count() > 0;
+            };
+            RealizedToken.prototype.hasLeadingComment = function () {
+                return this._leadingTrivia.hasComment();
+            };
+            RealizedToken.prototype.hasLeadingNewLine = function () {
+                return this._leadingTrivia.hasNewLine();
+            };
+            RealizedToken.prototype.hasLeadingSkippedText = function () {
+                return this._leadingTrivia.hasSkippedToken();
+            };
+            RealizedToken.prototype.leadingTriviaWidth = function () {
+                return this._leadingTrivia.fullWidth();
+            };
+
+            RealizedToken.prototype.hasTrailingTrivia = function () {
+                return this._trailingTrivia.count() > 0;
+            };
+            RealizedToken.prototype.hasTrailingComment = function () {
+                return this._trailingTrivia.hasComment();
+            };
+            RealizedToken.prototype.hasTrailingNewLine = function () {
+                return this._trailingTrivia.hasNewLine();
+            };
+            RealizedToken.prototype.hasTrailingSkippedText = function () {
+                return this._trailingTrivia.hasSkippedToken();
+            };
+            RealizedToken.prototype.trailingTriviaWidth = function () {
+                return this._trailingTrivia.fullWidth();
+            };
+
+            RealizedToken.prototype.hasSkippedToken = function () {
+                return this.hasLeadingSkippedText() || this.hasTrailingSkippedText();
+            };
+
+            RealizedToken.prototype.leadingTrivia = function () {
+                return this._leadingTrivia;
+            };
+            RealizedToken.prototype.trailingTrivia = function () {
+                return this._trailingTrivia;
+            };
+
+            RealizedToken.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            RealizedToken.prototype.collectTextElements = function (elements) {
+                this.leadingTrivia().collectTextElements(elements);
+                elements.push(this.text());
+                this.trailingTrivia().collectTextElements(elements);
+            };
+
+            RealizedToken.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return new RealizedToken(this.tokenKind, leadingTrivia, this._text, this._value, this._valueText, this._trailingTrivia);
+            };
+
+            RealizedToken.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return new RealizedToken(this.tokenKind, this._leadingTrivia, this._text, this._value, this._valueText, trailingTrivia);
+            };
+
+            RealizedToken.prototype.isExpression = function () {
+                return isExpression(this);
+            };
+
+            RealizedToken.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            RealizedToken.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            RealizedToken.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            RealizedToken.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return RealizedToken;
+        })();
+
+        function token(kind, info) {
+            if (typeof info === "undefined") { info = null; }
+            var text = (info !== null && info.text !== undefined) ? info.text : TypeScript.SyntaxFacts.getText(kind);
+
+            return new RealizedToken(kind, Syntax.triviaList(info === null ? null : info.leadingTrivia), text, value1(kind, text), valueText1(kind, text), Syntax.triviaList(info === null ? null : info.trailingTrivia));
+        }
+        Syntax.token = token;
+
+        function identifier(text, info) {
+            if (typeof info === "undefined") { info = null; }
+            info = info || {};
+            info.text = text;
+            return token(11 /* IdentifierName */, info);
+        }
+        Syntax.identifier = identifier;
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxTokenReplacer = (function (_super) {
+        __extends(SyntaxTokenReplacer, _super);
+        function SyntaxTokenReplacer(token1, token2) {
+            _super.call(this);
+            this.token1 = token1;
+            this.token2 = token2;
+        }
+        SyntaxTokenReplacer.prototype.visitToken = function (token) {
+            if (token === this.token1) {
+                var result = this.token2;
+                this.token1 = null;
+                this.token2 = null;
+
+                return result;
+            }
+
+            return token;
+        };
+
+        SyntaxTokenReplacer.prototype.visitNode = function (node) {
+            if (this.token1 === null) {
+                return node;
+            }
+
+            return _super.prototype.visitNode.call(this, node);
+        };
+
+        SyntaxTokenReplacer.prototype.visitList = function (list) {
+            if (this.token1 === null) {
+                return list;
+            }
+
+            return _super.prototype.visitList.call(this, list);
+        };
+
+        SyntaxTokenReplacer.prototype.visitSeparatedList = function (list) {
+            if (this.token1 === null) {
+                return list;
+            }
+
+            return _super.prototype.visitSeparatedList.call(this, list);
+        };
+        return SyntaxTokenReplacer;
+    })(TypeScript.SyntaxRewriter);
+    TypeScript.SyntaxTokenReplacer = SyntaxTokenReplacer;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        var AbstractTrivia = (function () {
+            function AbstractTrivia(_kind) {
+                this._kind = _kind;
+            }
+            AbstractTrivia.prototype.fullWidth = function () {
+                throw TypeScript.Errors.abstract();
+            };
+
+            AbstractTrivia.prototype.fullText = function () {
+                throw TypeScript.Errors.abstract();
+            };
+
+            AbstractTrivia.prototype.skippedToken = function () {
+                throw TypeScript.Errors.abstract();
+            };
+
+            AbstractTrivia.prototype.toJSON = function (key) {
+                var result = {};
+
+                for (var name in TypeScript.SyntaxKind) {
+                    if (TypeScript.SyntaxKind[name] === this._kind) {
+                        result.kind = name;
+                        break;
+                    }
+                }
+
+                if (this.isSkippedToken()) {
+                    result.skippedToken = this.skippedToken();
+                } else {
+                    result.text = this.fullText();
+                }
+                return result;
+            };
+
+            AbstractTrivia.prototype.kind = function () {
+                return this._kind;
+            };
+
+            AbstractTrivia.prototype.isWhitespace = function () {
+                return this.kind() === 4 /* WhitespaceTrivia */;
+            };
+
+            AbstractTrivia.prototype.isComment = function () {
+                return this.kind() === 7 /* SingleLineCommentTrivia */ || this.kind() === 6 /* MultiLineCommentTrivia */;
+            };
+
+            AbstractTrivia.prototype.isNewLine = function () {
+                return this.kind() === 5 /* NewLineTrivia */;
+            };
+
+            AbstractTrivia.prototype.isSkippedToken = function () {
+                return this.kind() === 8 /* SkippedTokenTrivia */;
+            };
+
+            AbstractTrivia.prototype.collectTextElements = function (elements) {
+                elements.push(this.fullText());
+            };
+            return AbstractTrivia;
+        })();
+
+        var NormalTrivia = (function (_super) {
+            __extends(NormalTrivia, _super);
+            function NormalTrivia(kind, _text) {
+                _super.call(this, kind);
+                this._text = _text;
+            }
+            NormalTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+
+            NormalTrivia.prototype.fullText = function () {
+                return this._text;
+            };
+
+            NormalTrivia.prototype.skippedToken = function () {
+                throw TypeScript.Errors.invalidOperation();
+            };
+            return NormalTrivia;
+        })(AbstractTrivia);
+
+        var SkippedTokenTrivia = (function (_super) {
+            __extends(SkippedTokenTrivia, _super);
+            function SkippedTokenTrivia(_skippedToken) {
+                _super.call(this, 8 /* SkippedTokenTrivia */);
+                this._skippedToken = _skippedToken;
+            }
+            SkippedTokenTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+
+            SkippedTokenTrivia.prototype.fullText = function () {
+                return this.skippedToken().fullText();
+            };
+
+            SkippedTokenTrivia.prototype.skippedToken = function () {
+                return this._skippedToken;
+            };
+            return SkippedTokenTrivia;
+        })(AbstractTrivia);
+
+        var DeferredTrivia = (function (_super) {
+            __extends(DeferredTrivia, _super);
+            function DeferredTrivia(kind, _text, _fullStart, _fullWidth) {
+                _super.call(this, kind);
+                this._text = _text;
+                this._fullStart = _fullStart;
+                this._fullWidth = _fullWidth;
+                this._fullText = null;
+            }
+            DeferredTrivia.prototype.fullWidth = function () {
+                return this._fullWidth;
+            };
+
+            DeferredTrivia.prototype.fullText = function () {
+                if (!this._fullText) {
+                    this._fullText = this._text.substr(this._fullStart, this._fullWidth, false);
+                    this._text = null;
+                }
+
+                return this._fullText;
+            };
+
+            DeferredTrivia.prototype.skippedToken = function () {
+                throw TypeScript.Errors.invalidOperation();
+            };
+            return DeferredTrivia;
+        })(AbstractTrivia);
+
+        function deferredTrivia(kind, text, fullStart, fullWidth) {
+            return new DeferredTrivia(kind, text, fullStart, fullWidth);
+        }
+        Syntax.deferredTrivia = deferredTrivia;
+
+        function trivia(kind, text) {
+            return new NormalTrivia(kind, text);
+        }
+        Syntax.trivia = trivia;
+
+        function skippedTokenTrivia(token) {
+            TypeScript.Debug.assert(!token.hasLeadingTrivia());
+            TypeScript.Debug.assert(!token.hasTrailingTrivia());
+            TypeScript.Debug.assert(token.fullWidth() > 0);
+            return new SkippedTokenTrivia(token);
+        }
+        Syntax.skippedTokenTrivia = skippedTokenTrivia;
+
+        function spaces(count) {
+            return trivia(4 /* WhitespaceTrivia */, TypeScript.StringUtilities.repeat(" ", count));
+        }
+        Syntax.spaces = spaces;
+
+        function whitespace(text) {
+            return trivia(4 /* WhitespaceTrivia */, text);
+        }
+        Syntax.whitespace = whitespace;
+
+        function multiLineComment(text) {
+            return trivia(6 /* MultiLineCommentTrivia */, text);
+        }
+        Syntax.multiLineComment = multiLineComment;
+
+        function singleLineComment(text) {
+            return trivia(7 /* SingleLineCommentTrivia */, text);
+        }
+        Syntax.singleLineComment = singleLineComment;
+
+        Syntax.spaceTrivia = spaces(1);
+        Syntax.lineFeedTrivia = trivia(5 /* NewLineTrivia */, "\n");
+        Syntax.carriageReturnTrivia = trivia(5 /* NewLineTrivia */, "\r");
+        Syntax.carriageReturnLineFeedTrivia = trivia(5 /* NewLineTrivia */, "\r\n");
+
+        function splitMultiLineCommentTriviaIntoMultipleLines(trivia) {
+            var result = [];
+
+            var triviaText = trivia.fullText();
+            var currentIndex = 0;
+
+            for (var i = 0; i < triviaText.length; i++) {
+                var ch = triviaText.charCodeAt(i);
+
+                var isCarriageReturnLineFeed = false;
+                switch (ch) {
+                    case 13 /* carriageReturn */:
+                        if (i < triviaText.length - 1 && triviaText.charCodeAt(i + 1) === 10 /* lineFeed */) {
+                            i++;
+                        }
+
+                    case 10 /* lineFeed */:
+                    case 8233 /* paragraphSeparator */:
+                    case 8232 /* lineSeparator */:
+                        result.push(triviaText.substring(currentIndex, i + 1));
+
+                        currentIndex = i + 1;
+                        continue;
+                }
+            }
+
+            result.push(triviaText.substring(currentIndex));
+            return result;
+        }
+        Syntax.splitMultiLineCommentTriviaIntoMultipleLines = splitMultiLineCommentTriviaIntoMultipleLines;
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        Syntax.emptyTriviaList = {
+            kind: function () {
+                return 3 /* TriviaList */;
+            },
+            count: function () {
+                return 0;
+            },
+            syntaxTriviaAt: function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            },
+            last: function () {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            },
+            fullWidth: function () {
+                return 0;
+            },
+            fullText: function () {
+                return "";
+            },
+            hasComment: function () {
+                return false;
+            },
+            hasNewLine: function () {
+                return false;
+            },
+            hasSkippedToken: function () {
+                return false;
+            },
+            toJSON: function (key) {
+                return [];
+            },
+            collectTextElements: function (elements) {
+            },
+            toArray: function () {
+                return [];
+            },
+            concat: function (trivia) {
+                return trivia;
+            }
+        };
+
+        function concatTrivia(list1, list2) {
+            if (list1.count() === 0) {
+                return list2;
+            }
+
+            if (list2.count() === 0) {
+                return list1;
+            }
+
+            var trivia = list1.toArray();
+            trivia.push.apply(trivia, list2.toArray());
+
+            return triviaList(trivia);
+        }
+
+        function isComment(trivia) {
+            return trivia.kind() === 6 /* MultiLineCommentTrivia */ || trivia.kind() === 7 /* SingleLineCommentTrivia */;
+        }
+
+        var SingletonSyntaxTriviaList = (function () {
+            function SingletonSyntaxTriviaList(item) {
+                this.item = item;
+            }
+            SingletonSyntaxTriviaList.prototype.kind = function () {
+                return 3 /* TriviaList */;
+            };
+
+            SingletonSyntaxTriviaList.prototype.count = function () {
+                return 1;
+            };
+
+            SingletonSyntaxTriviaList.prototype.syntaxTriviaAt = function (index) {
+                if (index !== 0) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.item;
+            };
+
+            SingletonSyntaxTriviaList.prototype.last = function () {
+                return this.item;
+            };
+
+            SingletonSyntaxTriviaList.prototype.fullWidth = function () {
+                return this.item.fullWidth();
+            };
+
+            SingletonSyntaxTriviaList.prototype.fullText = function () {
+                return this.item.fullText();
+            };
+
+            SingletonSyntaxTriviaList.prototype.hasComment = function () {
+                return isComment(this.item);
+            };
+
+            SingletonSyntaxTriviaList.prototype.hasNewLine = function () {
+                return this.item.kind() === 5 /* NewLineTrivia */;
+            };
+
+            SingletonSyntaxTriviaList.prototype.hasSkippedToken = function () {
+                return this.item.kind() === 8 /* SkippedTokenTrivia */;
+            };
+
+            SingletonSyntaxTriviaList.prototype.toJSON = function (key) {
+                return [this.item];
+            };
+
+            SingletonSyntaxTriviaList.prototype.collectTextElements = function (elements) {
+                this.item.collectTextElements(elements);
+            };
+
+            SingletonSyntaxTriviaList.prototype.toArray = function () {
+                return [this.item];
+            };
+
+            SingletonSyntaxTriviaList.prototype.concat = function (trivia) {
+                return concatTrivia(this, trivia);
+            };
+            return SingletonSyntaxTriviaList;
+        })();
+
+        var NormalSyntaxTriviaList = (function () {
+            function NormalSyntaxTriviaList(trivia) {
+                this.trivia = trivia;
+            }
+            NormalSyntaxTriviaList.prototype.kind = function () {
+                return 3 /* TriviaList */;
+            };
+
+            NormalSyntaxTriviaList.prototype.count = function () {
+                return this.trivia.length;
+            };
+
+            NormalSyntaxTriviaList.prototype.syntaxTriviaAt = function (index) {
+                if (index < 0 || index >= this.trivia.length) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.trivia[index];
+            };
+
+            NormalSyntaxTriviaList.prototype.last = function () {
+                return this.trivia[this.trivia.length - 1];
+            };
+
+            NormalSyntaxTriviaList.prototype.fullWidth = function () {
+                return TypeScript.ArrayUtilities.sum(this.trivia, function (t) {
+                    return t.fullWidth();
+                });
+            };
+
+            NormalSyntaxTriviaList.prototype.fullText = function () {
+                var result = "";
+
+                for (var i = 0, n = this.trivia.length; i < n; i++) {
+                    result += this.trivia[i].fullText();
+                }
+
+                return result;
+            };
+
+            NormalSyntaxTriviaList.prototype.hasComment = function () {
+                for (var i = 0; i < this.trivia.length; i++) {
+                    if (isComment(this.trivia[i])) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            NormalSyntaxTriviaList.prototype.hasNewLine = function () {
+                for (var i = 0; i < this.trivia.length; i++) {
+                    if (this.trivia[i].kind() === 5 /* NewLineTrivia */) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            NormalSyntaxTriviaList.prototype.hasSkippedToken = function () {
+                for (var i = 0; i < this.trivia.length; i++) {
+                    if (this.trivia[i].kind() === 8 /* SkippedTokenTrivia */) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            NormalSyntaxTriviaList.prototype.toJSON = function (key) {
+                return this.trivia;
+            };
+
+            NormalSyntaxTriviaList.prototype.collectTextElements = function (elements) {
+                for (var i = 0; i < this.trivia.length; i++) {
+                    this.trivia[i].collectTextElements(elements);
+                }
+            };
+
+            NormalSyntaxTriviaList.prototype.toArray = function () {
+                return this.trivia.slice(0);
+            };
+
+            NormalSyntaxTriviaList.prototype.concat = function (trivia) {
+                return concatTrivia(this, trivia);
+            };
+            return NormalSyntaxTriviaList;
+        })();
+
+        function triviaList(trivia) {
+            if (trivia === undefined || trivia === null || trivia.length === 0) {
+                return Syntax.emptyTriviaList;
+            }
+
+            if (trivia.length === 1) {
+                return new SingletonSyntaxTriviaList(trivia[0]);
+            }
+
+            return new NormalSyntaxTriviaList(trivia);
+        }
+        Syntax.triviaList = triviaList;
+
+        Syntax.spaceTriviaList = triviaList([Syntax.spaceTrivia]);
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxUtilities = (function () {
+        function SyntaxUtilities() {
+        }
+        SyntaxUtilities.isAngleBracket = function (positionedElement) {
+            var element = positionedElement.element();
+            var parent = positionedElement.parentElement();
+            if (parent !== null && (element.kind() === 80 /* LessThanToken */ || element.kind() === 81 /* GreaterThanToken */)) {
+                switch (parent.kind()) {
+                    case 228 /* TypeArgumentList */:
+                    case 229 /* TypeParameterList */:
+                    case 220 /* CastExpression */:
+                        return true;
+                }
+            }
+
+            return false;
+        };
+
+        SyntaxUtilities.getToken = function (list, kind) {
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var token = list.childAt(i);
+                if (token.tokenKind === kind) {
+                    return token;
+                }
+            }
+
+            return null;
+        };
+
+        SyntaxUtilities.containsToken = function (list, kind) {
+            return SyntaxUtilities.getToken(list, kind) !== null;
+        };
+
+        SyntaxUtilities.hasExportKeyword = function (moduleElement) {
+            return SyntaxUtilities.getExportKeyword(moduleElement) !== null;
+        };
+
+        SyntaxUtilities.getExportKeyword = function (moduleElement) {
+            switch (moduleElement.kind()) {
+                case 130 /* ModuleDeclaration */:
+                case 131 /* ClassDeclaration */:
+                case 129 /* FunctionDeclaration */:
+                case 148 /* VariableStatement */:
+                case 132 /* EnumDeclaration */:
+                case 128 /* InterfaceDeclaration */:
+                case 133 /* ImportDeclaration */:
+                    return SyntaxUtilities.getToken(moduleElement.modifiers, 47 /* ExportKeyword */);
+                default:
+                    return null;
+            }
+        };
+
+        SyntaxUtilities.isAmbientDeclarationSyntax = function (positionNode) {
+            if (!positionNode) {
+                return false;
+            }
+
+            var node = positionNode.node();
+            switch (node.kind()) {
+                case 130 /* ModuleDeclaration */:
+                case 131 /* ClassDeclaration */:
+                case 129 /* FunctionDeclaration */:
+                case 148 /* VariableStatement */:
+                case 132 /* EnumDeclaration */:
+                    if (SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */)) {
+                        return true;
+                    }
+
+                case 133 /* ImportDeclaration */:
+                case 137 /* ConstructorDeclaration */:
+                case 135 /* MemberFunctionDeclaration */:
+                case 139 /* GetAccessor */:
+                case 140 /* SetAccessor */:
+                case 136 /* MemberVariableDeclaration */:
+                    if (node.isClassElement() || node.isModuleElement()) {
+                        return SyntaxUtilities.isAmbientDeclarationSyntax(positionNode.containingNode());
+                    }
+
+                case 243 /* EnumElement */:
+                    return SyntaxUtilities.isAmbientDeclarationSyntax(positionNode.containingNode().containingNode());
+
+                default:
+                    return SyntaxUtilities.isAmbientDeclarationSyntax(positionNode.containingNode());
+            }
+        };
+        return SyntaxUtilities;
+    })();
+    TypeScript.SyntaxUtilities = SyntaxUtilities;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxVisitor = (function () {
+        function SyntaxVisitor() {
+        }
+        SyntaxVisitor.prototype.defaultVisit = function (node) {
+            return null;
+        };
+
+        SyntaxVisitor.prototype.visitToken = function (token) {
+            return this.defaultVisit(token);
+        };
+
+        SyntaxVisitor.prototype.visitSourceUnit = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitExternalModuleReference = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitModuleNameModuleReference = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitImportDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitExportAssignment = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitClassDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitInterfaceDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitHeritageClause = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitModuleDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitFunctionDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitVariableStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitVariableDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitVariableDeclarator = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitEqualsValueClause = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitPrefixUnaryExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitArrayLiteralExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitOmittedExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitParenthesizedExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitSimpleArrowFunctionExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitParenthesizedArrowFunctionExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitQualifiedName = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitTypeArgumentList = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitConstructorType = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitFunctionType = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitObjectType = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitArrayType = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitGenericType = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitTypeQuery = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitTypeAnnotation = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitBlock = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitParameter = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitMemberAccessExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitPostfixUnaryExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitElementAccessExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitInvocationExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitArgumentList = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitBinaryExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitConditionalExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitConstructSignature = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitMethodSignature = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitIndexSignature = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitPropertySignature = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitCallSignature = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitParameterList = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitTypeParameterList = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitTypeParameter = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitConstraint = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitElseClause = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitIfStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitExpressionStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitConstructorDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitMemberFunctionDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitGetAccessor = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitSetAccessor = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitMemberVariableDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitIndexMemberDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitThrowStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitReturnStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitObjectCreationExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitSwitchStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitCaseSwitchClause = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitDefaultSwitchClause = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitBreakStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitContinueStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitForStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitForInStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitWhileStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitWithStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitEnumDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitEnumElement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitCastExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitObjectLiteralExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitSimplePropertyAssignment = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitFunctionPropertyAssignment = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitFunctionExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitEmptyStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitTryStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitCatchClause = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitFinallyClause = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitLabeledStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitDoStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitTypeOfExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitDeleteExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitVoidExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitDebuggerStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+        return SyntaxVisitor;
+    })();
+    TypeScript.SyntaxVisitor = SyntaxVisitor;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxWalker = (function () {
+        function SyntaxWalker() {
+        }
+        SyntaxWalker.prototype.visitToken = function (token) {
+        };
+
+        SyntaxWalker.prototype.visitNode = function (node) {
+            node.accept(this);
+        };
+
+        SyntaxWalker.prototype.visitNodeOrToken = function (nodeOrToken) {
+            if (nodeOrToken.isToken()) {
+                this.visitToken(nodeOrToken);
+            } else {
+                this.visitNode(nodeOrToken);
+            }
+        };
+
+        SyntaxWalker.prototype.visitOptionalToken = function (token) {
+            if (token === null) {
+                return;
+            }
+
+            this.visitToken(token);
+        };
+
+        SyntaxWalker.prototype.visitOptionalNode = function (node) {
+            if (node === null) {
+                return;
+            }
+
+            this.visitNode(node);
+        };
+
+        SyntaxWalker.prototype.visitOptionalNodeOrToken = function (nodeOrToken) {
+            if (nodeOrToken === null) {
+                return;
+            }
+
+            this.visitNodeOrToken(nodeOrToken);
+        };
+
+        SyntaxWalker.prototype.visitList = function (list) {
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                this.visitNodeOrToken(list.childAt(i));
+            }
+        };
+
+        SyntaxWalker.prototype.visitSeparatedList = function (list) {
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var item = list.childAt(i);
+                this.visitNodeOrToken(item);
+            }
+        };
+
+        SyntaxWalker.prototype.visitSourceUnit = function (node) {
+            this.visitList(node.moduleElements);
+            this.visitToken(node.endOfFileToken);
+        };
+
+        SyntaxWalker.prototype.visitExternalModuleReference = function (node) {
+            this.visitToken(node.requireKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitToken(node.stringLiteral);
+            this.visitToken(node.closeParenToken);
+        };
+
+        SyntaxWalker.prototype.visitModuleNameModuleReference = function (node) {
+            this.visitNodeOrToken(node.moduleName);
+        };
+
+        SyntaxWalker.prototype.visitImportDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.importKeyword);
+            this.visitToken(node.identifier);
+            this.visitToken(node.equalsToken);
+            this.visitNodeOrToken(node.moduleReference);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitExportAssignment = function (node) {
+            this.visitToken(node.exportKeyword);
+            this.visitToken(node.equalsToken);
+            this.visitToken(node.identifier);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitClassDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.classKeyword);
+            this.visitToken(node.identifier);
+            this.visitOptionalNode(node.typeParameterList);
+            this.visitList(node.heritageClauses);
+            this.visitToken(node.openBraceToken);
+            this.visitList(node.classElements);
+            this.visitToken(node.closeBraceToken);
+        };
+
+        SyntaxWalker.prototype.visitInterfaceDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.interfaceKeyword);
+            this.visitToken(node.identifier);
+            this.visitOptionalNode(node.typeParameterList);
+            this.visitList(node.heritageClauses);
+            this.visitNode(node.body);
+        };
+
+        SyntaxWalker.prototype.visitHeritageClause = function (node) {
+            this.visitToken(node.extendsOrImplementsKeyword);
+            this.visitSeparatedList(node.typeNames);
+        };
+
+        SyntaxWalker.prototype.visitModuleDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.moduleKeyword);
+            this.visitOptionalNodeOrToken(node.name);
+            this.visitOptionalToken(node.stringLiteral);
+            this.visitToken(node.openBraceToken);
+            this.visitList(node.moduleElements);
+            this.visitToken(node.closeBraceToken);
+        };
+
+        SyntaxWalker.prototype.visitFunctionDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.functionKeyword);
+            this.visitToken(node.identifier);
+            this.visitNode(node.callSignature);
+            this.visitOptionalNode(node.block);
+            this.visitOptionalToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitVariableStatement = function (node) {
+            this.visitList(node.modifiers);
+            this.visitNode(node.variableDeclaration);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitVariableDeclaration = function (node) {
+            this.visitToken(node.varKeyword);
+            this.visitSeparatedList(node.variableDeclarators);
+        };
+
+        SyntaxWalker.prototype.visitVariableDeclarator = function (node) {
+            this.visitToken(node.propertyName);
+            this.visitOptionalNode(node.typeAnnotation);
+            this.visitOptionalNode(node.equalsValueClause);
+        };
+
+        SyntaxWalker.prototype.visitEqualsValueClause = function (node) {
+            this.visitToken(node.equalsToken);
+            this.visitNodeOrToken(node.value);
+        };
+
+        SyntaxWalker.prototype.visitPrefixUnaryExpression = function (node) {
+            this.visitToken(node.operatorToken);
+            this.visitNodeOrToken(node.operand);
+        };
+
+        SyntaxWalker.prototype.visitArrayLiteralExpression = function (node) {
+            this.visitToken(node.openBracketToken);
+            this.visitSeparatedList(node.expressions);
+            this.visitToken(node.closeBracketToken);
+        };
+
+        SyntaxWalker.prototype.visitOmittedExpression = function (node) {
+        };
+
+        SyntaxWalker.prototype.visitParenthesizedExpression = function (node) {
+            this.visitToken(node.openParenToken);
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.closeParenToken);
+        };
+
+        SyntaxWalker.prototype.visitSimpleArrowFunctionExpression = function (node) {
+            this.visitToken(node.identifier);
+            this.visitToken(node.equalsGreaterThanToken);
+            this.visitOptionalNode(node.block);
+            this.visitOptionalNodeOrToken(node.expression);
+        };
+
+        SyntaxWalker.prototype.visitParenthesizedArrowFunctionExpression = function (node) {
+            this.visitNode(node.callSignature);
+            this.visitToken(node.equalsGreaterThanToken);
+            this.visitOptionalNode(node.block);
+            this.visitOptionalNodeOrToken(node.expression);
+        };
+
+        SyntaxWalker.prototype.visitQualifiedName = function (node) {
+            this.visitNodeOrToken(node.left);
+            this.visitToken(node.dotToken);
+            this.visitToken(node.right);
+        };
+
+        SyntaxWalker.prototype.visitTypeArgumentList = function (node) {
+            this.visitToken(node.lessThanToken);
+            this.visitSeparatedList(node.typeArguments);
+            this.visitToken(node.greaterThanToken);
+        };
+
+        SyntaxWalker.prototype.visitConstructorType = function (node) {
+            this.visitToken(node.newKeyword);
+            this.visitOptionalNode(node.typeParameterList);
+            this.visitNode(node.parameterList);
+            this.visitToken(node.equalsGreaterThanToken);
+            this.visitNodeOrToken(node.type);
+        };
+
+        SyntaxWalker.prototype.visitFunctionType = function (node) {
+            this.visitOptionalNode(node.typeParameterList);
+            this.visitNode(node.parameterList);
+            this.visitToken(node.equalsGreaterThanToken);
+            this.visitNodeOrToken(node.type);
+        };
+
+        SyntaxWalker.prototype.visitObjectType = function (node) {
+            this.visitToken(node.openBraceToken);
+            this.visitSeparatedList(node.typeMembers);
+            this.visitToken(node.closeBraceToken);
+        };
+
+        SyntaxWalker.prototype.visitArrayType = function (node) {
+            this.visitNodeOrToken(node.type);
+            this.visitToken(node.openBracketToken);
+            this.visitToken(node.closeBracketToken);
+        };
+
+        SyntaxWalker.prototype.visitGenericType = function (node) {
+            this.visitNodeOrToken(node.name);
+            this.visitNode(node.typeArgumentList);
+        };
+
+        SyntaxWalker.prototype.visitTypeQuery = function (node) {
+            this.visitToken(node.typeOfKeyword);
+            this.visitNodeOrToken(node.name);
+        };
+
+        SyntaxWalker.prototype.visitTypeAnnotation = function (node) {
+            this.visitToken(node.colonToken);
+            this.visitNodeOrToken(node.type);
+        };
+
+        SyntaxWalker.prototype.visitBlock = function (node) {
+            this.visitToken(node.openBraceToken);
+            this.visitList(node.statements);
+            this.visitToken(node.closeBraceToken);
+        };
+
+        SyntaxWalker.prototype.visitParameter = function (node) {
+            this.visitOptionalToken(node.dotDotDotToken);
+            this.visitList(node.modifiers);
+            this.visitToken(node.identifier);
+            this.visitOptionalToken(node.questionToken);
+            this.visitOptionalNode(node.typeAnnotation);
+            this.visitOptionalNode(node.equalsValueClause);
+        };
+
+        SyntaxWalker.prototype.visitMemberAccessExpression = function (node) {
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.dotToken);
+            this.visitToken(node.name);
+        };
+
+        SyntaxWalker.prototype.visitPostfixUnaryExpression = function (node) {
+            this.visitNodeOrToken(node.operand);
+            this.visitToken(node.operatorToken);
+        };
+
+        SyntaxWalker.prototype.visitElementAccessExpression = function (node) {
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.openBracketToken);
+            this.visitNodeOrToken(node.argumentExpression);
+            this.visitToken(node.closeBracketToken);
+        };
+
+        SyntaxWalker.prototype.visitInvocationExpression = function (node) {
+            this.visitNodeOrToken(node.expression);
+            this.visitNode(node.argumentList);
+        };
+
+        SyntaxWalker.prototype.visitArgumentList = function (node) {
+            this.visitOptionalNode(node.typeArgumentList);
+            this.visitToken(node.openParenToken);
+            this.visitSeparatedList(node.arguments);
+            this.visitToken(node.closeParenToken);
+        };
+
+        SyntaxWalker.prototype.visitBinaryExpression = function (node) {
+            this.visitNodeOrToken(node.left);
+            this.visitToken(node.operatorToken);
+            this.visitNodeOrToken(node.right);
+        };
+
+        SyntaxWalker.prototype.visitConditionalExpression = function (node) {
+            this.visitNodeOrToken(node.condition);
+            this.visitToken(node.questionToken);
+            this.visitNodeOrToken(node.whenTrue);
+            this.visitToken(node.colonToken);
+            this.visitNodeOrToken(node.whenFalse);
+        };
+
+        SyntaxWalker.prototype.visitConstructSignature = function (node) {
+            this.visitToken(node.newKeyword);
+            this.visitNode(node.callSignature);
+        };
+
+        SyntaxWalker.prototype.visitMethodSignature = function (node) {
+            this.visitToken(node.propertyName);
+            this.visitOptionalToken(node.questionToken);
+            this.visitNode(node.callSignature);
+        };
+
+        SyntaxWalker.prototype.visitIndexSignature = function (node) {
+            this.visitToken(node.openBracketToken);
+            this.visitNode(node.parameter);
+            this.visitToken(node.closeBracketToken);
+            this.visitOptionalNode(node.typeAnnotation);
+        };
+
+        SyntaxWalker.prototype.visitPropertySignature = function (node) {
+            this.visitToken(node.propertyName);
+            this.visitOptionalToken(node.questionToken);
+            this.visitOptionalNode(node.typeAnnotation);
+        };
+
+        SyntaxWalker.prototype.visitCallSignature = function (node) {
+            this.visitOptionalNode(node.typeParameterList);
+            this.visitNode(node.parameterList);
+            this.visitOptionalNode(node.typeAnnotation);
+        };
+
+        SyntaxWalker.prototype.visitParameterList = function (node) {
+            this.visitToken(node.openParenToken);
+            this.visitSeparatedList(node.parameters);
+            this.visitToken(node.closeParenToken);
+        };
+
+        SyntaxWalker.prototype.visitTypeParameterList = function (node) {
+            this.visitToken(node.lessThanToken);
+            this.visitSeparatedList(node.typeParameters);
+            this.visitToken(node.greaterThanToken);
+        };
+
+        SyntaxWalker.prototype.visitTypeParameter = function (node) {
+            this.visitToken(node.identifier);
+            this.visitOptionalNode(node.constraint);
+        };
+
+        SyntaxWalker.prototype.visitConstraint = function (node) {
+            this.visitToken(node.extendsKeyword);
+            this.visitNodeOrToken(node.type);
+        };
+
+        SyntaxWalker.prototype.visitElseClause = function (node) {
+            this.visitToken(node.elseKeyword);
+            this.visitNodeOrToken(node.statement);
+        };
+
+        SyntaxWalker.prototype.visitIfStatement = function (node) {
+            this.visitToken(node.ifKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitNodeOrToken(node.condition);
+            this.visitToken(node.closeParenToken);
+            this.visitNodeOrToken(node.statement);
+            this.visitOptionalNode(node.elseClause);
+        };
+
+        SyntaxWalker.prototype.visitExpressionStatement = function (node) {
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitConstructorDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.constructorKeyword);
+            this.visitNode(node.callSignature);
+            this.visitOptionalNode(node.block);
+            this.visitOptionalToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitMemberFunctionDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.propertyName);
+            this.visitNode(node.callSignature);
+            this.visitOptionalNode(node.block);
+            this.visitOptionalToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitGetAccessor = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.getKeyword);
+            this.visitToken(node.propertyName);
+            this.visitNode(node.parameterList);
+            this.visitOptionalNode(node.typeAnnotation);
+            this.visitNode(node.block);
+        };
+
+        SyntaxWalker.prototype.visitSetAccessor = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.setKeyword);
+            this.visitToken(node.propertyName);
+            this.visitNode(node.parameterList);
+            this.visitNode(node.block);
+        };
+
+        SyntaxWalker.prototype.visitMemberVariableDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitNode(node.variableDeclarator);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitIndexMemberDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitNode(node.indexSignature);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitThrowStatement = function (node) {
+            this.visitToken(node.throwKeyword);
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitReturnStatement = function (node) {
+            this.visitToken(node.returnKeyword);
+            this.visitOptionalNodeOrToken(node.expression);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitObjectCreationExpression = function (node) {
+            this.visitToken(node.newKeyword);
+            this.visitNodeOrToken(node.expression);
+            this.visitOptionalNode(node.argumentList);
+        };
+
+        SyntaxWalker.prototype.visitSwitchStatement = function (node) {
+            this.visitToken(node.switchKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.closeParenToken);
+            this.visitToken(node.openBraceToken);
+            this.visitList(node.switchClauses);
+            this.visitToken(node.closeBraceToken);
+        };
+
+        SyntaxWalker.prototype.visitCaseSwitchClause = function (node) {
+            this.visitToken(node.caseKeyword);
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.colonToken);
+            this.visitList(node.statements);
+        };
+
+        SyntaxWalker.prototype.visitDefaultSwitchClause = function (node) {
+            this.visitToken(node.defaultKeyword);
+            this.visitToken(node.colonToken);
+            this.visitList(node.statements);
+        };
+
+        SyntaxWalker.prototype.visitBreakStatement = function (node) {
+            this.visitToken(node.breakKeyword);
+            this.visitOptionalToken(node.identifier);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitContinueStatement = function (node) {
+            this.visitToken(node.continueKeyword);
+            this.visitOptionalToken(node.identifier);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitForStatement = function (node) {
+            this.visitToken(node.forKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitOptionalNode(node.variableDeclaration);
+            this.visitOptionalNodeOrToken(node.initializer);
+            this.visitToken(node.firstSemicolonToken);
+            this.visitOptionalNodeOrToken(node.condition);
+            this.visitToken(node.secondSemicolonToken);
+            this.visitOptionalNodeOrToken(node.incrementor);
+            this.visitToken(node.closeParenToken);
+            this.visitNodeOrToken(node.statement);
+        };
+
+        SyntaxWalker.prototype.visitForInStatement = function (node) {
+            this.visitToken(node.forKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitOptionalNode(node.variableDeclaration);
+            this.visitOptionalNodeOrToken(node.left);
+            this.visitToken(node.inKeyword);
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.closeParenToken);
+            this.visitNodeOrToken(node.statement);
+        };
+
+        SyntaxWalker.prototype.visitWhileStatement = function (node) {
+            this.visitToken(node.whileKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitNodeOrToken(node.condition);
+            this.visitToken(node.closeParenToken);
+            this.visitNodeOrToken(node.statement);
+        };
+
+        SyntaxWalker.prototype.visitWithStatement = function (node) {
+            this.visitToken(node.withKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitNodeOrToken(node.condition);
+            this.visitToken(node.closeParenToken);
+            this.visitNodeOrToken(node.statement);
+        };
+
+        SyntaxWalker.prototype.visitEnumDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.enumKeyword);
+            this.visitToken(node.identifier);
+            this.visitToken(node.openBraceToken);
+            this.visitSeparatedList(node.enumElements);
+            this.visitToken(node.closeBraceToken);
+        };
+
+        SyntaxWalker.prototype.visitEnumElement = function (node) {
+            this.visitToken(node.propertyName);
+            this.visitOptionalNode(node.equalsValueClause);
+        };
+
+        SyntaxWalker.prototype.visitCastExpression = function (node) {
+            this.visitToken(node.lessThanToken);
+            this.visitNodeOrToken(node.type);
+            this.visitToken(node.greaterThanToken);
+            this.visitNodeOrToken(node.expression);
+        };
+
+        SyntaxWalker.prototype.visitObjectLiteralExpression = function (node) {
+            this.visitToken(node.openBraceToken);
+            this.visitSeparatedList(node.propertyAssignments);
+            this.visitToken(node.closeBraceToken);
+        };
+
+        SyntaxWalker.prototype.visitSimplePropertyAssignment = function (node) {
+            this.visitToken(node.propertyName);
+            this.visitToken(node.colonToken);
+            this.visitNodeOrToken(node.expression);
+        };
+
+        SyntaxWalker.prototype.visitFunctionPropertyAssignment = function (node) {
+            this.visitToken(node.propertyName);
+            this.visitNode(node.callSignature);
+            this.visitNode(node.block);
+        };
+
+        SyntaxWalker.prototype.visitFunctionExpression = function (node) {
+            this.visitToken(node.functionKeyword);
+            this.visitOptionalToken(node.identifier);
+            this.visitNode(node.callSignature);
+            this.visitNode(node.block);
+        };
+
+        SyntaxWalker.prototype.visitEmptyStatement = function (node) {
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitTryStatement = function (node) {
+            this.visitToken(node.tryKeyword);
+            this.visitNode(node.block);
+            this.visitOptionalNode(node.catchClause);
+            this.visitOptionalNode(node.finallyClause);
+        };
+
+        SyntaxWalker.prototype.visitCatchClause = function (node) {
+            this.visitToken(node.catchKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitToken(node.identifier);
+            this.visitOptionalNode(node.typeAnnotation);
+            this.visitToken(node.closeParenToken);
+            this.visitNode(node.block);
+        };
+
+        SyntaxWalker.prototype.visitFinallyClause = function (node) {
+            this.visitToken(node.finallyKeyword);
+            this.visitNode(node.block);
+        };
+
+        SyntaxWalker.prototype.visitLabeledStatement = function (node) {
+            this.visitToken(node.identifier);
+            this.visitToken(node.colonToken);
+            this.visitNodeOrToken(node.statement);
+        };
+
+        SyntaxWalker.prototype.visitDoStatement = function (node) {
+            this.visitToken(node.doKeyword);
+            this.visitNodeOrToken(node.statement);
+            this.visitToken(node.whileKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitNodeOrToken(node.condition);
+            this.visitToken(node.closeParenToken);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitTypeOfExpression = function (node) {
+            this.visitToken(node.typeOfKeyword);
+            this.visitNodeOrToken(node.expression);
+        };
+
+        SyntaxWalker.prototype.visitDeleteExpression = function (node) {
+            this.visitToken(node.deleteKeyword);
+            this.visitNodeOrToken(node.expression);
+        };
+
+        SyntaxWalker.prototype.visitVoidExpression = function (node) {
+            this.visitToken(node.voidKeyword);
+            this.visitNodeOrToken(node.expression);
+        };
+
+        SyntaxWalker.prototype.visitDebuggerStatement = function (node) {
+            this.visitToken(node.debuggerKeyword);
+            this.visitToken(node.semicolonToken);
+        };
+        return SyntaxWalker;
+    })();
+    TypeScript.SyntaxWalker = SyntaxWalker;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var PositionTrackingWalker = (function (_super) {
+        __extends(PositionTrackingWalker, _super);
+        function PositionTrackingWalker() {
+            _super.apply(this, arguments);
+            this._position = 0;
+        }
+        PositionTrackingWalker.prototype.visitToken = function (token) {
+            this._position += token.fullWidth();
+        };
+
+        PositionTrackingWalker.prototype.position = function () {
+            return this._position;
+        };
+
+        PositionTrackingWalker.prototype.skip = function (element) {
+            this._position += element.fullWidth();
+        };
+        return PositionTrackingWalker;
+    })(TypeScript.SyntaxWalker);
+    TypeScript.PositionTrackingWalker = PositionTrackingWalker;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxInformationMap = (function (_super) {
+        __extends(SyntaxInformationMap, _super);
+        function SyntaxInformationMap(trackParents, trackPreviousToken) {
+            _super.call(this);
+            this.trackParents = trackParents;
+            this.trackPreviousToken = trackPreviousToken;
+            this.tokenToInformation = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode);
+            this.elementToPosition = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode);
+            this._previousToken = null;
+            this._previousTokenInformation = null;
+            this._currentPosition = 0;
+            this._elementToParent = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode);
+            this._parentStack = [];
+            this._parentStack.push(null);
+        }
+        SyntaxInformationMap.create = function (node, trackParents, trackPreviousToken) {
+            var map = new SyntaxInformationMap(trackParents, trackPreviousToken);
+            map.visitNode(node);
+            return map;
+        };
+
+        SyntaxInformationMap.prototype.visitNode = function (node) {
+            this.trackParents && this._elementToParent.add(node, TypeScript.ArrayUtilities.last(this._parentStack));
+            this.elementToPosition.add(node, this._currentPosition);
+
+            this.trackParents && this._parentStack.push(node);
+            _super.prototype.visitNode.call(this, node);
+            this.trackParents && this._parentStack.pop();
+        };
+
+        SyntaxInformationMap.prototype.visitToken = function (token) {
+            this.trackParents && this._elementToParent.add(token, TypeScript.ArrayUtilities.last(this._parentStack));
+
+            if (this.trackPreviousToken) {
+                var tokenInformation = {
+                    previousToken: this._previousToken,
+                    nextToken: null
+                };
+
+                if (this._previousTokenInformation !== null) {
+                    this._previousTokenInformation.nextToken = token;
+                }
+
+                this._previousToken = token;
+                this._previousTokenInformation = tokenInformation;
+
+                this.tokenToInformation.add(token, tokenInformation);
+            }
+
+            this.elementToPosition.add(token, this._currentPosition);
+            this._currentPosition += token.fullWidth();
+        };
+
+        SyntaxInformationMap.prototype.parent = function (element) {
+            return this._elementToParent.get(element);
+        };
+
+        SyntaxInformationMap.prototype.fullStart = function (element) {
+            return this.elementToPosition.get(element);
+        };
+
+        SyntaxInformationMap.prototype.start = function (element) {
+            return this.fullStart(element) + element.leadingTriviaWidth();
+        };
+
+        SyntaxInformationMap.prototype.end = function (element) {
+            return this.start(element) + element.width();
+        };
+
+        SyntaxInformationMap.prototype.previousToken = function (token) {
+            return this.tokenInformation(token).previousToken;
+        };
+
+        SyntaxInformationMap.prototype.tokenInformation = function (token) {
+            return this.tokenToInformation.get(token);
+        };
+
+        SyntaxInformationMap.prototype.firstTokenInLineContainingToken = function (token) {
+            var current = token;
+            while (true) {
+                var information = this.tokenInformation(current);
+                if (this.isFirstTokenInLineWorker(information)) {
+                    break;
+                }
+
+                current = information.previousToken;
+            }
+
+            return current;
+        };
+
+        SyntaxInformationMap.prototype.isFirstTokenInLine = function (token) {
+            var information = this.tokenInformation(token);
+            return this.isFirstTokenInLineWorker(information);
+        };
+
+        SyntaxInformationMap.prototype.isFirstTokenInLineWorker = function (information) {
+            return information.previousToken === null || information.previousToken.hasTrailingNewLine();
+        };
+        return SyntaxInformationMap;
+    })(TypeScript.SyntaxWalker);
+    TypeScript.SyntaxInformationMap = SyntaxInformationMap;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxNodeInvariantsChecker = (function (_super) {
+        __extends(SyntaxNodeInvariantsChecker, _super);
+        function SyntaxNodeInvariantsChecker() {
+            _super.apply(this, arguments);
+            this.tokenTable = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode);
+        }
+        SyntaxNodeInvariantsChecker.checkInvariants = function (node) {
+            node.accept(new SyntaxNodeInvariantsChecker());
+        };
+
+        SyntaxNodeInvariantsChecker.prototype.visitToken = function (token) {
+            this.tokenTable.add(token, token);
+        };
+        return SyntaxNodeInvariantsChecker;
+    })(TypeScript.SyntaxWalker);
+    TypeScript.SyntaxNodeInvariantsChecker = SyntaxNodeInvariantsChecker;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var DepthLimitedWalker = (function (_super) {
+        __extends(DepthLimitedWalker, _super);
+        function DepthLimitedWalker(maximumDepth) {
+            _super.call(this);
+            this._depth = 0;
+            this._maximumDepth = 0;
+            this._maximumDepth = maximumDepth;
+        }
+        DepthLimitedWalker.prototype.visitNode = function (node) {
+            if (this._depth < this._maximumDepth) {
+                this._depth++;
+                _super.prototype.visitNode.call(this, node);
+                this._depth--;
+            } else {
+                this.skip(node);
+            }
+        };
+        return DepthLimitedWalker;
+    })(TypeScript.PositionTrackingWalker);
+    TypeScript.DepthLimitedWalker = DepthLimitedWalker;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (Parser) {
+        
+
+        var ExpressionPrecedence;
+        (function (ExpressionPrecedence) {
+            ExpressionPrecedence[ExpressionPrecedence["CommaExpressionPrecedence"] = 1] = "CommaExpressionPrecedence";
+
+            ExpressionPrecedence[ExpressionPrecedence["AssignmentExpressionPrecedence"] = 2] = "AssignmentExpressionPrecedence";
+
+            ExpressionPrecedence[ExpressionPrecedence["ConditionalExpressionPrecedence"] = 3] = "ConditionalExpressionPrecedence";
+
+            ExpressionPrecedence[ExpressionPrecedence["ArrowFunctionPrecedence"] = 4] = "ArrowFunctionPrecedence";
+
+            ExpressionPrecedence[ExpressionPrecedence["LogicalOrExpressionPrecedence"] = 5] = "LogicalOrExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["LogicalAndExpressionPrecedence"] = 6] = "LogicalAndExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["BitwiseOrExpressionPrecedence"] = 7] = "BitwiseOrExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["BitwiseExclusiveOrExpressionPrecedence"] = 8] = "BitwiseExclusiveOrExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["BitwiseAndExpressionPrecedence"] = 9] = "BitwiseAndExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["EqualityExpressionPrecedence"] = 10] = "EqualityExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["RelationalExpressionPrecedence"] = 11] = "RelationalExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["ShiftExpressionPrecdence"] = 12] = "ShiftExpressionPrecdence";
+            ExpressionPrecedence[ExpressionPrecedence["AdditiveExpressionPrecedence"] = 13] = "AdditiveExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["MultiplicativeExpressionPrecedence"] = 14] = "MultiplicativeExpressionPrecedence";
+
+            ExpressionPrecedence[ExpressionPrecedence["UnaryExpressionPrecedence"] = 15] = "UnaryExpressionPrecedence";
+        })(ExpressionPrecedence || (ExpressionPrecedence = {}));
+
+        var ListParsingState;
+        (function (ListParsingState) {
+            ListParsingState[ListParsingState["SourceUnit_ModuleElements"] = 1 << 0] = "SourceUnit_ModuleElements";
+            ListParsingState[ListParsingState["ClassDeclaration_ClassElements"] = 1 << 1] = "ClassDeclaration_ClassElements";
+            ListParsingState[ListParsingState["ModuleDeclaration_ModuleElements"] = 1 << 2] = "ModuleDeclaration_ModuleElements";
+            ListParsingState[ListParsingState["SwitchStatement_SwitchClauses"] = 1 << 3] = "SwitchStatement_SwitchClauses";
+            ListParsingState[ListParsingState["SwitchClause_Statements"] = 1 << 4] = "SwitchClause_Statements";
+            ListParsingState[ListParsingState["Block_Statements"] = 1 << 5] = "Block_Statements";
+            ListParsingState[ListParsingState["TryBlock_Statements"] = 1 << 6] = "TryBlock_Statements";
+            ListParsingState[ListParsingState["CatchBlock_Statements"] = 1 << 7] = "CatchBlock_Statements";
+            ListParsingState[ListParsingState["EnumDeclaration_EnumElements"] = 1 << 8] = "EnumDeclaration_EnumElements";
+            ListParsingState[ListParsingState["ObjectType_TypeMembers"] = 1 << 9] = "ObjectType_TypeMembers";
+            ListParsingState[ListParsingState["ClassOrInterfaceDeclaration_HeritageClauses"] = 1 << 10] = "ClassOrInterfaceDeclaration_HeritageClauses";
+            ListParsingState[ListParsingState["HeritageClause_TypeNameList"] = 1 << 11] = "HeritageClause_TypeNameList";
+            ListParsingState[ListParsingState["VariableDeclaration_VariableDeclarators_AllowIn"] = 1 << 12] = "VariableDeclaration_VariableDeclarators_AllowIn";
+            ListParsingState[ListParsingState["VariableDeclaration_VariableDeclarators_DisallowIn"] = 1 << 13] = "VariableDeclaration_VariableDeclarators_DisallowIn";
+            ListParsingState[ListParsingState["ArgumentList_AssignmentExpressions"] = 1 << 14] = "ArgumentList_AssignmentExpressions";
+            ListParsingState[ListParsingState["ObjectLiteralExpression_PropertyAssignments"] = 1 << 15] = "ObjectLiteralExpression_PropertyAssignments";
+            ListParsingState[ListParsingState["ArrayLiteralExpression_AssignmentExpressions"] = 1 << 16] = "ArrayLiteralExpression_AssignmentExpressions";
+            ListParsingState[ListParsingState["ParameterList_Parameters"] = 1 << 17] = "ParameterList_Parameters";
+            ListParsingState[ListParsingState["TypeArgumentList_Types"] = 1 << 18] = "TypeArgumentList_Types";
+            ListParsingState[ListParsingState["TypeParameterList_TypeParameters"] = 1 << 19] = "TypeParameterList_TypeParameters";
+
+            ListParsingState[ListParsingState["FirstListParsingState"] = ListParsingState.SourceUnit_ModuleElements] = "FirstListParsingState";
+            ListParsingState[ListParsingState["LastListParsingState"] = ListParsingState.TypeParameterList_TypeParameters] = "LastListParsingState";
+        })(ListParsingState || (ListParsingState = {}));
+
+        var SyntaxCursor = (function () {
+            function SyntaxCursor(sourceUnit) {
+                this._elements = [];
+                this._index = 0;
+                this._pinCount = 0;
+                sourceUnit.insertChildrenInto(this._elements, 0);
+            }
+            SyntaxCursor.prototype.isFinished = function () {
+                return this._index === this._elements.length;
+            };
+
+            SyntaxCursor.prototype.currentElement = function () {
+                if (this.isFinished()) {
+                    return null;
+                }
+
+                return this._elements[this._index];
+            };
+
+            SyntaxCursor.prototype.currentNode = function () {
+                var element = this.currentElement();
+                return element !== null && element.isNode() ? element : null;
+            };
+
+            SyntaxCursor.prototype.moveToFirstChild = function () {
+                if (this.isFinished()) {
+                    return;
+                }
+
+                var element = this._elements[this._index];
+                if (element.isToken()) {
+                    return;
+                }
+
+                var node = element;
+
+                this._elements.splice(this._index, 1);
+
+                node.insertChildrenInto(this._elements, this._index);
+            };
+
+            SyntaxCursor.prototype.moveToNextSibling = function () {
+                if (this.isFinished()) {
+                    return;
+                }
+
+                if (this._pinCount > 0) {
+                    this._index++;
+                    return;
+                }
+
+                this._elements.shift();
+            };
+
+            SyntaxCursor.prototype.getAndPinCursorIndex = function () {
+                this._pinCount++;
+                return this._index;
+            };
+
+            SyntaxCursor.prototype.releaseAndUnpinCursorIndex = function (index) {
+                this._pinCount--;
+                if (this._pinCount === 0) {
+                }
+            };
+
+            SyntaxCursor.prototype.rewindToPinnedCursorIndex = function (index) {
+                this._index = index;
+            };
+
+            SyntaxCursor.prototype.pinCount = function () {
+                return this._pinCount;
+            };
+
+            SyntaxCursor.prototype.moveToFirstToken = function () {
+                var element;
+
+                while (!this.isFinished()) {
+                    element = this.currentElement();
+                    if (element.isNode()) {
+                        this.moveToFirstChild();
+                        continue;
+                    }
+
+                    return;
+                }
+            };
+
+            SyntaxCursor.prototype.currentToken = function () {
+                this.moveToFirstToken();
+                if (this.isFinished()) {
+                    return null;
+                }
+
+                var element = this.currentElement();
+
+                return element;
+            };
+
+            SyntaxCursor.prototype.peekToken = function (n) {
+                this.moveToFirstToken();
+                var pin = this.getAndPinCursorIndex();
+
+                for (var i = 0; i < n; i++) {
+                    this.moveToNextSibling();
+                    this.moveToFirstToken();
+                }
+
+                var result = this.currentToken();
+                this.rewindToPinnedCursorIndex(pin);
+                this.releaseAndUnpinCursorIndex(pin);
+
+                return result;
+            };
+            return SyntaxCursor;
+        })();
+
+        
+
+        var NormalParserSource = (function () {
+            function NormalParserSource(fileName, text, languageVersion) {
+                this._previousToken = null;
+                this._absolutePosition = 0;
+                this._tokenDiagnostics = [];
+                this.rewindPointPool = [];
+                this.rewindPointPoolCount = 0;
+                this.slidingWindow = new TypeScript.SlidingWindow(this, TypeScript.ArrayUtilities.createArray(32, null), null);
+                this.scanner = new TypeScript.Scanner(fileName, text, languageVersion);
+            }
+            NormalParserSource.prototype.currentNode = function () {
+                return null;
+            };
+
+            NormalParserSource.prototype.moveToNextNode = function () {
+                throw TypeScript.Errors.invalidOperation();
+            };
+
+            NormalParserSource.prototype.absolutePosition = function () {
+                return this._absolutePosition;
+            };
+
+            NormalParserSource.prototype.previousToken = function () {
+                return this._previousToken;
+            };
+
+            NormalParserSource.prototype.tokenDiagnostics = function () {
+                return this._tokenDiagnostics;
+            };
+
+            NormalParserSource.prototype.getOrCreateRewindPoint = function () {
+                if (this.rewindPointPoolCount === 0) {
+                    return {};
+                }
+
+                this.rewindPointPoolCount--;
+                var result = this.rewindPointPool[this.rewindPointPoolCount];
+                this.rewindPointPool[this.rewindPointPoolCount] = null;
+                return result;
+            };
+
+            NormalParserSource.prototype.getRewindPoint = function () {
+                var slidingWindowIndex = this.slidingWindow.getAndPinAbsoluteIndex();
+
+                var rewindPoint = this.getOrCreateRewindPoint();
+
+                rewindPoint.slidingWindowIndex = slidingWindowIndex;
+                rewindPoint.previousToken = this._previousToken;
+                rewindPoint.absolutePosition = this._absolutePosition;
+
+                rewindPoint.pinCount = this.slidingWindow.pinCount();
+
+                return rewindPoint;
+            };
+
+            NormalParserSource.prototype.isPinned = function () {
+                return this.slidingWindow.pinCount() > 0;
+            };
+
+            NormalParserSource.prototype.rewind = function (rewindPoint) {
+                this.slidingWindow.rewindToPinnedIndex(rewindPoint.slidingWindowIndex);
+
+                this._previousToken = rewindPoint.previousToken;
+                this._absolutePosition = rewindPoint.absolutePosition;
+            };
+
+            NormalParserSource.prototype.releaseRewindPoint = function (rewindPoint) {
+                this.slidingWindow.releaseAndUnpinAbsoluteIndex(rewindPoint.absoluteIndex);
+
+                this.rewindPointPool[this.rewindPointPoolCount] = rewindPoint;
+                this.rewindPointPoolCount++;
+            };
+
+            NormalParserSource.prototype.fetchMoreItems = function (allowRegularExpression, sourceIndex, window, destinationIndex, spaceAvailable) {
+                window[destinationIndex] = this.scanner.scan(this._tokenDiagnostics, allowRegularExpression);
+                return 1;
+            };
+
+            NormalParserSource.prototype.peekToken = function (n) {
+                return this.slidingWindow.peekItemN(n);
+            };
+
+            NormalParserSource.prototype.moveToNextToken = function () {
+                var currentToken = this.currentToken();
+                this._absolutePosition += currentToken.fullWidth();
+                this._previousToken = currentToken;
+
+                this.slidingWindow.moveToNextItem();
+            };
+
+            NormalParserSource.prototype.currentToken = function () {
+                return this.slidingWindow.currentItem(false);
+            };
+
+            NormalParserSource.prototype.removeDiagnosticsOnOrAfterPosition = function (position) {
+                var tokenDiagnosticsLength = this._tokenDiagnostics.length;
+                while (tokenDiagnosticsLength > 0) {
+                    var diagnostic = this._tokenDiagnostics[tokenDiagnosticsLength - 1];
+                    if (diagnostic.start() >= position) {
+                        tokenDiagnosticsLength--;
+                    } else {
+                        break;
+                    }
+                }
+
+                this._tokenDiagnostics.length = tokenDiagnosticsLength;
+            };
+
+            NormalParserSource.prototype.resetToPosition = function (absolutePosition, previousToken) {
+                this._absolutePosition = absolutePosition;
+                this._previousToken = previousToken;
+
+                this.removeDiagnosticsOnOrAfterPosition(absolutePosition);
+
+                this.slidingWindow.disgardAllItemsFromCurrentIndexOnwards();
+
+                this.scanner.setAbsoluteIndex(absolutePosition);
+            };
+
+            NormalParserSource.prototype.currentTokenAllowingRegularExpression = function () {
+                this.resetToPosition(this._absolutePosition, this._previousToken);
+
+                var token = this.slidingWindow.currentItem(true);
+
+                return token;
+            };
+            return NormalParserSource;
+        })();
+
+        var IncrementalParserSource = (function () {
+            function IncrementalParserSource(oldSyntaxTree, textChangeRange, newText) {
+                this._changeDelta = 0;
+                var oldSourceUnit = oldSyntaxTree.sourceUnit();
+                this._oldSourceUnitCursor = new SyntaxCursor(oldSourceUnit);
+
+                this._changeRange = IncrementalParserSource.extendToAffectedRange(textChangeRange, oldSourceUnit);
+
+                if (TypeScript.Debug.shouldAssert(2 /* Aggressive */)) {
+                    TypeScript.Debug.assert((oldSourceUnit.fullWidth() - this._changeRange.span().length() + this._changeRange.newLength()) === newText.length());
+                }
+
+                this._normalParserSource = new NormalParserSource(oldSyntaxTree.fileName(), newText, oldSyntaxTree.parseOptions().languageVersion());
+            }
+            IncrementalParserSource.extendToAffectedRange = function (changeRange, sourceUnit) {
+                var maxLookahead = 1;
+
+                var start = changeRange.span().start();
+
+                for (var i = 0; start > 0 && i <= maxLookahead; i++) {
+                    var token = sourceUnit.findToken(start);
+
+                    var position = token.fullStart();
+
+                    start = TypeScript.MathPrototype.max(0, position - 1);
+                }
+
+                var finalSpan = TypeScript.TextSpan.fromBounds(start, changeRange.span().end());
+                var finalLength = changeRange.newLength() + (changeRange.span().start() - start);
+
+                return new TypeScript.TextChangeRange(finalSpan, finalLength);
+            };
+
+            IncrementalParserSource.prototype.absolutePosition = function () {
+                return this._normalParserSource.absolutePosition();
+            };
+
+            IncrementalParserSource.prototype.previousToken = function () {
+                return this._normalParserSource.previousToken();
+            };
+
+            IncrementalParserSource.prototype.tokenDiagnostics = function () {
+                return this._normalParserSource.tokenDiagnostics();
+            };
+
+            IncrementalParserSource.prototype.getRewindPoint = function () {
+                var rewindPoint = this._normalParserSource.getRewindPoint();
+                var oldSourceUnitCursorIndex = this._oldSourceUnitCursor.getAndPinCursorIndex();
+
+                rewindPoint.changeDelta = this._changeDelta;
+                rewindPoint.changeRange = this._changeRange;
+                rewindPoint.oldSourceUnitCursorIndex = oldSourceUnitCursorIndex;
+
+                return rewindPoint;
+            };
+
+            IncrementalParserSource.prototype.rewind = function (rewindPoint) {
+                this._changeRange = rewindPoint.changeRange;
+                this._changeDelta = rewindPoint.changeDelta;
+                this._oldSourceUnitCursor.rewindToPinnedCursorIndex(rewindPoint.oldSourceUnitCursorIndex);
+
+                this._normalParserSource.rewind(rewindPoint);
+            };
+
+            IncrementalParserSource.prototype.releaseRewindPoint = function (rewindPoint) {
+                this._oldSourceUnitCursor.releaseAndUnpinCursorIndex(rewindPoint.oldSourceUnitCursorIndex);
+                this._normalParserSource.releaseRewindPoint(rewindPoint);
+            };
+
+            IncrementalParserSource.prototype.canReadFromOldSourceUnit = function () {
+                if (this._normalParserSource.isPinned()) {
+                    return false;
+                }
+
+                if (this._changeRange !== null && this._changeRange.newSpan().intersectsWithPosition(this.absolutePosition())) {
+                    return false;
+                }
+
+                this.syncCursorToNewTextIfBehind();
+
+                return this._changeDelta === 0 && !this._oldSourceUnitCursor.isFinished();
+            };
+
+            IncrementalParserSource.prototype.currentNode = function () {
+                if (this.canReadFromOldSourceUnit()) {
+                    return this.tryGetNodeFromOldSourceUnit();
+                }
+
+                return null;
+            };
+
+            IncrementalParserSource.prototype.currentToken = function () {
+                if (this.canReadFromOldSourceUnit()) {
+                    var token = this.tryGetTokenFromOldSourceUnit();
+                    if (token !== null) {
+                        return token;
+                    }
+                }
+
+                return this._normalParserSource.currentToken();
+            };
+
+            IncrementalParserSource.prototype.currentTokenAllowingRegularExpression = function () {
+                return this._normalParserSource.currentTokenAllowingRegularExpression();
+            };
+
+            IncrementalParserSource.prototype.syncCursorToNewTextIfBehind = function () {
+                while (true) {
+                    if (this._oldSourceUnitCursor.isFinished()) {
+                        break;
+                    }
+
+                    if (this._changeDelta >= 0) {
+                        break;
+                    }
+
+                    var currentElement = this._oldSourceUnitCursor.currentElement();
+
+                    if (currentElement.isNode() && (currentElement.fullWidth() > Math.abs(this._changeDelta))) {
+                        this._oldSourceUnitCursor.moveToFirstChild();
+                    } else {
+                        this._oldSourceUnitCursor.moveToNextSibling();
+
+                        this._changeDelta += currentElement.fullWidth();
+                    }
+                }
+            };
+
+            IncrementalParserSource.prototype.intersectsWithChangeRangeSpanInOriginalText = function (start, length) {
+                return this._changeRange !== null && this._changeRange.span().intersectsWith(start, length);
+            };
+
+            IncrementalParserSource.prototype.tryGetNodeFromOldSourceUnit = function () {
+                while (true) {
+                    var node = this._oldSourceUnitCursor.currentNode();
+                    if (node === null) {
+                        return null;
+                    }
+
+                    if (!this.intersectsWithChangeRangeSpanInOriginalText(this.absolutePosition(), node.fullWidth())) {
+                        if (!node.isIncrementallyUnusable()) {
+                            return node;
+                        }
+                    }
+
+                    this._oldSourceUnitCursor.moveToFirstChild();
+                }
+            };
+
+            IncrementalParserSource.prototype.canReuseTokenFromOldSourceUnit = function (position, token) {
+                if (token !== null) {
+                    if (!this.intersectsWithChangeRangeSpanInOriginalText(position, token.fullWidth())) {
+                        if (!token.isIncrementallyUnusable()) {
+                            return true;
+                        }
+                    }
+                }
+
+                return false;
+            };
+
+            IncrementalParserSource.prototype.tryGetTokenFromOldSourceUnit = function () {
+                var token = this._oldSourceUnitCursor.currentToken();
+
+                return this.canReuseTokenFromOldSourceUnit(this.absolutePosition(), token) ? token : null;
+            };
+
+            IncrementalParserSource.prototype.peekToken = function (n) {
+                if (this.canReadFromOldSourceUnit()) {
+                    var token = this.tryPeekTokenFromOldSourceUnit(n);
+                    if (token !== null) {
+                        return token;
+                    }
+                }
+
+                return this._normalParserSource.peekToken(n);
+            };
+
+            IncrementalParserSource.prototype.tryPeekTokenFromOldSourceUnit = function (n) {
+                var currentPosition = this.absolutePosition();
+                for (var i = 0; i < n; i++) {
+                    var interimToken = this._oldSourceUnitCursor.peekToken(i);
+                    if (!this.canReuseTokenFromOldSourceUnit(currentPosition, interimToken)) {
+                        return null;
+                    }
+
+                    currentPosition += interimToken.fullWidth();
+                }
+
+                var token = this._oldSourceUnitCursor.peekToken(n);
+                return this.canReuseTokenFromOldSourceUnit(currentPosition, token) ? token : null;
+            };
+
+            IncrementalParserSource.prototype.moveToNextNode = function () {
+                var currentElement = this._oldSourceUnitCursor.currentElement();
+                var currentNode = this._oldSourceUnitCursor.currentNode();
+
+                this._oldSourceUnitCursor.moveToNextSibling();
+
+                var absolutePosition = this.absolutePosition() + currentNode.fullWidth();
+                var previousToken = currentNode.lastToken();
+                this._normalParserSource.resetToPosition(absolutePosition, previousToken);
+
+                if (this._changeRange !== null) {
+                }
+            };
+
+            IncrementalParserSource.prototype.moveToNextToken = function () {
+                var currentToken = this.currentToken();
+
+                if (this._oldSourceUnitCursor.currentToken() === currentToken) {
+                    this._oldSourceUnitCursor.moveToNextSibling();
+
+                    var absolutePosition = this.absolutePosition() + currentToken.fullWidth();
+                    var previousToken = currentToken;
+                    this._normalParserSource.resetToPosition(absolutePosition, previousToken);
+
+                    if (this._changeRange !== null) {
+                    }
+                } else {
+                    this._changeDelta -= currentToken.fullWidth();
+
+                    this._normalParserSource.moveToNextToken();
+
+                    if (this._changeRange !== null) {
+                        var changeRangeSpanInNewText = this._changeRange.newSpan();
+                        if (this.absolutePosition() >= changeRangeSpanInNewText.end()) {
+                            this._changeDelta += this._changeRange.newLength() - this._changeRange.span().length();
+                            this._changeRange = null;
+                        }
+                    }
+                }
+            };
+            return IncrementalParserSource;
+        })();
+
+        var ParserImpl = (function () {
+            function ParserImpl(fileName, lineMap, source, parseOptions, newText_forDebuggingPurposesOnly) {
+                this.newText_forDebuggingPurposesOnly = newText_forDebuggingPurposesOnly;
+                this.listParsingState = 0;
+                this.isInStrictMode = false;
+                this.diagnostics = [];
+                this.factory = TypeScript.Syntax.normalModeFactory;
+                this.mergeTokensStorage = [];
+                this.arrayPool = [];
+                this.fileName = fileName;
+                this.lineMap = lineMap;
+                this.source = source;
+                this.parseOptions = parseOptions;
+            }
+            ParserImpl.prototype.getRewindPoint = function () {
+                var rewindPoint = this.source.getRewindPoint();
+
+                rewindPoint.diagnosticsCount = this.diagnostics.length;
+
+                rewindPoint.isInStrictMode = this.isInStrictMode;
+                rewindPoint.listParsingState = this.listParsingState;
+
+                return rewindPoint;
+            };
+
+            ParserImpl.prototype.rewind = function (rewindPoint) {
+                this.source.rewind(rewindPoint);
+
+                this.diagnostics.length = rewindPoint.diagnosticsCount;
+            };
+
+            ParserImpl.prototype.releaseRewindPoint = function (rewindPoint) {
+                this.source.releaseRewindPoint(rewindPoint);
+            };
+
+            ParserImpl.prototype.currentTokenStart = function () {
+                return this.source.absolutePosition() + this.currentToken().leadingTriviaWidth();
+            };
+
+            ParserImpl.prototype.previousTokenStart = function () {
+                if (this.previousToken() === null) {
+                    return 0;
+                }
+
+                return this.source.absolutePosition() - this.previousToken().fullWidth() + this.previousToken().leadingTriviaWidth();
+            };
+
+            ParserImpl.prototype.previousTokenEnd = function () {
+                if (this.previousToken() === null) {
+                    return 0;
+                }
+
+                return this.previousTokenStart() + this.previousToken().width();
+            };
+
+            ParserImpl.prototype.currentNode = function () {
+                var node = this.source.currentNode();
+
+                if (node === null || node.parsedInStrictMode() !== this.isInStrictMode) {
+                    return null;
+                }
+
+                return node;
+            };
+
+            ParserImpl.prototype.currentToken = function () {
+                return this.source.currentToken();
+            };
+
+            ParserImpl.prototype.currentTokenAllowingRegularExpression = function () {
+                return this.source.currentTokenAllowingRegularExpression();
+            };
+
+            ParserImpl.prototype.peekToken = function (n) {
+                return this.source.peekToken(n);
+            };
+
+            ParserImpl.prototype.eatAnyToken = function () {
+                var token = this.currentToken();
+                this.moveToNextToken();
+                return token;
+            };
+
+            ParserImpl.prototype.moveToNextToken = function () {
+                this.source.moveToNextToken();
+            };
+
+            ParserImpl.prototype.previousToken = function () {
+                return this.source.previousToken();
+            };
+
+            ParserImpl.prototype.eatNode = function () {
+                var node = this.source.currentNode();
+                this.source.moveToNextNode();
+                return node;
+            };
+
+            ParserImpl.prototype.eatToken = function (kind) {
+                var token = this.currentToken();
+                if (token.tokenKind === kind) {
+                    this.moveToNextToken();
+                    return token;
+                }
+
+                return this.createMissingToken(kind, token);
+            };
+
+            ParserImpl.prototype.tryEatToken = function (kind) {
+                if (this.currentToken().tokenKind === kind) {
+                    return this.eatToken(kind);
+                }
+
+                return null;
+            };
+
+            ParserImpl.prototype.eatKeyword = function (kind) {
+                var token = this.currentToken();
+                if (token.tokenKind === kind) {
+                    this.moveToNextToken();
+                    return token;
+                }
+
+                return this.createMissingToken(kind, token);
+            };
+
+            ParserImpl.prototype.isIdentifier = function (token) {
+                var tokenKind = token.tokenKind;
+
+                if (tokenKind === 11 /* IdentifierName */) {
+                    return true;
+                }
+
+                if (tokenKind >= 51 /* FirstFutureReservedStrictKeyword */) {
+                    if (tokenKind <= 59 /* LastFutureReservedStrictKeyword */) {
+                        return !this.isInStrictMode;
+                    }
+
+                    return tokenKind <= 69 /* LastTypeScriptKeyword */;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.eatIdentifierNameToken = function () {
+                var token = this.currentToken();
+
+                if (token.tokenKind === 11 /* IdentifierName */) {
+                    this.moveToNextToken();
+                    return token;
+                }
+
+                if (TypeScript.SyntaxFacts.isAnyKeyword(token.tokenKind)) {
+                    this.moveToNextToken();
+                    return TypeScript.Syntax.convertToIdentifierName(token);
+                }
+
+                return this.createMissingToken(11 /* IdentifierName */, token);
+            };
+
+            ParserImpl.prototype.eatIdentifierToken = function () {
+                var token = this.currentToken();
+                if (this.isIdentifier(token)) {
+                    this.moveToNextToken();
+
+                    if (token.tokenKind === 11 /* IdentifierName */) {
+                        return token;
+                    }
+
+                    return TypeScript.Syntax.convertToIdentifierName(token);
+                }
+
+                return this.createMissingToken(11 /* IdentifierName */, token);
+            };
+
+            ParserImpl.prototype.canEatAutomaticSemicolon = function (allowWithoutNewLine) {
+                var token = this.currentToken();
+
+                if (token.tokenKind === 10 /* EndOfFileToken */) {
+                    return true;
+                }
+
+                if (token.tokenKind === 71 /* CloseBraceToken */) {
+                    return true;
+                }
+
+                if (allowWithoutNewLine) {
+                    return true;
+                }
+
+                if (this.previousToken() !== null && this.previousToken().hasTrailingNewLine()) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.canEatExplicitOrAutomaticSemicolon = function (allowWithoutNewline) {
+                var token = this.currentToken();
+
+                if (token.tokenKind === 78 /* SemicolonToken */) {
+                    return true;
+                }
+
+                return this.canEatAutomaticSemicolon(allowWithoutNewline);
+            };
+
+            ParserImpl.prototype.eatExplicitOrAutomaticSemicolon = function (allowWithoutNewline) {
+                var token = this.currentToken();
+
+                if (token.tokenKind === 78 /* SemicolonToken */) {
+                    return this.eatToken(78 /* SemicolonToken */);
+                }
+
+                if (this.canEatAutomaticSemicolon(allowWithoutNewline)) {
+                    var semicolonToken = TypeScript.Syntax.emptyToken(78 /* SemicolonToken */);
+
+                    if (!this.parseOptions.allowAutomaticSemicolonInsertion()) {
+                        this.addDiagnostic(new TypeScript.Diagnostic(this.fileName, this.lineMap, this.previousTokenEnd(), 0, TypeScript.DiagnosticCode.Automatic_semicolon_insertion_not_allowed, null));
+                    }
+
+                    return semicolonToken;
+                }
+
+                return this.eatToken(78 /* SemicolonToken */);
+            };
+
+            ParserImpl.prototype.isKeyword = function (kind) {
+                if (kind >= 15 /* FirstKeyword */) {
+                    if (kind <= 50 /* LastFutureReservedKeyword */) {
+                        return true;
+                    }
+
+                    if (this.isInStrictMode) {
+                        return kind <= 59 /* LastFutureReservedStrictKeyword */;
+                    }
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.createMissingToken = function (expectedKind, actual) {
+                var diagnostic = this.getExpectedTokenDiagnostic(expectedKind, actual);
+                this.addDiagnostic(diagnostic);
+
+                return TypeScript.Syntax.emptyToken(expectedKind);
+            };
+
+            ParserImpl.prototype.getExpectedTokenDiagnostic = function (expectedKind, actual) {
+                var token = this.currentToken();
+
+                if (TypeScript.SyntaxFacts.isAnyKeyword(expectedKind) || TypeScript.SyntaxFacts.isAnyPunctuation(expectedKind)) {
+                    return new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode._0_expected, [TypeScript.SyntaxFacts.getText(expectedKind)]);
+                } else {
+                    if (actual !== null && TypeScript.SyntaxFacts.isAnyKeyword(actual.tokenKind)) {
+                        return new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode.Identifier_expected_0_is_a_keyword, [TypeScript.SyntaxFacts.getText(actual.tokenKind)]);
+                    } else {
+                        return new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode.Identifier_expected, null);
+                    }
+                }
+            };
+
+            ParserImpl.getPrecedence = function (expressionKind) {
+                switch (expressionKind) {
+                    case 173 /* CommaExpression */:
+                        return 1 /* CommaExpressionPrecedence */;
+
+                    case 174 /* AssignmentExpression */:
+                    case 175 /* AddAssignmentExpression */:
+                    case 176 /* SubtractAssignmentExpression */:
+                    case 177 /* MultiplyAssignmentExpression */:
+                    case 178 /* DivideAssignmentExpression */:
+                    case 179 /* ModuloAssignmentExpression */:
+                    case 180 /* AndAssignmentExpression */:
+                    case 181 /* ExclusiveOrAssignmentExpression */:
+                    case 182 /* OrAssignmentExpression */:
+                    case 183 /* LeftShiftAssignmentExpression */:
+                    case 184 /* SignedRightShiftAssignmentExpression */:
+                    case 185 /* UnsignedRightShiftAssignmentExpression */:
+                        return 2 /* AssignmentExpressionPrecedence */;
+
+                    case 186 /* ConditionalExpression */:
+                        return 3 /* ConditionalExpressionPrecedence */;
+
+                    case 187 /* LogicalOrExpression */:
+                        return 5 /* LogicalOrExpressionPrecedence */;
+
+                    case 188 /* LogicalAndExpression */:
+                        return 6 /* LogicalAndExpressionPrecedence */;
+
+                    case 189 /* BitwiseOrExpression */:
+                        return 7 /* BitwiseOrExpressionPrecedence */;
+
+                    case 190 /* BitwiseExclusiveOrExpression */:
+                        return 8 /* BitwiseExclusiveOrExpressionPrecedence */;
+
+                    case 191 /* BitwiseAndExpression */:
+                        return 9 /* BitwiseAndExpressionPrecedence */;
+
+                    case 192 /* EqualsWithTypeConversionExpression */:
+                    case 193 /* NotEqualsWithTypeConversionExpression */:
+                    case 194 /* EqualsExpression */:
+                    case 195 /* NotEqualsExpression */:
+                        return 10 /* EqualityExpressionPrecedence */;
+
+                    case 196 /* LessThanExpression */:
+                    case 197 /* GreaterThanExpression */:
+                    case 198 /* LessThanOrEqualExpression */:
+                    case 199 /* GreaterThanOrEqualExpression */:
+                    case 200 /* InstanceOfExpression */:
+                    case 201 /* InExpression */:
+                        return 11 /* RelationalExpressionPrecedence */;
+
+                    case 202 /* LeftShiftExpression */:
+                    case 203 /* SignedRightShiftExpression */:
+                    case 204 /* UnsignedRightShiftExpression */:
+                        return 12 /* ShiftExpressionPrecdence */;
+
+                    case 208 /* AddExpression */:
+                    case 209 /* SubtractExpression */:
+                        return 13 /* AdditiveExpressionPrecedence */;
+
+                    case 205 /* MultiplyExpression */:
+                    case 206 /* DivideExpression */:
+                    case 207 /* ModuloExpression */:
+                        return 14 /* MultiplicativeExpressionPrecedence */;
+
+                    case 164 /* PlusExpression */:
+                    case 165 /* NegateExpression */:
+                    case 166 /* BitwiseNotExpression */:
+                    case 167 /* LogicalNotExpression */:
+                    case 170 /* DeleteExpression */:
+                    case 171 /* TypeOfExpression */:
+                    case 172 /* VoidExpression */:
+                    case 168 /* PreIncrementExpression */:
+                    case 169 /* PreDecrementExpression */:
+                        return 15 /* UnaryExpressionPrecedence */;
+                }
+
+                throw TypeScript.Errors.invalidOperation();
+            };
+
+            ParserImpl.prototype.addSkippedTokenAfterNodeOrToken = function (nodeOrToken, skippedToken) {
+                if (nodeOrToken.isToken()) {
+                    return this.addSkippedTokenAfterToken(nodeOrToken, skippedToken);
+                } else if (nodeOrToken.isNode()) {
+                    return this.addSkippedTokenAfterNode(nodeOrToken, skippedToken);
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.addSkippedTokenAfterNode = function (node, skippedToken) {
+                var oldToken = node.lastToken();
+                var newToken = this.addSkippedTokenAfterToken(oldToken, skippedToken);
+
+                return node.replaceToken(oldToken, newToken);
+            };
+
+            ParserImpl.prototype.addSkippedTokensBeforeNode = function (node, skippedTokens) {
+                if (skippedTokens.length > 0) {
+                    var oldToken = node.firstToken();
+                    var newToken = this.addSkippedTokensBeforeToken(oldToken, skippedTokens);
+
+                    return node.replaceToken(oldToken, newToken);
+                }
+
+                return node;
+            };
+
+            ParserImpl.prototype.addSkippedTokensBeforeToken = function (token, skippedTokens) {
+                var leadingTrivia = [];
+                for (var i = 0, n = skippedTokens.length; i < n; i++) {
+                    this.addSkippedTokenToTriviaArray(leadingTrivia, skippedTokens[i]);
+                }
+
+                this.addTriviaTo(token.leadingTrivia(), leadingTrivia);
+
+                this.returnArray(skippedTokens);
+                return token.withLeadingTrivia(TypeScript.Syntax.triviaList(leadingTrivia));
+            };
+
+            ParserImpl.prototype.addSkippedTokensAfterToken = function (token, skippedTokens) {
+                if (skippedTokens.length === 0) {
+                    this.returnArray(skippedTokens);
+                    return token;
+                }
+
+                var trailingTrivia = token.trailingTrivia().toArray();
+
+                for (var i = 0, n = skippedTokens.length; i < n; i++) {
+                    this.addSkippedTokenToTriviaArray(trailingTrivia, skippedTokens[i]);
+                }
+
+                this.returnArray(skippedTokens);
+                return token.withTrailingTrivia(TypeScript.Syntax.triviaList(trailingTrivia));
+            };
+
+            ParserImpl.prototype.addSkippedTokenAfterToken = function (token, skippedToken) {
+                var trailingTrivia = token.trailingTrivia().toArray();
+                this.addSkippedTokenToTriviaArray(trailingTrivia, skippedToken);
+
+                return token.withTrailingTrivia(TypeScript.Syntax.triviaList(trailingTrivia));
+            };
+
+            ParserImpl.prototype.addSkippedTokenToTriviaArray = function (array, skippedToken) {
+                this.addTriviaTo(skippedToken.leadingTrivia(), array);
+
+                var trimmedToken = skippedToken.withLeadingTrivia(TypeScript.Syntax.emptyTriviaList).withTrailingTrivia(TypeScript.Syntax.emptyTriviaList);
+                array.push(TypeScript.Syntax.skippedTokenTrivia(trimmedToken));
+
+                this.addTriviaTo(skippedToken.trailingTrivia(), array);
+            };
+
+            ParserImpl.prototype.addTriviaTo = function (list, array) {
+                for (var i = 0, n = list.count(); i < n; i++) {
+                    array.push(list.syntaxTriviaAt(i));
+                }
+            };
+
+            ParserImpl.prototype.parseSyntaxTree = function (isDeclaration) {
+                var sourceUnit = this.parseSourceUnit();
+
+                var allDiagnostics = this.source.tokenDiagnostics().concat(this.diagnostics);
+                allDiagnostics.sort(function (a, b) {
+                    return a.start() - b.start();
+                });
+
+                return new TypeScript.SyntaxTree(sourceUnit, isDeclaration, allDiagnostics, this.fileName, this.lineMap, this.parseOptions);
+            };
+
+            ParserImpl.prototype.setStrictMode = function (isInStrictMode) {
+                this.isInStrictMode = isInStrictMode;
+                this.factory = isInStrictMode ? TypeScript.Syntax.strictModeFactory : TypeScript.Syntax.normalModeFactory;
+            };
+
+            ParserImpl.prototype.parseSourceUnit = function () {
+                var savedIsInStrictMode = this.isInStrictMode;
+
+                var result = this.parseSyntaxList(1 /* SourceUnit_ModuleElements */, ParserImpl.updateStrictModeState);
+                var moduleElements = result.list;
+
+                this.setStrictMode(savedIsInStrictMode);
+
+                var sourceUnit = this.factory.sourceUnit(moduleElements, this.currentToken());
+                sourceUnit = this.addSkippedTokensBeforeNode(sourceUnit, result.skippedTokens);
+
+                if (TypeScript.Debug.shouldAssert(2 /* Aggressive */)) {
+                    TypeScript.Debug.assert(sourceUnit.fullWidth() === this.newText_forDebuggingPurposesOnly.length());
+
+                    if (TypeScript.Debug.shouldAssert(3 /* VeryAggressive */)) {
+                        TypeScript.Debug.assert(sourceUnit.fullText() === this.newText_forDebuggingPurposesOnly.substr(0, this.newText_forDebuggingPurposesOnly.length(), false));
+                    }
+                }
+
+                return sourceUnit;
+            };
+
+            ParserImpl.updateStrictModeState = function (parser, items) {
+                if (!parser.isInStrictMode) {
+                    for (var i = 0; i < items.length; i++) {
+                        var item = items[i];
+                        if (!TypeScript.SyntaxFacts.isDirectivePrologueElement(item)) {
+                            return;
+                        }
+                    }
+
+                    parser.setStrictMode(TypeScript.SyntaxFacts.isUseStrictDirective(items[items.length - 1]));
+                }
+            };
+
+            ParserImpl.prototype.isModuleElement = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isModuleElement()) {
+                    return true;
+                }
+
+                var modifierCount = this.modifierCount();
+                return this.isImportDeclaration(modifierCount) || this.isExportAssignment() || this.isModuleDeclaration(modifierCount) || this.isInterfaceDeclaration(modifierCount) || this.isClassDeclaration(modifierCount) || this.isEnumDeclaration(modifierCount) || this.isStatement(inErrorRecovery);
+            };
+
+            ParserImpl.prototype.parseModuleElement = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isModuleElement()) {
+                    return this.eatNode();
+                }
+
+                var modifierCount = this.modifierCount();
+                if (this.isImportDeclaration(modifierCount)) {
+                    return this.parseImportDeclaration();
+                } else if (this.isExportAssignment()) {
+                    return this.parseExportAssignment();
+                } else if (this.isModuleDeclaration(modifierCount)) {
+                    return this.parseModuleDeclaration();
+                } else if (this.isInterfaceDeclaration(modifierCount)) {
+                    return this.parseInterfaceDeclaration();
+                } else if (this.isClassDeclaration(modifierCount)) {
+                    return this.parseClassDeclaration();
+                } else if (this.isEnumDeclaration(modifierCount)) {
+                    return this.parseEnumDeclaration();
+                } else if (this.isStatement(inErrorRecovery)) {
+                    return this.parseStatement(inErrorRecovery);
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.isImportDeclaration = function (modifierCount) {
+                if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 49 /* ImportKeyword */) {
+                    return true;
+                }
+
+                return this.currentToken().tokenKind === 49 /* ImportKeyword */ && this.isIdentifier(this.peekToken(1));
+            };
+
+            ParserImpl.prototype.parseImportDeclaration = function () {
+                var modifiers = this.parseModifiers();
+                var importKeyword = this.eatKeyword(49 /* ImportKeyword */);
+                var identifier = this.eatIdentifierToken();
+                var equalsToken = this.eatToken(107 /* EqualsToken */);
+                var moduleReference = this.parseModuleReference();
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.importDeclaration(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken);
+            };
+
+            ParserImpl.prototype.isExportAssignment = function () {
+                return this.currentToken().tokenKind === 47 /* ExportKeyword */ && this.peekToken(1).tokenKind === 107 /* EqualsToken */;
+            };
+
+            ParserImpl.prototype.parseExportAssignment = function () {
+                var exportKeyword = this.eatKeyword(47 /* ExportKeyword */);
+                var equalsToken = this.eatToken(107 /* EqualsToken */);
+                var identifier = this.eatIdentifierToken();
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.exportAssignment(exportKeyword, equalsToken, identifier, semicolonToken);
+            };
+
+            ParserImpl.prototype.parseModuleReference = function () {
+                if (this.isExternalModuleReference()) {
+                    return this.parseExternalModuleReference();
+                } else {
+                    return this.parseModuleNameModuleReference();
+                }
+            };
+
+            ParserImpl.prototype.isExternalModuleReference = function () {
+                var token0 = this.currentToken();
+                if (token0.tokenKind === 66 /* RequireKeyword */) {
+                    return this.peekToken(1).tokenKind === 72 /* OpenParenToken */;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.parseExternalModuleReference = function () {
+                var requireKeyword = this.eatKeyword(66 /* RequireKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var stringLiteral = this.eatToken(14 /* StringLiteral */);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+
+                return this.factory.externalModuleReference(requireKeyword, openParenToken, stringLiteral, closeParenToken);
+            };
+
+            ParserImpl.prototype.parseModuleNameModuleReference = function () {
+                var name = this.parseName();
+                return this.factory.moduleNameModuleReference(name);
+            };
+
+            ParserImpl.prototype.parseIdentifierName = function () {
+                var identifierName = this.eatIdentifierNameToken();
+                return identifierName;
+            };
+
+            ParserImpl.prototype.tryParseTypeArgumentList = function (inExpression) {
+                if (this.currentToken().kind() !== 80 /* LessThanToken */) {
+                    return null;
+                }
+
+                var lessThanToken;
+                var greaterThanToken;
+                var result;
+                var typeArguments;
+
+                if (!inExpression) {
+                    lessThanToken = this.eatToken(80 /* LessThanToken */);
+
+                    result = this.parseSeparatedSyntaxList(262144 /* TypeArgumentList_Types */);
+                    typeArguments = result.list;
+                    lessThanToken = this.addSkippedTokensAfterToken(lessThanToken, result.skippedTokens);
+
+                    greaterThanToken = this.eatToken(81 /* GreaterThanToken */);
+
+                    return this.factory.typeArgumentList(lessThanToken, typeArguments, greaterThanToken);
+                }
+
+                var rewindPoint = this.getRewindPoint();
+
+                lessThanToken = this.eatToken(80 /* LessThanToken */);
+
+                result = this.parseSeparatedSyntaxList(262144 /* TypeArgumentList_Types */);
+                typeArguments = result.list;
+                lessThanToken = this.addSkippedTokensAfterToken(lessThanToken, result.skippedTokens);
+
+                greaterThanToken = this.eatToken(81 /* GreaterThanToken */);
+
+                if (greaterThanToken.fullWidth() === 0 || !this.canFollowTypeArgumentListInExpression(this.currentToken().kind())) {
+                    this.rewind(rewindPoint);
+
+                    this.releaseRewindPoint(rewindPoint);
+                    return null;
+                } else {
+                    this.releaseRewindPoint(rewindPoint);
+                    var typeArgumentList = this.factory.typeArgumentList(lessThanToken, typeArguments, greaterThanToken);
+
+                    return typeArgumentList;
+                }
+            };
+
+            ParserImpl.prototype.canFollowTypeArgumentListInExpression = function (kind) {
+                switch (kind) {
+                    case 72 /* OpenParenToken */:
+                    case 76 /* DotToken */:
+
+                    case 73 /* CloseParenToken */:
+                    case 75 /* CloseBracketToken */:
+                    case 106 /* ColonToken */:
+                    case 78 /* SemicolonToken */:
+                    case 79 /* CommaToken */:
+                    case 105 /* QuestionToken */:
+                    case 84 /* EqualsEqualsToken */:
+                    case 87 /* EqualsEqualsEqualsToken */:
+                    case 86 /* ExclamationEqualsToken */:
+                    case 88 /* ExclamationEqualsEqualsToken */:
+                    case 103 /* AmpersandAmpersandToken */:
+                    case 104 /* BarBarToken */:
+                    case 100 /* CaretToken */:
+                    case 98 /* AmpersandToken */:
+                    case 99 /* BarToken */:
+                    case 71 /* CloseBraceToken */:
+                    case 10 /* EndOfFileToken */:
+                        return true;
+
+                    default:
+                        return false;
+                }
+            };
+
+            ParserImpl.prototype.parseName = function () {
+                var shouldContinue = this.isIdentifier(this.currentToken());
+                var current = this.eatIdentifierToken();
+
+                while (shouldContinue && this.currentToken().tokenKind === 76 /* DotToken */) {
+                    var dotToken = this.eatToken(76 /* DotToken */);
+
+                    var currentToken = this.currentToken();
+                    var identifierName;
+
+                    if (TypeScript.SyntaxFacts.isAnyKeyword(currentToken.tokenKind) && this.previousToken().hasTrailingNewLine() && !currentToken.hasTrailingNewLine() && TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(this.peekToken(1))) {
+                        identifierName = this.createMissingToken(11 /* IdentifierName */, currentToken);
+                    } else {
+                        identifierName = this.eatIdentifierNameToken();
+                    }
+
+                    current = this.factory.qualifiedName(current, dotToken, identifierName);
+
+                    shouldContinue = identifierName.fullWidth() > 0;
+                }
+
+                return current;
+            };
+
+            ParserImpl.prototype.isEnumDeclaration = function (modifierCount) {
+                if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 46 /* EnumKeyword */) {
+                    return true;
+                }
+
+                return this.currentToken().tokenKind === 46 /* EnumKeyword */ && this.isIdentifier(this.peekToken(1));
+            };
+
+            ParserImpl.prototype.parseEnumDeclaration = function () {
+                var modifiers = this.parseModifiers();
+                var enumKeyword = this.eatKeyword(46 /* EnumKeyword */);
+                var identifier = this.eatIdentifierToken();
+
+                var openBraceToken = this.eatToken(70 /* OpenBraceToken */);
+                var enumElements = TypeScript.Syntax.emptySeparatedList;
+
+                if (openBraceToken.width() > 0) {
+                    var result = this.parseSeparatedSyntaxList(256 /* EnumDeclaration_EnumElements */);
+                    enumElements = result.list;
+                    openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens);
+                }
+
+                var closeBraceToken = this.eatToken(71 /* CloseBraceToken */);
+
+                return this.factory.enumDeclaration(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken);
+            };
+
+            ParserImpl.prototype.isEnumElement = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().kind() === 243 /* EnumElement */) {
+                    return true;
+                }
+
+                return this.isPropertyName(this.currentToken(), inErrorRecovery);
+            };
+
+            ParserImpl.prototype.parseEnumElement = function () {
+                if (this.currentNode() !== null && this.currentNode().kind() === 243 /* EnumElement */) {
+                    return this.eatNode();
+                }
+
+                var propertyName = this.eatPropertyName();
+                var equalsValueClause = null;
+                if (this.isEqualsValueClause(false)) {
+                    equalsValueClause = this.parseEqualsValueClause(true);
+                }
+
+                return this.factory.enumElement(propertyName, equalsValueClause);
+            };
+
+            ParserImpl.isModifier = function (token) {
+                switch (token.tokenKind) {
+                    case 57 /* PublicKeyword */:
+                    case 55 /* PrivateKeyword */:
+                    case 58 /* StaticKeyword */:
+                    case 47 /* ExportKeyword */:
+                    case 63 /* DeclareKeyword */:
+                        return true;
+
+                    default:
+                        return false;
+                }
+            };
+
+            ParserImpl.prototype.modifierCount = function () {
+                var modifierCount = 0;
+                while (true) {
+                    if (ParserImpl.isModifier(this.peekToken(modifierCount))) {
+                        modifierCount++;
+                        continue;
+                    }
+
+                    break;
+                }
+
+                return modifierCount;
+            };
+
+            ParserImpl.prototype.parseModifiers = function () {
+                var tokens = this.getArray();
+
+                while (true) {
+                    if (ParserImpl.isModifier(this.currentToken())) {
+                        tokens.push(this.eatAnyToken());
+                        continue;
+                    }
+
+                    break;
+                }
+
+                var result = TypeScript.Syntax.list(tokens);
+
+                this.returnZeroOrOneLengthArray(tokens);
+
+                return result;
+            };
+
+            ParserImpl.prototype.isClassDeclaration = function (modifierCount) {
+                if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 44 /* ClassKeyword */) {
+                    return true;
+                }
+
+                return this.currentToken().tokenKind === 44 /* ClassKeyword */ && this.isIdentifier(this.peekToken(1));
+            };
+
+            ParserImpl.prototype.parseHeritageClauses = function () {
+                var heritageClauses = TypeScript.Syntax.emptyList;
+
+                if (this.isHeritageClause()) {
+                    var result = this.parseSyntaxList(1024 /* ClassOrInterfaceDeclaration_HeritageClauses */);
+                    heritageClauses = result.list;
+                    TypeScript.Debug.assert(result.skippedTokens.length === 0);
+                }
+
+                return heritageClauses;
+            };
+
+            ParserImpl.prototype.parseClassDeclaration = function () {
+                var modifiers = this.parseModifiers();
+
+                var classKeyword = this.eatKeyword(44 /* ClassKeyword */);
+                var identifier = this.eatIdentifierToken();
+                var typeParameterList = this.parseOptionalTypeParameterList(false);
+                var heritageClauses = this.parseHeritageClauses();
+                var openBraceToken = this.eatToken(70 /* OpenBraceToken */);
+                var classElements = TypeScript.Syntax.emptyList;
+
+                if (openBraceToken.width() > 0) {
+                    var result = this.parseSyntaxList(2 /* ClassDeclaration_ClassElements */);
+
+                    classElements = result.list;
+                    openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens);
+                }
+
+                var closeBraceToken = this.eatToken(71 /* CloseBraceToken */);
+                return this.factory.classDeclaration(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken);
+            };
+
+            ParserImpl.isPublicOrPrivateKeyword = function (token) {
+                return token.tokenKind === 57 /* PublicKeyword */ || token.tokenKind === 55 /* PrivateKeyword */;
+            };
+
+            ParserImpl.prototype.isAccessor = function (inErrorRecovery) {
+                var index = this.modifierCount();
+
+                if (this.peekToken(index).tokenKind !== 64 /* GetKeyword */ && this.peekToken(index).tokenKind !== 68 /* SetKeyword */) {
+                    return false;
+                }
+
+                index++;
+                return this.isPropertyName(this.peekToken(index), inErrorRecovery);
+            };
+
+            ParserImpl.prototype.parseAccessor = function (checkForStrictMode) {
+                var modifiers = this.parseModifiers();
+
+                if (this.currentToken().tokenKind === 64 /* GetKeyword */) {
+                    return this.parseGetMemberAccessorDeclaration(modifiers, checkForStrictMode);
+                } else if (this.currentToken().tokenKind === 68 /* SetKeyword */) {
+                    return this.parseSetMemberAccessorDeclaration(modifiers, checkForStrictMode);
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.parseGetMemberAccessorDeclaration = function (modifiers, checkForStrictMode) {
+                var getKeyword = this.eatKeyword(64 /* GetKeyword */);
+                var propertyName = this.eatPropertyName();
+                var parameterList = this.parseParameterList();
+                var typeAnnotation = this.parseOptionalTypeAnnotation(false);
+                var block = this.parseBlock(false, checkForStrictMode);
+
+                return this.factory.getAccessor(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block);
+            };
+
+            ParserImpl.prototype.parseSetMemberAccessorDeclaration = function (modifiers, checkForStrictMode) {
+                var setKeyword = this.eatKeyword(68 /* SetKeyword */);
+                var propertyName = this.eatPropertyName();
+                var parameterList = this.parseParameterList();
+                var block = this.parseBlock(false, checkForStrictMode);
+
+                return this.factory.setAccessor(modifiers, setKeyword, propertyName, parameterList, block);
+            };
+
+            ParserImpl.prototype.isClassElement = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isClassElement()) {
+                    return true;
+                }
+
+                return this.isConstructorDeclaration() || this.isMemberFunctionDeclaration(inErrorRecovery) || this.isAccessor(inErrorRecovery) || this.isMemberVariableDeclaration(inErrorRecovery) || this.isIndexMemberDeclaration();
+            };
+
+            ParserImpl.prototype.parseClassElement = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isClassElement()) {
+                    return this.eatNode();
+                }
+
+                if (this.isConstructorDeclaration()) {
+                    return this.parseConstructorDeclaration();
+                } else if (this.isMemberFunctionDeclaration(inErrorRecovery)) {
+                    return this.parseMemberFunctionDeclaration();
+                } else if (this.isAccessor(inErrorRecovery)) {
+                    return this.parseAccessor(false);
+                } else if (this.isMemberVariableDeclaration(inErrorRecovery)) {
+                    return this.parseMemberVariableDeclaration();
+                } else if (this.isIndexMemberDeclaration()) {
+                    return this.parseIndexMemberDeclaration();
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.isConstructorDeclaration = function () {
+                var index = this.modifierCount();
+                return this.peekToken(index).tokenKind === 62 /* ConstructorKeyword */;
+            };
+
+            ParserImpl.prototype.parseConstructorDeclaration = function () {
+                var modifiers = this.parseModifiers();
+                var constructorKeyword = this.eatKeyword(62 /* ConstructorKeyword */);
+                var callSignature = this.parseCallSignature(false);
+
+                var semicolonToken = null;
+                var block = null;
+
+                if (this.isBlock()) {
+                    block = this.parseBlock(false, true);
+                } else {
+                    semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+                }
+
+                return this.factory.constructorDeclaration(modifiers, constructorKeyword, callSignature, block, semicolonToken);
+            };
+
+            ParserImpl.prototype.isMemberFunctionDeclaration = function (inErrorRecovery) {
+                var index = 0;
+
+                while (true) {
+                    var token = this.peekToken(index);
+                    if (this.isPropertyName(token, inErrorRecovery) && this.isCallSignature(index + 1)) {
+                        return true;
+                    }
+
+                    if (ParserImpl.isModifier(token)) {
+                        index++;
+                        continue;
+                    }
+
+                    return false;
+                }
+            };
+
+            ParserImpl.prototype.parseMemberFunctionDeclaration = function () {
+                var modifierArray = this.getArray();
+
+                while (true) {
+                    var currentToken = this.currentToken();
+                    if (this.isPropertyName(currentToken, false) && this.isCallSignature(1)) {
+                        break;
+                    }
+
+                    TypeScript.Debug.assert(ParserImpl.isModifier(currentToken));
+                    modifierArray.push(this.eatAnyToken());
+                }
+
+                var modifiers = TypeScript.Syntax.list(modifierArray);
+                this.returnZeroOrOneLengthArray(modifierArray);
+
+                var propertyName = this.eatPropertyName();
+                var callSignature = this.parseCallSignature(false);
+
+                var parseBlockEvenWithNoOpenBrace = false;
+                var newCallSignature = this.tryAddUnexpectedEqualsGreaterThanToken(callSignature);
+                if (newCallSignature !== callSignature) {
+                    parseBlockEvenWithNoOpenBrace = true;
+                    callSignature = newCallSignature;
+                }
+
+                var block = null;
+                var semicolon = null;
+
+                if (parseBlockEvenWithNoOpenBrace || this.isBlock()) {
+                    block = this.parseBlock(parseBlockEvenWithNoOpenBrace, true);
+                } else {
+                    semicolon = this.eatExplicitOrAutomaticSemicolon(false);
+                }
+
+                return this.factory.memberFunctionDeclaration(modifiers, propertyName, callSignature, block, semicolon);
+            };
+
+            ParserImpl.prototype.isDefinitelyMemberVariablePropertyName = function (index) {
+                if (TypeScript.SyntaxFacts.isAnyKeyword(this.peekToken(index).tokenKind)) {
+                    switch (this.peekToken(index + 1).tokenKind) {
+                        case 78 /* SemicolonToken */:
+                        case 107 /* EqualsToken */:
+                        case 106 /* ColonToken */:
+                        case 71 /* CloseBraceToken */:
+                        case 10 /* EndOfFileToken */:
+                            return true;
+                        default:
+                            return false;
+                    }
+                } else {
+                    return true;
+                }
+            };
+
+            ParserImpl.prototype.isMemberVariableDeclaration = function (inErrorRecovery) {
+                var index = 0;
+
+                while (true) {
+                    var token = this.peekToken(index);
+                    if (this.isPropertyName(token, inErrorRecovery) && this.isDefinitelyMemberVariablePropertyName(index)) {
+                        return true;
+                    }
+
+                    if (ParserImpl.isModifier(this.peekToken(index))) {
+                        index++;
+                        continue;
+                    }
+
+                    return false;
+                }
+            };
+
+            ParserImpl.prototype.parseMemberVariableDeclaration = function () {
+                var modifierArray = this.getArray();
+
+                while (true) {
+                    var currentToken = this.currentToken();
+                    if (this.isPropertyName(currentToken, false) && this.isDefinitelyMemberVariablePropertyName(0)) {
+                        break;
+                    }
+
+                    TypeScript.Debug.assert(ParserImpl.isModifier(currentToken));
+                    modifierArray.push(this.eatAnyToken());
+                }
+
+                var modifiers = TypeScript.Syntax.list(modifierArray);
+                this.returnZeroOrOneLengthArray(modifierArray);
+
+                var variableDeclarator = this.parseVariableDeclarator(true, true);
+                var semicolon = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.memberVariableDeclaration(modifiers, variableDeclarator, semicolon);
+            };
+
+            ParserImpl.prototype.isIndexMemberDeclaration = function () {
+                var index = this.modifierCount();
+                return this.isIndexSignature(index);
+            };
+
+            ParserImpl.prototype.parseIndexMemberDeclaration = function () {
+                var modifiers = this.parseModifiers();
+                var indexSignature = this.parseIndexSignature();
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.indexMemberDeclaration(modifiers, indexSignature, semicolonToken);
+            };
+
+            ParserImpl.prototype.tryAddUnexpectedEqualsGreaterThanToken = function (callSignature) {
+                var token0 = this.currentToken();
+
+                var hasEqualsGreaterThanToken = token0.tokenKind === 85 /* EqualsGreaterThanToken */;
+                if (hasEqualsGreaterThanToken) {
+                    if (callSignature.lastToken()) {
+                        var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token0.width(), TypeScript.DiagnosticCode.Unexpected_token_0_expected, [TypeScript.SyntaxFacts.getText(70 /* OpenBraceToken */)]);
+                        this.addDiagnostic(diagnostic);
+
+                        var token = this.eatAnyToken();
+                        return this.addSkippedTokenAfterNode(callSignature, token0);
+                    }
+                }
+
+                return callSignature;
+            };
+
+            ParserImpl.prototype.isFunctionDeclaration = function () {
+                var index = this.modifierCount();
+                return this.peekToken(index).tokenKind === 27 /* FunctionKeyword */;
+            };
+
+            ParserImpl.prototype.parseFunctionDeclaration = function () {
+                var modifiers = this.parseModifiers();
+                var functionKeyword = this.eatKeyword(27 /* FunctionKeyword */);
+                var identifier = this.eatIdentifierToken();
+                var callSignature = this.parseCallSignature(false);
+
+                var parseBlockEvenWithNoOpenBrace = false;
+                var newCallSignature = this.tryAddUnexpectedEqualsGreaterThanToken(callSignature);
+                if (newCallSignature !== callSignature) {
+                    parseBlockEvenWithNoOpenBrace = true;
+                    callSignature = newCallSignature;
+                }
+
+                var semicolonToken = null;
+                var block = null;
+
+                if (parseBlockEvenWithNoOpenBrace || this.isBlock()) {
+                    block = this.parseBlock(parseBlockEvenWithNoOpenBrace, true);
+                } else {
+                    semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+                }
+
+                return this.factory.functionDeclaration(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken);
+            };
+
+            ParserImpl.prototype.isModuleDeclaration = function (modifierCount) {
+                if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 65 /* ModuleKeyword */) {
+                    return true;
+                }
+
+                if (this.currentToken().tokenKind === 65 /* ModuleKeyword */) {
+                    var token1 = this.peekToken(1);
+                    return this.isIdentifier(token1) || token1.tokenKind === 14 /* StringLiteral */;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.parseModuleDeclaration = function () {
+                var modifiers = this.parseModifiers();
+                var moduleKeyword = this.eatKeyword(65 /* ModuleKeyword */);
+
+                var moduleName = null;
+                var stringLiteral = null;
+
+                if (this.currentToken().tokenKind === 14 /* StringLiteral */) {
+                    stringLiteral = this.eatToken(14 /* StringLiteral */);
+                } else {
+                    moduleName = this.parseName();
+                }
+
+                var openBraceToken = this.eatToken(70 /* OpenBraceToken */);
+
+                var moduleElements = TypeScript.Syntax.emptyList;
+                if (openBraceToken.width() > 0) {
+                    var result = this.parseSyntaxList(4 /* ModuleDeclaration_ModuleElements */);
+                    moduleElements = result.list;
+                    openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens);
+                }
+
+                var closeBraceToken = this.eatToken(71 /* CloseBraceToken */);
+
+                return this.factory.moduleDeclaration(modifiers, moduleKeyword, moduleName, stringLiteral, openBraceToken, moduleElements, closeBraceToken);
+            };
+
+            ParserImpl.prototype.isInterfaceDeclaration = function (modifierCount) {
+                if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 52 /* InterfaceKeyword */) {
+                    return true;
+                }
+
+                return this.currentToken().tokenKind === 52 /* InterfaceKeyword */ && this.isIdentifier(this.peekToken(1));
+            };
+
+            ParserImpl.prototype.parseInterfaceDeclaration = function () {
+                var modifiers = this.parseModifiers();
+                var interfaceKeyword = this.eatKeyword(52 /* InterfaceKeyword */);
+                var identifier = this.eatIdentifierToken();
+                var typeParameterList = this.parseOptionalTypeParameterList(false);
+                var heritageClauses = this.parseHeritageClauses();
+
+                var objectType = this.parseObjectType();
+                return this.factory.interfaceDeclaration(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, objectType);
+            };
+
+            ParserImpl.prototype.parseObjectType = function () {
+                var openBraceToken = this.eatToken(70 /* OpenBraceToken */);
+
+                var typeMembers = TypeScript.Syntax.emptySeparatedList;
+                if (openBraceToken.width() > 0) {
+                    var result = this.parseSeparatedSyntaxList(512 /* ObjectType_TypeMembers */);
+                    typeMembers = result.list;
+                    openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens);
+                }
+
+                var closeBraceToken = this.eatToken(71 /* CloseBraceToken */);
+                return this.factory.objectType(openBraceToken, typeMembers, closeBraceToken);
+            };
+
+            ParserImpl.prototype.isTypeMember = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isTypeMember()) {
+                    return true;
+                }
+
+                return this.isCallSignature(0) || this.isConstructSignature() || this.isIndexSignature(0) || this.isMethodSignature(inErrorRecovery) || this.isPropertySignature(inErrorRecovery);
+            };
+
+            ParserImpl.prototype.parseTypeMember = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isTypeMember()) {
+                    return this.eatNode();
+                }
+
+                if (this.isCallSignature(0)) {
+                    return this.parseCallSignature(false);
+                } else if (this.isConstructSignature()) {
+                    return this.parseConstructSignature();
+                } else if (this.isIndexSignature(0)) {
+                    return this.parseIndexSignature();
+                } else if (this.isMethodSignature(inErrorRecovery)) {
+                    return this.parseMethodSignature();
+                } else if (this.isPropertySignature(inErrorRecovery)) {
+                    return this.parsePropertySignature();
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.parseConstructSignature = function () {
+                var newKeyword = this.eatKeyword(31 /* NewKeyword */);
+                var callSignature = this.parseCallSignature(false);
+
+                return this.factory.constructSignature(newKeyword, callSignature);
+            };
+
+            ParserImpl.prototype.parseIndexSignature = function () {
+                var openBracketToken = this.eatToken(74 /* OpenBracketToken */);
+                var parameter = this.parseParameter();
+                var closeBracketToken = this.eatToken(75 /* CloseBracketToken */);
+                var typeAnnotation = this.parseOptionalTypeAnnotation(false);
+
+                return this.factory.indexSignature(openBracketToken, parameter, closeBracketToken, typeAnnotation);
+            };
+
+            ParserImpl.prototype.parseMethodSignature = function () {
+                var propertyName = this.eatPropertyName();
+                var questionToken = this.tryEatToken(105 /* QuestionToken */);
+                var callSignature = this.parseCallSignature(false);
+
+                return this.factory.methodSignature(propertyName, questionToken, callSignature);
+            };
+
+            ParserImpl.prototype.parsePropertySignature = function () {
+                var propertyName = this.eatPropertyName();
+                var questionToken = this.tryEatToken(105 /* QuestionToken */);
+                var typeAnnotation = this.parseOptionalTypeAnnotation(false);
+
+                return this.factory.propertySignature(propertyName, questionToken, typeAnnotation);
+            };
+
+            ParserImpl.prototype.isCallSignature = function (tokenIndex) {
+                var tokenKind = this.peekToken(tokenIndex).tokenKind;
+                return tokenKind === 72 /* OpenParenToken */ || tokenKind === 80 /* LessThanToken */;
+            };
+
+            ParserImpl.prototype.isConstructSignature = function () {
+                if (this.currentToken().tokenKind !== 31 /* NewKeyword */) {
+                    return false;
+                }
+
+                var token1 = this.peekToken(1);
+                return token1.tokenKind === 80 /* LessThanToken */ || token1.tokenKind === 72 /* OpenParenToken */;
+            };
+
+            ParserImpl.prototype.isIndexSignature = function (tokenIndex) {
+                return this.peekToken(tokenIndex).tokenKind === 74 /* OpenBracketToken */;
+            };
+
+            ParserImpl.prototype.isMethodSignature = function (inErrorRecovery) {
+                if (this.isPropertyName(this.currentToken(), inErrorRecovery)) {
+                    if (this.isCallSignature(1)) {
+                        return true;
+                    }
+
+                    if (this.peekToken(1).tokenKind === 105 /* QuestionToken */ && this.isCallSignature(2)) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isPropertySignature = function (inErrorRecovery) {
+                var currentToken = this.currentToken();
+
+                if (ParserImpl.isModifier(currentToken) && !currentToken.hasTrailingNewLine() && this.isPropertyName(this.peekToken(1), inErrorRecovery)) {
+                    return false;
+                }
+
+                return this.isPropertyName(currentToken, inErrorRecovery);
+            };
+
+            ParserImpl.prototype.isHeritageClause = function () {
+                var token0 = this.currentToken();
+                return token0.tokenKind === 48 /* ExtendsKeyword */ || token0.tokenKind === 51 /* ImplementsKeyword */;
+            };
+
+            ParserImpl.prototype.isNotHeritageClauseTypeName = function () {
+                if (this.currentToken().tokenKind === 51 /* ImplementsKeyword */ || this.currentToken().tokenKind === 48 /* ExtendsKeyword */) {
+                    return this.isIdentifier(this.peekToken(1));
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isHeritageClauseTypeName = function () {
+                if (this.isIdentifier(this.currentToken())) {
+                    return !this.isNotHeritageClauseTypeName();
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.parseHeritageClause = function () {
+                var extendsOrImplementsKeyword = this.eatAnyToken();
+                TypeScript.Debug.assert(extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */ || extendsOrImplementsKeyword.tokenKind === 51 /* ImplementsKeyword */);
+
+                var result = this.parseSeparatedSyntaxList(2048 /* HeritageClause_TypeNameList */);
+                var typeNames = result.list;
+                extendsOrImplementsKeyword = this.addSkippedTokensAfterToken(extendsOrImplementsKeyword, result.skippedTokens);
+
+                return this.factory.heritageClause(extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */ ? 230 /* ExtendsHeritageClause */ : 231 /* ImplementsHeritageClause */, extendsOrImplementsKeyword, typeNames);
+            };
+
+            ParserImpl.prototype.isStatement = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isStatement()) {
+                    return true;
+                }
+
+                var currentToken = this.currentToken();
+                var currentTokenKind = currentToken.tokenKind;
+                switch (currentTokenKind) {
+                    case 57 /* PublicKeyword */:
+                    case 55 /* PrivateKeyword */:
+                    case 58 /* StaticKeyword */:
+                        var token1 = this.peekToken(1);
+                        if (TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token1)) {
+                            return false;
+                        }
+
+                        break;
+
+                    case 28 /* IfKeyword */:
+                    case 70 /* OpenBraceToken */:
+                    case 33 /* ReturnKeyword */:
+                    case 34 /* SwitchKeyword */:
+                    case 36 /* ThrowKeyword */:
+                    case 15 /* BreakKeyword */:
+                    case 18 /* ContinueKeyword */:
+                    case 26 /* ForKeyword */:
+                    case 42 /* WhileKeyword */:
+                    case 43 /* WithKeyword */:
+                    case 22 /* DoKeyword */:
+                    case 38 /* TryKeyword */:
+                    case 19 /* DebuggerKeyword */:
+                        return true;
+                }
+
+                if (this.isInterfaceDeclaration(0) || this.isClassDeclaration(0) || this.isEnumDeclaration(0) || this.isModuleDeclaration(0)) {
+                    return false;
+                }
+
+                return this.isLabeledStatement(currentToken) || this.isVariableStatement() || this.isFunctionDeclaration() || this.isEmptyStatement(currentToken, inErrorRecovery) || this.isExpressionStatement(currentToken);
+            };
+
+            ParserImpl.prototype.parseStatement = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isStatement()) {
+                    return this.eatNode();
+                }
+
+                var currentToken = this.currentToken();
+                var currentTokenKind = currentToken.tokenKind;
+
+                switch (currentTokenKind) {
+                    case 28 /* IfKeyword */:
+                        return this.parseIfStatement();
+                    case 70 /* OpenBraceToken */:
+                        return this.parseBlock(false, false);
+                    case 33 /* ReturnKeyword */:
+                        return this.parseReturnStatement();
+                    case 34 /* SwitchKeyword */:
+                        return this.parseSwitchStatement();
+                    case 36 /* ThrowKeyword */:
+                        return this.parseThrowStatement();
+                    case 15 /* BreakKeyword */:
+                        return this.parseBreakStatement();
+                    case 18 /* ContinueKeyword */:
+                        return this.parseContinueStatement();
+                    case 26 /* ForKeyword */:
+                        return this.parseForOrForInStatement();
+                    case 42 /* WhileKeyword */:
+                        return this.parseWhileStatement();
+                    case 43 /* WithKeyword */:
+                        return this.parseWithStatement();
+                    case 22 /* DoKeyword */:
+                        return this.parseDoStatement();
+                    case 38 /* TryKeyword */:
+                        return this.parseTryStatement();
+                    case 19 /* DebuggerKeyword */:
+                        return this.parseDebuggerStatement();
+                }
+
+                if (this.isVariableStatement()) {
+                    return this.parseVariableStatement();
+                } else if (this.isLabeledStatement(currentToken)) {
+                    return this.parseLabeledStatement();
+                } else if (this.isFunctionDeclaration()) {
+                    return this.parseFunctionDeclaration();
+                } else if (this.isEmptyStatement(currentToken, inErrorRecovery)) {
+                    return this.parseEmptyStatement();
+                } else {
+                    return this.parseExpressionStatement();
+                }
+            };
+
+            ParserImpl.prototype.parseDebuggerStatement = function () {
+                var debuggerKeyword = this.eatKeyword(19 /* DebuggerKeyword */);
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.debuggerStatement(debuggerKeyword, semicolonToken);
+            };
+
+            ParserImpl.prototype.parseDoStatement = function () {
+                var doKeyword = this.eatKeyword(22 /* DoKeyword */);
+                var statement = this.parseStatement(false);
+                var whileKeyword = this.eatKeyword(42 /* WhileKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var condition = this.parseExpression(true);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(true);
+
+                return this.factory.doStatement(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken);
+            };
+
+            ParserImpl.prototype.isLabeledStatement = function (currentToken) {
+                return this.isIdentifier(currentToken) && this.peekToken(1).tokenKind === 106 /* ColonToken */;
+            };
+
+            ParserImpl.prototype.parseLabeledStatement = function () {
+                var identifier = this.eatIdentifierToken();
+                var colonToken = this.eatToken(106 /* ColonToken */);
+                var statement = this.parseStatement(false);
+
+                return this.factory.labeledStatement(identifier, colonToken, statement);
+            };
+
+            ParserImpl.prototype.parseTryStatement = function () {
+                var tryKeyword = this.eatKeyword(38 /* TryKeyword */);
+
+                var savedListParsingState = this.listParsingState;
+                this.listParsingState |= 64 /* TryBlock_Statements */;
+                var block = this.parseBlock(false, false);
+                this.listParsingState = savedListParsingState;
+
+                var catchClause = null;
+                if (this.isCatchClause()) {
+                    catchClause = this.parseCatchClause();
+                }
+
+                var finallyClause = null;
+                if (catchClause === null || this.isFinallyClause()) {
+                    finallyClause = this.parseFinallyClause();
+                }
+
+                return this.factory.tryStatement(tryKeyword, block, catchClause, finallyClause);
+            };
+
+            ParserImpl.prototype.isCatchClause = function () {
+                return this.currentToken().tokenKind === 17 /* CatchKeyword */;
+            };
+
+            ParserImpl.prototype.parseCatchClause = function () {
+                var catchKeyword = this.eatKeyword(17 /* CatchKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var identifier = this.eatIdentifierToken();
+                var typeAnnotation = this.parseOptionalTypeAnnotation(false);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+
+                var savedListParsingState = this.listParsingState;
+                this.listParsingState |= 128 /* CatchBlock_Statements */;
+                var block = this.parseBlock(false, false);
+                this.listParsingState = savedListParsingState;
+
+                return this.factory.catchClause(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block);
+            };
+
+            ParserImpl.prototype.isFinallyClause = function () {
+                return this.currentToken().tokenKind === 25 /* FinallyKeyword */;
+            };
+
+            ParserImpl.prototype.parseFinallyClause = function () {
+                var finallyKeyword = this.eatKeyword(25 /* FinallyKeyword */);
+                var block = this.parseBlock(false, false);
+
+                return this.factory.finallyClause(finallyKeyword, block);
+            };
+
+            ParserImpl.prototype.parseWithStatement = function () {
+                var withKeyword = this.eatKeyword(43 /* WithKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var condition = this.parseExpression(true);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+                var statement = this.parseStatement(false);
+
+                return this.factory.withStatement(withKeyword, openParenToken, condition, closeParenToken, statement);
+            };
+
+            ParserImpl.prototype.parseWhileStatement = function () {
+                var whileKeyword = this.eatKeyword(42 /* WhileKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var condition = this.parseExpression(true);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+                var statement = this.parseStatement(false);
+
+                return this.factory.whileStatement(whileKeyword, openParenToken, condition, closeParenToken, statement);
+            };
+
+            ParserImpl.prototype.isEmptyStatement = function (currentToken, inErrorRecovery) {
+                if (inErrorRecovery) {
+                    return false;
+                }
+
+                return currentToken.tokenKind === 78 /* SemicolonToken */;
+            };
+
+            ParserImpl.prototype.parseEmptyStatement = function () {
+                var semicolonToken = this.eatToken(78 /* SemicolonToken */);
+                return this.factory.emptyStatement(semicolonToken);
+            };
+
+            ParserImpl.prototype.parseForOrForInStatement = function () {
+                var forKeyword = this.eatKeyword(26 /* ForKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+
+                var currentToken = this.currentToken();
+                if (currentToken.tokenKind === 40 /* VarKeyword */) {
+                    return this.parseForOrForInStatementWithVariableDeclaration(forKeyword, openParenToken);
+                } else if (currentToken.tokenKind === 78 /* SemicolonToken */) {
+                    return this.parseForStatementWithNoVariableDeclarationOrInitializer(forKeyword, openParenToken);
+                } else {
+                    return this.parseForOrForInStatementWithInitializer(forKeyword, openParenToken);
+                }
+            };
+
+            ParserImpl.prototype.parseForOrForInStatementWithVariableDeclaration = function (forKeyword, openParenToken) {
+                var variableDeclaration = this.parseVariableDeclaration(false);
+
+                if (this.currentToken().tokenKind === 29 /* InKeyword */) {
+                    return this.parseForInStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, variableDeclaration, null);
+                }
+
+                return this.parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, variableDeclaration, null);
+            };
+
+            ParserImpl.prototype.parseForInStatementWithVariableDeclarationOrInitializer = function (forKeyword, openParenToken, variableDeclaration, initializer) {
+                var inKeyword = this.eatKeyword(29 /* InKeyword */);
+                var expression = this.parseExpression(true);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+                var statement = this.parseStatement(false);
+
+                return this.factory.forInStatement(forKeyword, openParenToken, variableDeclaration, initializer, inKeyword, expression, closeParenToken, statement);
+            };
+
+            ParserImpl.prototype.parseForOrForInStatementWithInitializer = function (forKeyword, openParenToken) {
+                var initializer = this.parseExpression(false);
+                if (this.currentToken().tokenKind === 29 /* InKeyword */) {
+                    return this.parseForInStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, null, initializer);
+                } else {
+                    return this.parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, null, initializer);
+                }
+            };
+
+            ParserImpl.prototype.parseForStatementWithNoVariableDeclarationOrInitializer = function (forKeyword, openParenToken) {
+                return this.parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, null, null);
+            };
+
+            ParserImpl.prototype.parseForStatementWithVariableDeclarationOrInitializer = function (forKeyword, openParenToken, variableDeclaration, initializer) {
+                var firstSemicolonToken = this.eatToken(78 /* SemicolonToken */);
+
+                var condition = null;
+                if (this.currentToken().tokenKind !== 78 /* SemicolonToken */ && this.currentToken().tokenKind !== 73 /* CloseParenToken */ && this.currentToken().tokenKind !== 10 /* EndOfFileToken */) {
+                    condition = this.parseExpression(true);
+                }
+
+                var secondSemicolonToken = this.eatToken(78 /* SemicolonToken */);
+
+                var incrementor = null;
+                if (this.currentToken().tokenKind !== 73 /* CloseParenToken */ && this.currentToken().tokenKind !== 10 /* EndOfFileToken */) {
+                    incrementor = this.parseExpression(true);
+                }
+
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+                var statement = this.parseStatement(false);
+
+                return this.factory.forStatement(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement);
+            };
+
+            ParserImpl.prototype.parseBreakStatement = function () {
+                var breakKeyword = this.eatKeyword(15 /* BreakKeyword */);
+
+                var identifier = null;
+                if (!this.canEatExplicitOrAutomaticSemicolon(false)) {
+                    if (this.isIdentifier(this.currentToken())) {
+                        identifier = this.eatIdentifierToken();
+                    }
+                }
+
+                var semicolon = this.eatExplicitOrAutomaticSemicolon(false);
+                return this.factory.breakStatement(breakKeyword, identifier, semicolon);
+            };
+
+            ParserImpl.prototype.parseContinueStatement = function () {
+                var continueKeyword = this.eatKeyword(18 /* ContinueKeyword */);
+
+                var identifier = null;
+                if (!this.canEatExplicitOrAutomaticSemicolon(false)) {
+                    if (this.isIdentifier(this.currentToken())) {
+                        identifier = this.eatIdentifierToken();
+                    }
+                }
+
+                var semicolon = this.eatExplicitOrAutomaticSemicolon(false);
+                return this.factory.continueStatement(continueKeyword, identifier, semicolon);
+            };
+
+            ParserImpl.prototype.parseSwitchStatement = function () {
+                var switchKeyword = this.eatKeyword(34 /* SwitchKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var expression = this.parseExpression(true);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+
+                var openBraceToken = this.eatToken(70 /* OpenBraceToken */);
+
+                var switchClauses = TypeScript.Syntax.emptyList;
+                if (openBraceToken.width() > 0) {
+                    var result = this.parseSyntaxList(8 /* SwitchStatement_SwitchClauses */);
+                    switchClauses = result.list;
+                    openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens);
+                }
+
+                var closeBraceToken = this.eatToken(71 /* CloseBraceToken */);
+                return this.factory.switchStatement(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken);
+            };
+
+            ParserImpl.prototype.isCaseSwitchClause = function () {
+                return this.currentToken().tokenKind === 16 /* CaseKeyword */;
+            };
+
+            ParserImpl.prototype.isDefaultSwitchClause = function () {
+                return this.currentToken().tokenKind === 20 /* DefaultKeyword */;
+            };
+
+            ParserImpl.prototype.isSwitchClause = function () {
+                if (this.currentNode() !== null && this.currentNode().isSwitchClause()) {
+                    return true;
+                }
+
+                return this.isCaseSwitchClause() || this.isDefaultSwitchClause();
+            };
+
+            ParserImpl.prototype.parseSwitchClause = function () {
+                if (this.currentNode() !== null && this.currentNode().isSwitchClause()) {
+                    return this.eatNode();
+                }
+
+                if (this.isCaseSwitchClause()) {
+                    return this.parseCaseSwitchClause();
+                } else if (this.isDefaultSwitchClause()) {
+                    return this.parseDefaultSwitchClause();
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.parseCaseSwitchClause = function () {
+                var caseKeyword = this.eatKeyword(16 /* CaseKeyword */);
+                var expression = this.parseExpression(true);
+                var colonToken = this.eatToken(106 /* ColonToken */);
+                var statements = TypeScript.Syntax.emptyList;
+
+                if (colonToken.fullWidth() > 0) {
+                    var result = this.parseSyntaxList(16 /* SwitchClause_Statements */);
+                    statements = result.list;
+                    colonToken = this.addSkippedTokensAfterToken(colonToken, result.skippedTokens);
+                }
+
+                return this.factory.caseSwitchClause(caseKeyword, expression, colonToken, statements);
+            };
+
+            ParserImpl.prototype.parseDefaultSwitchClause = function () {
+                var defaultKeyword = this.eatKeyword(20 /* DefaultKeyword */);
+                var colonToken = this.eatToken(106 /* ColonToken */);
+                var statements = TypeScript.Syntax.emptyList;
+
+                if (colonToken.fullWidth() > 0) {
+                    var result = this.parseSyntaxList(16 /* SwitchClause_Statements */);
+                    statements = result.list;
+                    colonToken = this.addSkippedTokensAfterToken(colonToken, result.skippedTokens);
+                }
+
+                return this.factory.defaultSwitchClause(defaultKeyword, colonToken, statements);
+            };
+
+            ParserImpl.prototype.parseThrowStatement = function () {
+                var throwKeyword = this.eatKeyword(36 /* ThrowKeyword */);
+
+                var expression = null;
+                if (this.canEatExplicitOrAutomaticSemicolon(false)) {
+                    var token = this.createMissingToken(11 /* IdentifierName */, null);
+                    expression = token;
+                } else {
+                    expression = this.parseExpression(true);
+                }
+
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.throwStatement(throwKeyword, expression, semicolonToken);
+            };
+
+            ParserImpl.prototype.parseReturnStatement = function () {
+                var returnKeyword = this.eatKeyword(33 /* ReturnKeyword */);
+
+                var expression = null;
+                if (!this.canEatExplicitOrAutomaticSemicolon(false)) {
+                    expression = this.parseExpression(true);
+                }
+
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.returnStatement(returnKeyword, expression, semicolonToken);
+            };
+
+            ParserImpl.prototype.isExpressionStatement = function (currentToken) {
+                var kind = currentToken.tokenKind;
+                if (kind === 70 /* OpenBraceToken */ || kind === 27 /* FunctionKeyword */) {
+                    return false;
+                }
+
+                return this.isExpression(currentToken);
+            };
+
+            ParserImpl.prototype.isAssignmentOrOmittedExpression = function () {
+                var currentToken = this.currentToken();
+                if (currentToken.tokenKind === 79 /* CommaToken */) {
+                    return true;
+                }
+
+                return this.isExpression(currentToken);
+            };
+
+            ParserImpl.prototype.parseAssignmentOrOmittedExpression = function () {
+                if (this.currentToken().tokenKind === 79 /* CommaToken */) {
+                    return this.factory.omittedExpression();
+                }
+
+                return this.parseAssignmentExpression(true);
+            };
+
+            ParserImpl.prototype.isExpression = function (currentToken) {
+                switch (currentToken.tokenKind) {
+                    case 13 /* NumericLiteral */:
+                    case 14 /* StringLiteral */:
+                    case 12 /* RegularExpressionLiteral */:
+
+                    case 74 /* OpenBracketToken */:
+
+                    case 72 /* OpenParenToken */:
+
+                    case 80 /* LessThanToken */:
+
+                    case 93 /* PlusPlusToken */:
+                    case 94 /* MinusMinusToken */:
+                    case 89 /* PlusToken */:
+                    case 90 /* MinusToken */:
+                    case 102 /* TildeToken */:
+                    case 101 /* ExclamationToken */:
+
+                    case 70 /* OpenBraceToken */:
+
+                    case 85 /* EqualsGreaterThanToken */:
+
+                    case 118 /* SlashToken */:
+                    case 119 /* SlashEqualsToken */:
+
+                    case 50 /* SuperKeyword */:
+                    case 35 /* ThisKeyword */:
+                    case 37 /* TrueKeyword */:
+                    case 24 /* FalseKeyword */:
+                    case 32 /* NullKeyword */:
+
+                    case 31 /* NewKeyword */:
+
+                    case 21 /* DeleteKeyword */:
+                    case 41 /* VoidKeyword */:
+                    case 39 /* TypeOfKeyword */:
+
+                    case 27 /* FunctionKeyword */:
+                        return true;
+                }
+
+                return this.isIdentifier(currentToken);
+            };
+
+            ParserImpl.prototype.parseExpressionStatement = function () {
+                var expression = this.parseExpression(true);
+
+                var semicolon = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.expressionStatement(expression, semicolon);
+            };
+
+            ParserImpl.prototype.parseIfStatement = function () {
+                var ifKeyword = this.eatKeyword(28 /* IfKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var condition = this.parseExpression(true);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+                var statement = this.parseStatement(false);
+
+                var elseClause = null;
+                if (this.isElseClause()) {
+                    elseClause = this.parseElseClause();
+                }
+
+                return this.factory.ifStatement(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause);
+            };
+
+            ParserImpl.prototype.isElseClause = function () {
+                return this.currentToken().tokenKind === 23 /* ElseKeyword */;
+            };
+
+            ParserImpl.prototype.parseElseClause = function () {
+                var elseKeyword = this.eatKeyword(23 /* ElseKeyword */);
+                var statement = this.parseStatement(false);
+
+                return this.factory.elseClause(elseKeyword, statement);
+            };
+
+            ParserImpl.prototype.isVariableStatement = function () {
+                var index = this.modifierCount();
+                return this.peekToken(index).tokenKind === 40 /* VarKeyword */;
+            };
+
+            ParserImpl.prototype.parseVariableStatement = function () {
+                var modifiers = this.parseModifiers();
+                var variableDeclaration = this.parseVariableDeclaration(true);
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.variableStatement(modifiers, variableDeclaration, semicolonToken);
+            };
+
+            ParserImpl.prototype.parseVariableDeclaration = function (allowIn) {
+                var varKeyword = this.eatKeyword(40 /* VarKeyword */);
+
+                var listParsingState = allowIn ? 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */ : 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */;
+
+                var result = this.parseSeparatedSyntaxList(listParsingState);
+                var variableDeclarators = result.list;
+                varKeyword = this.addSkippedTokensAfterToken(varKeyword, result.skippedTokens);
+
+                return this.factory.variableDeclaration(varKeyword, variableDeclarators);
+            };
+
+            ParserImpl.prototype.isVariableDeclarator = function () {
+                if (this.currentNode() !== null && this.currentNode().kind() === 225 /* VariableDeclarator */) {
+                    return true;
+                }
+
+                return this.isIdentifier(this.currentToken());
+            };
+
+            ParserImpl.prototype.canReuseVariableDeclaratorNode = function (node) {
+                if (node === null || node.kind() !== 225 /* VariableDeclarator */) {
+                    return false;
+                }
+
+                var variableDeclarator = node;
+                return variableDeclarator.equalsValueClause === null;
+            };
+
+            ParserImpl.prototype.parseVariableDeclarator = function (allowIn, allowPropertyName) {
+                if (this.canReuseVariableDeclaratorNode(this.currentNode())) {
+                    return this.eatNode();
+                }
+
+                var propertyName = allowPropertyName ? this.eatPropertyName() : this.eatIdentifierToken();
+                var equalsValueClause = null;
+                var typeAnnotation = null;
+
+                if (propertyName.width() > 0) {
+                    typeAnnotation = this.parseOptionalTypeAnnotation(false);
+
+                    if (this.isEqualsValueClause(false)) {
+                        equalsValueClause = this.parseEqualsValueClause(allowIn);
+                    }
+                }
+
+                return this.factory.variableDeclarator(propertyName, typeAnnotation, equalsValueClause);
+            };
+
+            ParserImpl.prototype.isColonValueClause = function () {
+                return this.currentToken().tokenKind === 106 /* ColonToken */;
+            };
+
+            ParserImpl.prototype.isEqualsValueClause = function (inParameter) {
+                var token0 = this.currentToken();
+                if (token0.tokenKind === 107 /* EqualsToken */) {
+                    return true;
+                }
+
+                if (!this.previousToken().hasTrailingNewLine()) {
+                    if (token0.tokenKind === 85 /* EqualsGreaterThanToken */) {
+                        return false;
+                    }
+
+                    if (token0.tokenKind === 70 /* OpenBraceToken */ && inParameter) {
+                        return false;
+                    }
+
+                    return this.isExpression(token0);
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.parseEqualsValueClause = function (allowIn) {
+                var equalsToken = this.eatToken(107 /* EqualsToken */);
+                var value = this.parseAssignmentExpression(allowIn);
+
+                return this.factory.equalsValueClause(equalsToken, value);
+            };
+
+            ParserImpl.prototype.parseExpression = function (allowIn) {
+                return this.parseSubExpression(0, allowIn);
+            };
+
+            ParserImpl.prototype.parseAssignmentExpression = function (allowIn) {
+                return this.parseSubExpression(2 /* AssignmentExpressionPrecedence */, allowIn);
+            };
+
+            ParserImpl.prototype.parseUnaryExpressionOrLower = function () {
+                var currentTokenKind = this.currentToken().tokenKind;
+                if (TypeScript.SyntaxFacts.isPrefixUnaryExpressionOperatorToken(currentTokenKind)) {
+                    var operatorKind = TypeScript.SyntaxFacts.getPrefixUnaryExpressionFromOperatorToken(currentTokenKind);
+
+                    var operatorToken = this.eatAnyToken();
+
+                    var operand = this.parseUnaryExpressionOrLower();
+                    return this.factory.prefixUnaryExpression(operatorKind, operatorToken, operand);
+                } else if (currentTokenKind === 39 /* TypeOfKeyword */) {
+                    return this.parseTypeOfExpression();
+                } else if (currentTokenKind === 41 /* VoidKeyword */) {
+                    return this.parseVoidExpression();
+                } else if (currentTokenKind === 21 /* DeleteKeyword */) {
+                    return this.parseDeleteExpression();
+                } else if (currentTokenKind === 80 /* LessThanToken */) {
+                    return this.parseCastExpression();
+                } else {
+                    return this.parsePostfixExpressionOrLower();
+                }
+            };
+
+            ParserImpl.prototype.parseSubExpression = function (precedence, allowIn) {
+                if (precedence <= 2 /* AssignmentExpressionPrecedence */) {
+                    if (this.isSimpleArrowFunctionExpression()) {
+                        return this.parseSimpleArrowFunctionExpression();
+                    }
+
+                    var parethesizedArrowFunction = this.tryParseParenthesizedArrowFunctionExpression();
+                    if (parethesizedArrowFunction !== null) {
+                        return parethesizedArrowFunction;
+                    }
+                }
+
+                var leftOperand = this.parseUnaryExpressionOrLower();
+                return this.parseBinaryOrConditionalExpressions(precedence, allowIn, leftOperand);
+            };
+
+            ParserImpl.prototype.parseBinaryOrConditionalExpressions = function (precedence, allowIn, leftOperand) {
+                while (true) {
+                    var token0 = this.currentToken();
+                    var token0Kind = token0.tokenKind;
+
+                    if (TypeScript.SyntaxFacts.isBinaryExpressionOperatorToken(token0Kind)) {
+                        if (token0Kind === 29 /* InKeyword */ && !allowIn) {
+                            break;
+                        }
+
+                        var mergedToken = this.tryMergeBinaryExpressionTokens();
+                        var tokenKind = mergedToken === null ? token0Kind : mergedToken.syntaxKind;
+
+                        var binaryExpressionKind = TypeScript.SyntaxFacts.getBinaryExpressionFromOperatorToken(tokenKind);
+                        var newPrecedence = ParserImpl.getPrecedence(binaryExpressionKind);
+
+                        if (newPrecedence < precedence) {
+                            break;
+                        }
+
+                        if (newPrecedence === precedence && !this.isRightAssociative(binaryExpressionKind)) {
+                            break;
+                        }
+
+                        var operatorToken = mergedToken === null ? token0 : TypeScript.Syntax.token(mergedToken.syntaxKind).withLeadingTrivia(token0.leadingTrivia()).withTrailingTrivia(this.peekToken(mergedToken.tokenCount - 1).trailingTrivia());
+
+                        var skipCount = mergedToken === null ? 1 : mergedToken.tokenCount;
+                        for (var i = 0; i < skipCount; i++) {
+                            this.eatAnyToken();
+                        }
+
+                        leftOperand = this.factory.binaryExpression(binaryExpressionKind, leftOperand, operatorToken, this.parseSubExpression(newPrecedence, allowIn));
+                        continue;
+                    }
+
+                    if (token0Kind === 105 /* QuestionToken */ && precedence <= 3 /* ConditionalExpressionPrecedence */) {
+                        var questionToken = this.eatToken(105 /* QuestionToken */);
+
+                        var whenTrueExpression = this.parseAssignmentExpression(allowIn);
+                        var colon = this.eatToken(106 /* ColonToken */);
+
+                        var whenFalseExpression = this.parseAssignmentExpression(allowIn);
+                        leftOperand = this.factory.conditionalExpression(leftOperand, questionToken, whenTrueExpression, colon, whenFalseExpression);
+                        continue;
+                    }
+
+                    break;
+                }
+
+                return leftOperand;
+            };
+
+            ParserImpl.prototype.tryMergeBinaryExpressionTokens = function () {
+                var token0 = this.currentToken();
+
+                if (token0.tokenKind === 81 /* GreaterThanToken */ && !token0.hasTrailingTrivia()) {
+                    var storage = this.mergeTokensStorage;
+                    storage[0] = 0 /* None */;
+                    storage[1] = 0 /* None */;
+                    storage[2] = 0 /* None */;
+
+                    for (var i = 0; i < storage.length; i++) {
+                        var nextToken = this.peekToken(i + 1);
+
+                        if (!nextToken.hasLeadingTrivia()) {
+                            storage[i] = nextToken.tokenKind;
+                        }
+
+                        if (nextToken.hasTrailingTrivia()) {
+                            break;
+                        }
+                    }
+
+                    if (storage[0] === 81 /* GreaterThanToken */) {
+                        if (storage[1] === 81 /* GreaterThanToken */) {
+                            if (storage[2] === 107 /* EqualsToken */) {
+                                return { tokenCount: 4, syntaxKind: 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */ };
+                            } else {
+                                return { tokenCount: 3, syntaxKind: 97 /* GreaterThanGreaterThanGreaterThanToken */ };
+                            }
+                        } else if (storage[1] === 107 /* EqualsToken */) {
+                            return { tokenCount: 3, syntaxKind: 113 /* GreaterThanGreaterThanEqualsToken */ };
+                        } else {
+                            return { tokenCount: 2, syntaxKind: 96 /* GreaterThanGreaterThanToken */ };
+                        }
+                    } else if (storage[0] === 107 /* EqualsToken */) {
+                        return { tokenCount: 2, syntaxKind: 83 /* GreaterThanEqualsToken */ };
+                    }
+                }
+
+                return null;
+            };
+
+            ParserImpl.prototype.isRightAssociative = function (expressionKind) {
+                switch (expressionKind) {
+                    case 174 /* AssignmentExpression */:
+                    case 175 /* AddAssignmentExpression */:
+                    case 176 /* SubtractAssignmentExpression */:
+                    case 177 /* MultiplyAssignmentExpression */:
+                    case 178 /* DivideAssignmentExpression */:
+                    case 179 /* ModuloAssignmentExpression */:
+                    case 180 /* AndAssignmentExpression */:
+                    case 181 /* ExclusiveOrAssignmentExpression */:
+                    case 182 /* OrAssignmentExpression */:
+                    case 183 /* LeftShiftAssignmentExpression */:
+                    case 184 /* SignedRightShiftAssignmentExpression */:
+                    case 185 /* UnsignedRightShiftAssignmentExpression */:
+                        return true;
+                    default:
+                        return false;
+                }
+            };
+
+            ParserImpl.prototype.parseMemberExpressionOrLower = function (inObjectCreation) {
+                if (this.currentToken().tokenKind === 31 /* NewKeyword */) {
+                    return this.parseObjectCreationExpression();
+                }
+
+                var expression = this.parsePrimaryExpression();
+                if (expression === null) {
+                    return this.eatIdentifierToken();
+                }
+
+                return this.parseMemberExpressionRest(expression, false, inObjectCreation);
+            };
+
+            ParserImpl.prototype.parseCallExpressionOrLower = function () {
+                var expression;
+                if (this.currentToken().tokenKind === 50 /* SuperKeyword */) {
+                    expression = this.eatKeyword(50 /* SuperKeyword */);
+
+                    var currentTokenKind = this.currentToken().tokenKind;
+                    if (currentTokenKind !== 72 /* OpenParenToken */ && currentTokenKind !== 76 /* DotToken */) {
+                        expression = this.factory.memberAccessExpression(expression, this.eatToken(76 /* DotToken */), this.eatIdentifierNameToken());
+                    }
+                } else {
+                    expression = this.parseMemberExpressionOrLower(false);
+                }
+
+                return this.parseMemberExpressionRest(expression, true, false);
+            };
+
+            ParserImpl.prototype.parseMemberExpressionRest = function (expression, allowArguments, inObjectCreation) {
+                while (true) {
+                    var currentTokenKind = this.currentToken().tokenKind;
+
+                    switch (currentTokenKind) {
+                        case 72 /* OpenParenToken */:
+                            if (!allowArguments) {
+                                return expression;
+                            }
+
+                            expression = this.factory.invocationExpression(expression, this.parseArgumentList(null));
+                            continue;
+
+                        case 80 /* LessThanToken */:
+                            if (!allowArguments) {
+                                return expression;
+                            }
+
+                            var argumentList = this.tryParseArgumentList();
+                            if (argumentList !== null) {
+                                expression = this.factory.invocationExpression(expression, argumentList);
+                                continue;
+                            }
+
+                            break;
+
+                        case 74 /* OpenBracketToken */:
+                            expression = this.parseElementAccessExpression(expression, inObjectCreation);
+                            continue;
+
+                        case 76 /* DotToken */:
+                            expression = this.factory.memberAccessExpression(expression, this.eatToken(76 /* DotToken */), this.eatIdentifierNameToken());
+                            continue;
+                    }
+
+                    return expression;
+                }
+            };
+
+            ParserImpl.prototype.parseLeftHandSideExpressionOrLower = function () {
+                if (this.currentToken().tokenKind === 31 /* NewKeyword */) {
+                    return this.parseObjectCreationExpression();
+                } else {
+                    return this.parseCallExpressionOrLower();
+                }
+            };
+
+            ParserImpl.prototype.parsePostfixExpressionOrLower = function () {
+                var expression = this.parseLeftHandSideExpressionOrLower();
+                if (expression === null) {
+                    return this.eatIdentifierToken();
+                }
+
+                var currentTokenKind = this.currentToken().tokenKind;
+
+                switch (currentTokenKind) {
+                    case 93 /* PlusPlusToken */:
+                    case 94 /* MinusMinusToken */:
+                        if (this.previousToken() !== null && this.previousToken().hasTrailingNewLine()) {
+                            break;
+                        }
+
+                        return this.factory.postfixUnaryExpression(TypeScript.SyntaxFacts.getPostfixUnaryExpressionFromOperatorToken(currentTokenKind), expression, this.eatAnyToken());
+                }
+
+                return expression;
+            };
+
+            ParserImpl.prototype.tryParseGenericArgumentList = function () {
+                var rewindPoint = this.getRewindPoint();
+
+                var typeArgumentList = this.tryParseTypeArgumentList(true);
+                var token0 = this.currentToken();
+
+                var isOpenParen = token0.tokenKind === 72 /* OpenParenToken */;
+                var isDot = token0.tokenKind === 76 /* DotToken */;
+                var isOpenParenOrDot = isOpenParen || isDot;
+
+                var argumentList = null;
+                if (typeArgumentList === null || !isOpenParenOrDot) {
+                    this.rewind(rewindPoint);
+                    this.releaseRewindPoint(rewindPoint);
+                    return null;
+                } else {
+                    this.releaseRewindPoint(rewindPoint);
+
+                    if (isDot) {
+                        var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token0.width(), TypeScript.DiagnosticCode.A_parameter_list_must_follow_a_generic_type_argument_list_expected, null);
+                        this.addDiagnostic(diagnostic);
+
+                        return this.factory.argumentList(typeArgumentList, TypeScript.Syntax.emptyToken(72 /* OpenParenToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.emptyToken(73 /* CloseParenToken */));
+                    } else {
+                        return this.parseArgumentList(typeArgumentList);
+                    }
+                }
+            };
+
+            ParserImpl.prototype.tryParseArgumentList = function () {
+                if (this.currentToken().tokenKind === 80 /* LessThanToken */) {
+                    return this.tryParseGenericArgumentList();
+                }
+
+                if (this.currentToken().tokenKind === 72 /* OpenParenToken */) {
+                    return this.parseArgumentList(null);
+                }
+
+                return null;
+            };
+
+            ParserImpl.prototype.parseArgumentList = function (typeArgumentList) {
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+
+                var _arguments = TypeScript.Syntax.emptySeparatedList;
+
+                if (openParenToken.fullWidth() > 0) {
+                    var result = this.parseSeparatedSyntaxList(16384 /* ArgumentList_AssignmentExpressions */);
+                    _arguments = result.list;
+                    openParenToken = this.addSkippedTokensAfterToken(openParenToken, result.skippedTokens);
+                }
+
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+
+                return this.factory.argumentList(typeArgumentList, openParenToken, _arguments, closeParenToken);
+            };
+
+            ParserImpl.prototype.parseElementAccessExpression = function (expression, inObjectCreation) {
+                var start = this.currentTokenStart();
+                var openBracketToken = this.eatToken(74 /* OpenBracketToken */);
+                var argumentExpression;
+
+                if (this.currentToken().tokenKind === 75 /* CloseBracketToken */ && inObjectCreation) {
+                    var end = this.currentTokenStart() + this.currentToken().width();
+                    var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, start, end - start, TypeScript.DiagnosticCode.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead, null);
+                    this.addDiagnostic(diagnostic);
+
+                    argumentExpression = TypeScript.Syntax.emptyToken(11 /* IdentifierName */);
+                } else {
+                    argumentExpression = this.parseExpression(true);
+                }
+
+                var closeBracketToken = this.eatToken(75 /* CloseBracketToken */);
+
+                return this.factory.elementAccessExpression(expression, openBracketToken, argumentExpression, closeBracketToken);
+            };
+
+            ParserImpl.prototype.parsePrimaryExpression = function () {
+                var currentToken = this.currentToken();
+
+                if (this.isIdentifier(currentToken)) {
+                    return this.eatIdentifierToken();
+                }
+
+                var currentTokenKind = currentToken.tokenKind;
+                switch (currentTokenKind) {
+                    case 35 /* ThisKeyword */:
+                        return this.parseThisExpression();
+
+                    case 37 /* TrueKeyword */:
+                    case 24 /* FalseKeyword */:
+                        return this.parseLiteralExpression();
+
+                    case 32 /* NullKeyword */:
+                        return this.parseLiteralExpression();
+
+                    case 27 /* FunctionKeyword */:
+                        return this.parseFunctionExpression();
+
+                    case 13 /* NumericLiteral */:
+                        return this.parseLiteralExpression();
+
+                    case 12 /* RegularExpressionLiteral */:
+                        return this.parseLiteralExpression();
+
+                    case 14 /* StringLiteral */:
+                        return this.parseLiteralExpression();
+
+                    case 74 /* OpenBracketToken */:
+                        return this.parseArrayLiteralExpression();
+
+                    case 70 /* OpenBraceToken */:
+                        return this.parseObjectLiteralExpression();
+
+                    case 72 /* OpenParenToken */:
+                        return this.parseParenthesizedExpression();
+
+                    case 118 /* SlashToken */:
+                    case 119 /* SlashEqualsToken */:
+                        var result = this.tryReparseDivideAsRegularExpression();
+                        if (result !== null) {
+                            return result;
+                        }
+                        break;
+                }
+
+                return null;
+            };
+
+            ParserImpl.prototype.tryReparseDivideAsRegularExpression = function () {
+                var currentToken = this.currentToken();
+
+                if (this.previousToken() !== null) {
+                    var previousTokenKind = this.previousToken().tokenKind;
+                    switch (previousTokenKind) {
+                        case 11 /* IdentifierName */:
+                            return null;
+
+                        case 35 /* ThisKeyword */:
+                        case 37 /* TrueKeyword */:
+                        case 24 /* FalseKeyword */:
+                            return null;
+
+                        case 14 /* StringLiteral */:
+                        case 13 /* NumericLiteral */:
+                        case 12 /* RegularExpressionLiteral */:
+                        case 93 /* PlusPlusToken */:
+                        case 94 /* MinusMinusToken */:
+                        case 75 /* CloseBracketToken */:
+                            return null;
+                    }
+                }
+
+                currentToken = this.currentTokenAllowingRegularExpression();
+
+                if (currentToken.tokenKind === 118 /* SlashToken */ || currentToken.tokenKind === 119 /* SlashEqualsToken */) {
+                    return null;
+                } else if (currentToken.tokenKind === 12 /* RegularExpressionLiteral */) {
+                    return this.parseLiteralExpression();
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.parseTypeOfExpression = function () {
+                var typeOfKeyword = this.eatKeyword(39 /* TypeOfKeyword */);
+                var expression = this.parseUnaryExpressionOrLower();
+
+                return this.factory.typeOfExpression(typeOfKeyword, expression);
+            };
+
+            ParserImpl.prototype.parseDeleteExpression = function () {
+                var deleteKeyword = this.eatKeyword(21 /* DeleteKeyword */);
+                var expression = this.parseUnaryExpressionOrLower();
+
+                return this.factory.deleteExpression(deleteKeyword, expression);
+            };
+
+            ParserImpl.prototype.parseVoidExpression = function () {
+                var voidKeyword = this.eatKeyword(41 /* VoidKeyword */);
+                var expression = this.parseUnaryExpressionOrLower();
+
+                return this.factory.voidExpression(voidKeyword, expression);
+            };
+
+            ParserImpl.prototype.parseFunctionExpression = function () {
+                var functionKeyword = this.eatKeyword(27 /* FunctionKeyword */);
+                var identifier = null;
+
+                if (this.isIdentifier(this.currentToken())) {
+                    identifier = this.eatIdentifierToken();
+                }
+
+                var callSignature = this.parseCallSignature(false);
+                var block = this.parseBlock(false, true);
+
+                return this.factory.functionExpression(functionKeyword, identifier, callSignature, block);
+            };
+
+            ParserImpl.prototype.parseObjectCreationExpression = function () {
+                var newKeyword = this.eatKeyword(31 /* NewKeyword */);
+
+                var expression = this.parseObjectCreationExpressionOrLower(true);
+                var argumentList = this.tryParseArgumentList();
+
+                var result = this.factory.objectCreationExpression(newKeyword, expression, argumentList);
+                return this.parseMemberExpressionRest(result, true, false);
+            };
+
+            ParserImpl.prototype.parseObjectCreationExpressionOrLower = function (inObjectCreation) {
+                if (this.currentToken().tokenKind === 31 /* NewKeyword */) {
+                    return this.parseObjectCreationExpression();
+                } else {
+                    return this.parseMemberExpressionOrLower(inObjectCreation);
+                }
+            };
+
+            ParserImpl.prototype.parseCastExpression = function () {
+                var lessThanToken = this.eatToken(80 /* LessThanToken */);
+                var type = this.parseType();
+                var greaterThanToken = this.eatToken(81 /* GreaterThanToken */);
+                var expression = this.parseUnaryExpressionOrLower();
+
+                return this.factory.castExpression(lessThanToken, type, greaterThanToken, expression);
+            };
+
+            ParserImpl.prototype.parseParenthesizedExpression = function () {
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var expression = this.parseExpression(true);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+
+                return this.factory.parenthesizedExpression(openParenToken, expression, closeParenToken);
+            };
+
+            ParserImpl.prototype.tryParseParenthesizedArrowFunctionExpression = function () {
+                var tokenKind = this.currentToken().tokenKind;
+                if (tokenKind !== 72 /* OpenParenToken */ && tokenKind !== 80 /* LessThanToken */) {
+                    return null;
+                }
+
+                if (this.isDefinitelyArrowFunctionExpression()) {
+                    return this.parseParenthesizedArrowFunctionExpression(false);
+                }
+
+                if (!this.isPossiblyArrowFunctionExpression()) {
+                    return null;
+                }
+
+                var rewindPoint = this.getRewindPoint();
+
+                var arrowFunction = this.parseParenthesizedArrowFunctionExpression(true);
+                if (arrowFunction === null) {
+                    this.rewind(rewindPoint);
+                }
+
+                this.releaseRewindPoint(rewindPoint);
+                return arrowFunction;
+            };
+
+            ParserImpl.prototype.parseParenthesizedArrowFunctionExpression = function (requireArrow) {
+                var currentToken = this.currentToken();
+
+                var callSignature = this.parseCallSignature(true);
+
+                if (requireArrow && this.currentToken().tokenKind !== 85 /* EqualsGreaterThanToken */) {
+                    return null;
+                }
+
+                var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */);
+
+                var block = this.tryParseArrowFunctionBlock();
+                var expression = null;
+                if (block === null) {
+                    expression = this.parseAssignmentExpression(true);
+                }
+
+                return this.factory.parenthesizedArrowFunctionExpression(callSignature, equalsGreaterThanToken, block, expression);
+            };
+
+            ParserImpl.prototype.tryParseArrowFunctionBlock = function () {
+                if (this.isBlock()) {
+                    return this.parseBlock(false, false);
+                } else {
+                    if (this.isStatement(false) && !this.isExpressionStatement(this.currentToken()) && !this.isFunctionDeclaration()) {
+                        return this.parseBlock(true, false);
+                    } else {
+                        return null;
+                    }
+                }
+            };
+
+            ParserImpl.prototype.isSimpleArrowFunctionExpression = function () {
+                if (this.currentToken().tokenKind === 85 /* EqualsGreaterThanToken */) {
+                    return true;
+                }
+
+                return this.isIdentifier(this.currentToken()) && this.peekToken(1).tokenKind === 85 /* EqualsGreaterThanToken */;
+            };
+
+            ParserImpl.prototype.parseSimpleArrowFunctionExpression = function () {
+                var identifier = this.eatIdentifierToken();
+                var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */);
+
+                var block = this.tryParseArrowFunctionBlock();
+                var expression = null;
+                if (block === null) {
+                    expression = this.parseAssignmentExpression(true);
+                }
+
+                return this.factory.simpleArrowFunctionExpression(identifier, equalsGreaterThanToken, block, expression);
+            };
+
+            ParserImpl.prototype.isBlock = function () {
+                return this.currentToken().tokenKind === 70 /* OpenBraceToken */;
+            };
+
+            ParserImpl.prototype.isDefinitelyArrowFunctionExpression = function () {
+                var token0 = this.currentToken();
+                if (token0.tokenKind !== 72 /* OpenParenToken */) {
+                    return false;
+                }
+
+                var token1 = this.peekToken(1);
+                var token2;
+
+                if (token1.tokenKind === 73 /* CloseParenToken */) {
+                    token2 = this.peekToken(2);
+                    return token2.tokenKind === 106 /* ColonToken */ || token2.tokenKind === 85 /* EqualsGreaterThanToken */ || token2.tokenKind === 70 /* OpenBraceToken */;
+                }
+
+                if (token1.tokenKind === 77 /* DotDotDotToken */) {
+                    return true;
+                }
+
+                token2 = this.peekToken(2);
+                if (token1.tokenKind === 57 /* PublicKeyword */ || token1.tokenKind === 55 /* PrivateKeyword */) {
+                    if (this.isIdentifier(token2)) {
+                        return true;
+                    }
+                }
+
+                if (!this.isIdentifier(token1)) {
+                    return false;
+                }
+
+                if (token2.tokenKind === 106 /* ColonToken */) {
+                    return true;
+                }
+
+                var token3 = this.peekToken(3);
+                if (token2.tokenKind === 105 /* QuestionToken */) {
+                    if (token3.tokenKind === 106 /* ColonToken */ || token3.tokenKind === 73 /* CloseParenToken */ || token3.tokenKind === 79 /* CommaToken */) {
+                        return true;
+                    }
+                }
+
+                if (token2.tokenKind === 73 /* CloseParenToken */) {
+                    if (token3.tokenKind === 85 /* EqualsGreaterThanToken */) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isPossiblyArrowFunctionExpression = function () {
+                var token0 = this.currentToken();
+                if (token0.tokenKind !== 72 /* OpenParenToken */) {
+                    return true;
+                }
+
+                var token1 = this.peekToken(1);
+
+                if (!this.isIdentifier(token1)) {
+                    return false;
+                }
+
+                var token2 = this.peekToken(2);
+                if (token2.tokenKind === 107 /* EqualsToken */) {
+                    return true;
+                }
+
+                if (token2.tokenKind === 79 /* CommaToken */) {
+                    return true;
+                }
+
+                if (token2.tokenKind === 73 /* CloseParenToken */) {
+                    var token3 = this.peekToken(3);
+                    if (token3.tokenKind === 106 /* ColonToken */) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.parseObjectLiteralExpression = function () {
+                var openBraceToken = this.eatToken(70 /* OpenBraceToken */);
+
+                var result = this.parseSeparatedSyntaxList(32768 /* ObjectLiteralExpression_PropertyAssignments */);
+                var propertyAssignments = result.list;
+                openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens);
+
+                var closeBraceToken = this.eatToken(71 /* CloseBraceToken */);
+
+                return this.factory.objectLiteralExpression(openBraceToken, propertyAssignments, closeBraceToken);
+            };
+
+            ParserImpl.prototype.parsePropertyAssignment = function (inErrorRecovery) {
+                if (this.isAccessor(inErrorRecovery)) {
+                    return this.parseAccessor(true);
+                } else if (this.isFunctionPropertyAssignment(inErrorRecovery)) {
+                    return this.parseFunctionPropertyAssignment();
+                } else if (this.isSimplePropertyAssignment(inErrorRecovery)) {
+                    return this.parseSimplePropertyAssignment();
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.isPropertyAssignment = function (inErrorRecovery) {
+                return this.isAccessor(inErrorRecovery) || this.isFunctionPropertyAssignment(inErrorRecovery) || this.isSimplePropertyAssignment(inErrorRecovery);
+            };
+
+            ParserImpl.prototype.eatPropertyName = function () {
+                return TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(this.currentToken()) ? this.eatIdentifierNameToken() : this.eatAnyToken();
+            };
+
+            ParserImpl.prototype.isFunctionPropertyAssignment = function (inErrorRecovery) {
+                return this.isPropertyName(this.currentToken(), inErrorRecovery) && this.isCallSignature(1);
+            };
+
+            ParserImpl.prototype.parseFunctionPropertyAssignment = function () {
+                var propertyName = this.eatPropertyName();
+                var callSignature = this.parseCallSignature(false);
+                var block = this.parseBlock(false, true);
+
+                return this.factory.functionPropertyAssignment(propertyName, callSignature, block);
+            };
+
+            ParserImpl.prototype.isSimplePropertyAssignment = function (inErrorRecovery) {
+                return this.isPropertyName(this.currentToken(), inErrorRecovery);
+            };
+
+            ParserImpl.prototype.parseSimplePropertyAssignment = function () {
+                var propertyName = this.eatPropertyName();
+                var colonToken = this.eatToken(106 /* ColonToken */);
+                var expression = this.parseAssignmentExpression(true);
+
+                return this.factory.simplePropertyAssignment(propertyName, colonToken, expression);
+            };
+
+            ParserImpl.prototype.isPropertyName = function (token, inErrorRecovery) {
+                if (TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token)) {
+                    if (inErrorRecovery) {
+                        return this.isIdentifier(token);
+                    } else {
+                        return true;
+                    }
+                }
+
+                switch (token.tokenKind) {
+                    case 14 /* StringLiteral */:
+                    case 13 /* NumericLiteral */:
+                        return true;
+
+                    default:
+                        return false;
+                }
+            };
+
+            ParserImpl.prototype.parseArrayLiteralExpression = function () {
+                var openBracketToken = this.eatToken(74 /* OpenBracketToken */);
+
+                var result = this.parseSeparatedSyntaxList(65536 /* ArrayLiteralExpression_AssignmentExpressions */);
+                var expressions = result.list;
+                openBracketToken = this.addSkippedTokensAfterToken(openBracketToken, result.skippedTokens);
+
+                var closeBracketToken = this.eatToken(75 /* CloseBracketToken */);
+
+                return this.factory.arrayLiteralExpression(openBracketToken, expressions, closeBracketToken);
+            };
+
+            ParserImpl.prototype.parseLiteralExpression = function () {
+                return this.eatAnyToken();
+            };
+
+            ParserImpl.prototype.parseThisExpression = function () {
+                return this.eatKeyword(35 /* ThisKeyword */);
+            };
+
+            ParserImpl.prototype.parseBlock = function (parseBlockEvenWithNoOpenBrace, checkForStrictMode) {
+                var openBraceToken = this.eatToken(70 /* OpenBraceToken */);
+
+                var statements = TypeScript.Syntax.emptyList;
+
+                if (parseBlockEvenWithNoOpenBrace || openBraceToken.width() > 0) {
+                    var savedIsInStrictMode = this.isInStrictMode;
+
+                    var processItems = checkForStrictMode ? ParserImpl.updateStrictModeState : null;
+                    var result = this.parseSyntaxList(32 /* Block_Statements */, processItems);
+                    statements = result.list;
+                    openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens);
+
+                    this.setStrictMode(savedIsInStrictMode);
+                }
+
+                var closeBraceToken = this.eatToken(71 /* CloseBraceToken */);
+
+                return this.factory.block(openBraceToken, statements, closeBraceToken);
+            };
+
+            ParserImpl.prototype.parseCallSignature = function (requireCompleteTypeParameterList) {
+                var typeParameterList = this.parseOptionalTypeParameterList(requireCompleteTypeParameterList);
+                var parameterList = this.parseParameterList();
+                var typeAnnotation = this.parseOptionalTypeAnnotation(false);
+
+                return this.factory.callSignature(typeParameterList, parameterList, typeAnnotation);
+            };
+
+            ParserImpl.prototype.parseOptionalTypeParameterList = function (requireCompleteTypeParameterList) {
+                if (this.currentToken().tokenKind !== 80 /* LessThanToken */) {
+                    return null;
+                }
+
+                var rewindPoint = this.getRewindPoint();
+
+                var lessThanToken = this.eatToken(80 /* LessThanToken */);
+
+                var result = this.parseSeparatedSyntaxList(524288 /* TypeParameterList_TypeParameters */);
+                var typeParameters = result.list;
+                lessThanToken = this.addSkippedTokensAfterToken(lessThanToken, result.skippedTokens);
+
+                var greaterThanToken = this.eatToken(81 /* GreaterThanToken */);
+
+                if (requireCompleteTypeParameterList && greaterThanToken.fullWidth() === 0) {
+                    this.rewind(rewindPoint);
+                    this.releaseRewindPoint(rewindPoint);
+                    return null;
+                } else {
+                    this.releaseRewindPoint(rewindPoint);
+                    var typeParameterList = this.factory.typeParameterList(lessThanToken, typeParameters, greaterThanToken);
+
+                    return typeParameterList;
+                }
+            };
+
+            ParserImpl.prototype.isTypeParameter = function () {
+                return this.isIdentifier(this.currentToken());
+            };
+
+            ParserImpl.prototype.parseTypeParameter = function () {
+                var identifier = this.eatIdentifierToken();
+                var constraint = this.parseOptionalConstraint();
+
+                return this.factory.typeParameter(identifier, constraint);
+            };
+
+            ParserImpl.prototype.parseOptionalConstraint = function () {
+                if (this.currentToken().kind() !== 48 /* ExtendsKeyword */) {
+                    return null;
+                }
+
+                var extendsKeyword = this.eatKeyword(48 /* ExtendsKeyword */);
+                var type = this.parseType();
+
+                return this.factory.constraint(extendsKeyword, type);
+            };
+
+            ParserImpl.prototype.parseParameterList = function () {
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var parameters = TypeScript.Syntax.emptySeparatedList;
+
+                if (openParenToken.width() > 0) {
+                    var result = this.parseSeparatedSyntaxList(131072 /* ParameterList_Parameters */);
+                    parameters = result.list;
+                    openParenToken = this.addSkippedTokensAfterToken(openParenToken, result.skippedTokens);
+                }
+
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+                return this.factory.parameterList(openParenToken, parameters, closeParenToken);
+            };
+
+            ParserImpl.prototype.isTypeAnnotation = function () {
+                return this.currentToken().tokenKind === 106 /* ColonToken */;
+            };
+
+            ParserImpl.prototype.parseOptionalTypeAnnotation = function (allowStringLiteral) {
+                return this.isTypeAnnotation() ? this.parseTypeAnnotation(allowStringLiteral) : null;
+            };
+
+            ParserImpl.prototype.parseTypeAnnotation = function (allowStringLiteral) {
+                var colonToken = this.eatToken(106 /* ColonToken */);
+                var type = allowStringLiteral && this.currentToken().tokenKind === 14 /* StringLiteral */ ? this.eatToken(14 /* StringLiteral */) : this.parseType();
+
+                return this.factory.typeAnnotation(colonToken, type);
+            };
+
+            ParserImpl.prototype.isType = function () {
+                var currentToken = this.currentToken();
+                var currentTokenKind = currentToken.tokenKind;
+
+                switch (currentTokenKind) {
+                    case 39 /* TypeOfKeyword */:
+
+                    case 60 /* AnyKeyword */:
+                    case 67 /* NumberKeyword */:
+                    case 61 /* BooleanKeyword */:
+                    case 69 /* StringKeyword */:
+                    case 41 /* VoidKeyword */:
+
+                    case 70 /* OpenBraceToken */:
+
+                    case 72 /* OpenParenToken */:
+                    case 80 /* LessThanToken */:
+
+                    case 31 /* NewKeyword */:
+                        return true;
+                }
+
+                return this.isIdentifier(currentToken);
+            };
+
+            ParserImpl.prototype.parseType = function () {
+                var currentToken = this.currentToken();
+                var currentTokenKind = currentToken.tokenKind;
+
+                var type = this.parseNonArrayType(currentToken);
+
+                while (this.currentToken().tokenKind === 74 /* OpenBracketToken */) {
+                    var openBracketToken = this.eatToken(74 /* OpenBracketToken */);
+                    var closeBracketToken = this.eatToken(75 /* CloseBracketToken */);
+
+                    type = this.factory.arrayType(type, openBracketToken, closeBracketToken);
+                }
+
+                return type;
+            };
+
+            ParserImpl.prototype.isTypeQuery = function () {
+                return this.currentToken().tokenKind === 39 /* TypeOfKeyword */;
+            };
+
+            ParserImpl.prototype.parseTypeQuery = function () {
+                var typeOfKeyword = this.eatToken(39 /* TypeOfKeyword */);
+                var name = this.parseName();
+
+                return this.factory.typeQuery(typeOfKeyword, name);
+            };
+
+            ParserImpl.prototype.parseNonArrayType = function (currentToken) {
+                var currentTokenKind = currentToken.tokenKind;
+                switch (currentTokenKind) {
+                    case 60 /* AnyKeyword */:
+                    case 67 /* NumberKeyword */:
+                    case 61 /* BooleanKeyword */:
+                    case 69 /* StringKeyword */:
+                    case 41 /* VoidKeyword */:
+                        return this.eatAnyToken();
+
+                    case 70 /* OpenBraceToken */:
+                        return this.parseObjectType();
+
+                    case 72 /* OpenParenToken */:
+                    case 80 /* LessThanToken */:
+                        return this.parseFunctionType();
+
+                    case 31 /* NewKeyword */:
+                        return this.parseConstructorType();
+
+                    case 39 /* TypeOfKeyword */:
+                        return this.parseTypeQuery();
+                }
+
+                return this.parseNameOrGenericType();
+            };
+
+            ParserImpl.prototype.parseNameOrGenericType = function () {
+                var name = this.parseName();
+                var typeArgumentList = this.tryParseTypeArgumentList(false);
+
+                return typeArgumentList === null ? name : this.factory.genericType(name, typeArgumentList);
+            };
+
+            ParserImpl.prototype.parseFunctionType = function () {
+                var typeParameterList = this.parseOptionalTypeParameterList(false);
+                var parameterList = this.parseParameterList();
+                var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */);
+                var returnType = this.parseType();
+
+                return this.factory.functionType(typeParameterList, parameterList, equalsGreaterThanToken, returnType);
+            };
+
+            ParserImpl.prototype.parseConstructorType = function () {
+                var newKeyword = this.eatKeyword(31 /* NewKeyword */);
+                var typeParameterList = this.parseOptionalTypeParameterList(false);
+                var parameterList = this.parseParameterList();
+                var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */);
+                var type = this.parseType();
+
+                return this.factory.constructorType(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type);
+            };
+
+            ParserImpl.prototype.isParameter = function () {
+                if (this.currentNode() !== null && this.currentNode().kind() === 242 /* Parameter */) {
+                    return true;
+                }
+
+                var token = this.currentToken();
+                var tokenKind = token.tokenKind;
+                if (tokenKind === 77 /* DotDotDotToken */) {
+                    return true;
+                }
+
+                if (ParserImpl.isModifier(token) && !this.isModifierUsedAsParameterIdentifier(token)) {
+                    return true;
+                }
+
+                return this.isIdentifier(token);
+            };
+
+            ParserImpl.prototype.isModifierUsedAsParameterIdentifier = function (token) {
+                if (this.isIdentifier(token)) {
+                    var nextTokenKind = this.peekToken(1).tokenKind;
+                    switch (nextTokenKind) {
+                        case 73 /* CloseParenToken */:
+                        case 106 /* ColonToken */:
+                        case 107 /* EqualsToken */:
+                        case 79 /* CommaToken */:
+                        case 105 /* QuestionToken */:
+                            return true;
+                    }
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.parseParameter = function () {
+                if (this.currentNode() !== null && this.currentNode().kind() === 242 /* Parameter */) {
+                    return this.eatNode();
+                }
+
+                var dotDotDotToken = this.tryEatToken(77 /* DotDotDotToken */);
+
+                var modifierArray = this.getArray();
+
+                while (true) {
+                    var currentToken = this.currentToken();
+                    if (ParserImpl.isModifier(currentToken) && !this.isModifierUsedAsParameterIdentifier(currentToken)) {
+                        modifierArray.push(this.eatAnyToken());
+                        continue;
+                    }
+
+                    break;
+                }
+
+                var modifiers = TypeScript.Syntax.list(modifierArray);
+                this.returnZeroOrOneLengthArray(modifierArray);
+
+                var identifier = this.eatIdentifierToken();
+                var questionToken = this.tryEatToken(105 /* QuestionToken */);
+                var typeAnnotation = this.parseOptionalTypeAnnotation(true);
+
+                var equalsValueClause = null;
+                if (this.isEqualsValueClause(true)) {
+                    equalsValueClause = this.parseEqualsValueClause(true);
+                }
+
+                return this.factory.parameter(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause);
+            };
+
+            ParserImpl.prototype.parseSyntaxList = function (currentListType, processItems) {
+                if (typeof processItems === "undefined") { processItems = null; }
+                var savedListParsingState = this.listParsingState;
+                this.listParsingState |= currentListType;
+
+                var result = this.parseSyntaxListWorker(currentListType, processItems);
+
+                this.listParsingState = savedListParsingState;
+
+                return result;
+            };
+
+            ParserImpl.prototype.parseSeparatedSyntaxList = function (currentListType) {
+                var savedListParsingState = this.listParsingState;
+                this.listParsingState |= currentListType;
+
+                var result = this.parseSeparatedSyntaxListWorker(currentListType);
+
+                this.listParsingState = savedListParsingState;
+
+                return result;
+            };
+
+            ParserImpl.prototype.abortParsingListOrMoveToNextToken = function (currentListType, items, skippedTokens) {
+                this.reportUnexpectedTokenDiagnostic(currentListType);
+
+                for (var state = 524288 /* LastListParsingState */; state >= 1 /* FirstListParsingState */; state >>= 1) {
+                    if ((this.listParsingState & state) !== 0) {
+                        if (this.isExpectedListTerminator(state) || this.isExpectedListItem(state, true)) {
+                            return true;
+                        }
+                    }
+                }
+
+                var skippedToken = this.currentToken();
+
+                this.moveToNextToken();
+
+                this.addSkippedTokenToList(items, skippedTokens, skippedToken);
+
+                return false;
+            };
+
+            ParserImpl.prototype.addSkippedTokenToList = function (items, skippedTokens, skippedToken) {
+                for (var i = items.length - 1; i >= 0; i--) {
+                    var item = items[i];
+                    var lastToken = item.lastToken();
+                    if (lastToken.fullWidth() > 0) {
+                        items[i] = this.addSkippedTokenAfterNodeOrToken(item, skippedToken);
+                        return;
+                    }
+                }
+
+                skippedTokens.push(skippedToken);
+            };
+
+            ParserImpl.prototype.tryParseExpectedListItem = function (currentListType, inErrorRecovery, items, processItems) {
+                if (this.isExpectedListItem(currentListType, inErrorRecovery)) {
+                    var item = this.parseExpectedListItem(currentListType, inErrorRecovery);
+
+                    items.push(item);
+
+                    if (processItems !== null) {
+                        processItems(this, items);
+                    }
+                }
+            };
+
+            ParserImpl.prototype.listIsTerminated = function (currentListType) {
+                return this.isExpectedListTerminator(currentListType) || this.currentToken().tokenKind === 10 /* EndOfFileToken */;
+            };
+
+            ParserImpl.prototype.getArray = function () {
+                if (this.arrayPool.length > 0) {
+                    return this.arrayPool.pop();
+                }
+
+                return [];
+            };
+
+            ParserImpl.prototype.returnZeroOrOneLengthArray = function (array) {
+                if (array.length <= 1) {
+                    this.returnArray(array);
+                }
+            };
+
+            ParserImpl.prototype.returnArray = function (array) {
+                array.length = 0;
+                this.arrayPool.push(array);
+            };
+
+            ParserImpl.prototype.parseSyntaxListWorker = function (currentListType, processItems) {
+                var items = this.getArray();
+                var skippedTokens = this.getArray();
+
+                while (true) {
+                    var oldItemsCount = items.length;
+                    this.tryParseExpectedListItem(currentListType, false, items, processItems);
+
+                    var newItemsCount = items.length;
+                    if (newItemsCount === oldItemsCount) {
+                        if (this.listIsTerminated(currentListType)) {
+                            break;
+                        }
+
+                        var abort = this.abortParsingListOrMoveToNextToken(currentListType, items, skippedTokens);
+                        if (abort) {
+                            break;
+                        }
+                    }
+                }
+
+                var result = TypeScript.Syntax.list(items);
+
+                this.returnZeroOrOneLengthArray(items);
+
+                return { skippedTokens: skippedTokens, list: result };
+            };
+
+            ParserImpl.prototype.parseSeparatedSyntaxListWorker = function (currentListType) {
+                var items = this.getArray();
+                var skippedTokens = this.getArray();
+                TypeScript.Debug.assert(items.length === 0);
+                TypeScript.Debug.assert(skippedTokens.length === 0);
+                TypeScript.Debug.assert(skippedTokens !== items);
+
+                var separatorKind = this.separatorKind(currentListType);
+                var allowAutomaticSemicolonInsertion = separatorKind === 78 /* SemicolonToken */;
+
+                var inErrorRecovery = false;
+                var listWasTerminated = false;
+                while (true) {
+                    var oldItemsCount = items.length;
+
+                    this.tryParseExpectedListItem(currentListType, inErrorRecovery, items, null);
+
+                    var newItemsCount = items.length;
+                    if (newItemsCount === oldItemsCount) {
+                        if (this.listIsTerminated(currentListType)) {
+                            listWasTerminated = true;
+                            break;
+                        }
+
+                        var abort = this.abortParsingListOrMoveToNextToken(currentListType, items, skippedTokens);
+                        if (abort) {
+                            break;
+                        } else {
+                            inErrorRecovery = true;
+                            continue;
+                        }
+                    }
+
+                    inErrorRecovery = false;
+
+                    var currentToken = this.currentToken();
+                    if (currentToken.tokenKind === separatorKind || currentToken.tokenKind === 79 /* CommaToken */) {
+                        items.push(this.eatAnyToken());
+                        continue;
+                    }
+
+                    if (this.listIsTerminated(currentListType)) {
+                        listWasTerminated = true;
+                        break;
+                    }
+
+                    if (allowAutomaticSemicolonInsertion && this.canEatAutomaticSemicolon(false)) {
+                        items.push(this.eatExplicitOrAutomaticSemicolon(false));
+
+                        continue;
+                    }
+
+                    items.push(this.eatToken(separatorKind));
+
+                    inErrorRecovery = true;
+                }
+
+                var result = TypeScript.Syntax.separatedList(items);
+
+                this.returnZeroOrOneLengthArray(items);
+
+                return { skippedTokens: skippedTokens, list: result };
+            };
+
+            ParserImpl.prototype.separatorKind = function (currentListType) {
+                switch (currentListType) {
+                    case 2048 /* HeritageClause_TypeNameList */:
+                    case 16384 /* ArgumentList_AssignmentExpressions */:
+                    case 256 /* EnumDeclaration_EnumElements */:
+                    case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */:
+                    case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */:
+                    case 32768 /* ObjectLiteralExpression_PropertyAssignments */:
+                    case 131072 /* ParameterList_Parameters */:
+                    case 65536 /* ArrayLiteralExpression_AssignmentExpressions */:
+                    case 262144 /* TypeArgumentList_Types */:
+                    case 524288 /* TypeParameterList_TypeParameters */:
+                        return 79 /* CommaToken */;
+
+                    case 512 /* ObjectType_TypeMembers */:
+                        return 78 /* SemicolonToken */;
+
+                    case 1 /* SourceUnit_ModuleElements */:
+                    case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */:
+                    case 2 /* ClassDeclaration_ClassElements */:
+                    case 4 /* ModuleDeclaration_ModuleElements */:
+                    case 8 /* SwitchStatement_SwitchClauses */:
+                    case 16 /* SwitchClause_Statements */:
+                    case 32 /* Block_Statements */:
+                    default:
+                        throw TypeScript.Errors.notYetImplemented();
+                }
+            };
+
+            ParserImpl.prototype.reportUnexpectedTokenDiagnostic = function (listType) {
+                var token = this.currentToken();
+
+                var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode.Unexpected_token_0_expected, [this.getExpectedListElementType(listType)]);
+                this.addDiagnostic(diagnostic);
+            };
+
+            ParserImpl.prototype.addDiagnostic = function (diagnostic) {
+                if (this.diagnostics.length > 0 && this.diagnostics[this.diagnostics.length - 1].start() === diagnostic.start()) {
+                    return;
+                }
+
+                this.diagnostics.push(diagnostic);
+            };
+
+            ParserImpl.prototype.isExpectedListTerminator = function (currentListType) {
+                switch (currentListType) {
+                    case 1 /* SourceUnit_ModuleElements */:
+                        return this.isExpectedSourceUnit_ModuleElementsTerminator();
+
+                    case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */:
+                        return this.isExpectedClassOrInterfaceDeclaration_HeritageClausesTerminator();
+
+                    case 2 /* ClassDeclaration_ClassElements */:
+                        return this.isExpectedClassDeclaration_ClassElementsTerminator();
+
+                    case 4 /* ModuleDeclaration_ModuleElements */:
+                        return this.isExpectedModuleDeclaration_ModuleElementsTerminator();
+
+                    case 8 /* SwitchStatement_SwitchClauses */:
+                        return this.isExpectedSwitchStatement_SwitchClausesTerminator();
+
+                    case 16 /* SwitchClause_Statements */:
+                        return this.isExpectedSwitchClause_StatementsTerminator();
+
+                    case 32 /* Block_Statements */:
+                        return this.isExpectedBlock_StatementsTerminator();
+
+                    case 64 /* TryBlock_Statements */:
+                        return this.isExpectedTryBlock_StatementsTerminator();
+
+                    case 128 /* CatchBlock_Statements */:
+                        return this.isExpectedCatchBlock_StatementsTerminator();
+
+                    case 256 /* EnumDeclaration_EnumElements */:
+                        return this.isExpectedEnumDeclaration_EnumElementsTerminator();
+
+                    case 512 /* ObjectType_TypeMembers */:
+                        return this.isExpectedObjectType_TypeMembersTerminator();
+
+                    case 16384 /* ArgumentList_AssignmentExpressions */:
+                        return this.isExpectedArgumentList_AssignmentExpressionsTerminator();
+
+                    case 2048 /* HeritageClause_TypeNameList */:
+                        return this.isExpectedHeritageClause_TypeNameListTerminator();
+
+                    case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */:
+                        return this.isExpectedVariableDeclaration_VariableDeclarators_AllowInTerminator();
+
+                    case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */:
+                        return this.isExpectedVariableDeclaration_VariableDeclarators_DisallowInTerminator();
+
+                    case 32768 /* ObjectLiteralExpression_PropertyAssignments */:
+                        return this.isExpectedObjectLiteralExpression_PropertyAssignmentsTerminator();
+
+                    case 131072 /* ParameterList_Parameters */:
+                        return this.isExpectedParameterList_ParametersTerminator();
+
+                    case 262144 /* TypeArgumentList_Types */:
+                        return this.isExpectedTypeArgumentList_TypesTerminator();
+
+                    case 524288 /* TypeParameterList_TypeParameters */:
+                        return this.isExpectedTypeParameterList_TypeParametersTerminator();
+
+                    case 65536 /* ArrayLiteralExpression_AssignmentExpressions */:
+                        return this.isExpectedLiteralExpression_AssignmentExpressionsTerminator();
+
+                    default:
+                        throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.isExpectedSourceUnit_ModuleElementsTerminator = function () {
+                return this.currentToken().tokenKind === 10 /* EndOfFileToken */;
+            };
+
+            ParserImpl.prototype.isExpectedEnumDeclaration_EnumElementsTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */;
+            };
+
+            ParserImpl.prototype.isExpectedModuleDeclaration_ModuleElementsTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */;
+            };
+
+            ParserImpl.prototype.isExpectedObjectType_TypeMembersTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */;
+            };
+
+            ParserImpl.prototype.isExpectedObjectLiteralExpression_PropertyAssignmentsTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */;
+            };
+
+            ParserImpl.prototype.isExpectedLiteralExpression_AssignmentExpressionsTerminator = function () {
+                return this.currentToken().tokenKind === 75 /* CloseBracketToken */;
+            };
+
+            ParserImpl.prototype.isExpectedTypeArgumentList_TypesTerminator = function () {
+                var token = this.currentToken();
+                if (token.tokenKind === 81 /* GreaterThanToken */) {
+                    return true;
+                }
+
+                if (this.canFollowTypeArgumentListInExpression(token.tokenKind)) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isExpectedTypeParameterList_TypeParametersTerminator = function () {
+                var token = this.currentToken();
+                if (token.tokenKind === 81 /* GreaterThanToken */) {
+                    return true;
+                }
+
+                if (token.tokenKind === 72 /* OpenParenToken */ || token.tokenKind === 70 /* OpenBraceToken */ || token.tokenKind === 48 /* ExtendsKeyword */ || token.tokenKind === 51 /* ImplementsKeyword */) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isExpectedParameterList_ParametersTerminator = function () {
+                var token = this.currentToken();
+                if (token.tokenKind === 73 /* CloseParenToken */) {
+                    return true;
+                }
+
+                if (token.tokenKind === 70 /* OpenBraceToken */) {
+                    return true;
+                }
+
+                if (token.tokenKind === 85 /* EqualsGreaterThanToken */) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isExpectedVariableDeclaration_VariableDeclarators_DisallowInTerminator = function () {
+                if (this.currentToken().tokenKind === 78 /* SemicolonToken */ || this.currentToken().tokenKind === 73 /* CloseParenToken */) {
+                    return true;
+                }
+
+                if (this.currentToken().tokenKind === 29 /* InKeyword */) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isExpectedVariableDeclaration_VariableDeclarators_AllowInTerminator = function () {
+                if (this.previousToken().tokenKind === 79 /* CommaToken */) {
+                    return false;
+                }
+
+                if (this.currentToken().tokenKind === 85 /* EqualsGreaterThanToken */) {
+                    return true;
+                }
+
+                return this.canEatExplicitOrAutomaticSemicolon(false);
+            };
+
+            ParserImpl.prototype.isExpectedClassOrInterfaceDeclaration_HeritageClausesTerminator = function () {
+                var token0 = this.currentToken();
+                if (token0.tokenKind === 70 /* OpenBraceToken */ || token0.tokenKind === 71 /* CloseBraceToken */) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isExpectedHeritageClause_TypeNameListTerminator = function () {
+                var token0 = this.currentToken();
+                if (token0.tokenKind === 48 /* ExtendsKeyword */ || token0.tokenKind === 51 /* ImplementsKeyword */) {
+                    return true;
+                }
+
+                if (this.isExpectedClassOrInterfaceDeclaration_HeritageClausesTerminator()) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isExpectedArgumentList_AssignmentExpressionsTerminator = function () {
+                var token0 = this.currentToken();
+                return token0.tokenKind === 73 /* CloseParenToken */ || token0.tokenKind === 78 /* SemicolonToken */;
+            };
+
+            ParserImpl.prototype.isExpectedClassDeclaration_ClassElementsTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */;
+            };
+
+            ParserImpl.prototype.isExpectedSwitchStatement_SwitchClausesTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */;
+            };
+
+            ParserImpl.prototype.isExpectedSwitchClause_StatementsTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */ || this.isSwitchClause();
+            };
+
+            ParserImpl.prototype.isExpectedBlock_StatementsTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */;
+            };
+
+            ParserImpl.prototype.isExpectedTryBlock_StatementsTerminator = function () {
+                return this.currentToken().tokenKind === 17 /* CatchKeyword */ || this.currentToken().tokenKind === 25 /* FinallyKeyword */;
+            };
+
+            ParserImpl.prototype.isExpectedCatchBlock_StatementsTerminator = function () {
+                return this.currentToken().tokenKind === 25 /* FinallyKeyword */;
+            };
+
+            ParserImpl.prototype.isExpectedListItem = function (currentListType, inErrorRecovery) {
+                switch (currentListType) {
+                    case 1 /* SourceUnit_ModuleElements */:
+                        return this.isModuleElement(inErrorRecovery);
+
+                    case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */:
+                        return this.isHeritageClause();
+
+                    case 2 /* ClassDeclaration_ClassElements */:
+                        return this.isClassElement(inErrorRecovery);
+
+                    case 4 /* ModuleDeclaration_ModuleElements */:
+                        return this.isModuleElement(inErrorRecovery);
+
+                    case 8 /* SwitchStatement_SwitchClauses */:
+                        return this.isSwitchClause();
+
+                    case 16 /* SwitchClause_Statements */:
+                        return this.isStatement(inErrorRecovery);
+
+                    case 32 /* Block_Statements */:
+                        return this.isStatement(inErrorRecovery);
+
+                    case 64 /* TryBlock_Statements */:
+                    case 128 /* CatchBlock_Statements */:
+                        return false;
+
+                    case 256 /* EnumDeclaration_EnumElements */:
+                        return this.isEnumElement(inErrorRecovery);
+
+                    case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */:
+                    case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */:
+                        return this.isVariableDeclarator();
+
+                    case 512 /* ObjectType_TypeMembers */:
+                        return this.isTypeMember(inErrorRecovery);
+
+                    case 16384 /* ArgumentList_AssignmentExpressions */:
+                        return this.isExpectedArgumentList_AssignmentExpression();
+
+                    case 2048 /* HeritageClause_TypeNameList */:
+                        return this.isHeritageClauseTypeName();
+
+                    case 32768 /* ObjectLiteralExpression_PropertyAssignments */:
+                        return this.isPropertyAssignment(inErrorRecovery);
+
+                    case 131072 /* ParameterList_Parameters */:
+                        return this.isParameter();
+
+                    case 262144 /* TypeArgumentList_Types */:
+                        return this.isType();
+
+                    case 524288 /* TypeParameterList_TypeParameters */:
+                        return this.isTypeParameter();
+
+                    case 65536 /* ArrayLiteralExpression_AssignmentExpressions */:
+                        return this.isAssignmentOrOmittedExpression();
+
+                    default:
+                        throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.isExpectedArgumentList_AssignmentExpression = function () {
+                var currentToken = this.currentToken();
+                if (this.isExpression(currentToken)) {
+                    return true;
+                }
+
+                if (currentToken.tokenKind === 79 /* CommaToken */) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.parseExpectedListItem = function (currentListType, inErrorRecovery) {
+                switch (currentListType) {
+                    case 1 /* SourceUnit_ModuleElements */:
+                        return this.parseModuleElement(inErrorRecovery);
+
+                    case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */:
+                        return this.parseHeritageClause();
+
+                    case 2 /* ClassDeclaration_ClassElements */:
+                        return this.parseClassElement(inErrorRecovery);
+
+                    case 4 /* ModuleDeclaration_ModuleElements */:
+                        return this.parseModuleElement(inErrorRecovery);
+
+                    case 8 /* SwitchStatement_SwitchClauses */:
+                        return this.parseSwitchClause();
+
+                    case 16 /* SwitchClause_Statements */:
+                        return this.parseStatement(inErrorRecovery);
+
+                    case 32 /* Block_Statements */:
+                        return this.parseStatement(inErrorRecovery);
+
+                    case 256 /* EnumDeclaration_EnumElements */:
+                        return this.parseEnumElement();
+
+                    case 512 /* ObjectType_TypeMembers */:
+                        return this.parseTypeMember(inErrorRecovery);
+
+                    case 16384 /* ArgumentList_AssignmentExpressions */:
+                        return this.parseAssignmentExpression(true);
+
+                    case 2048 /* HeritageClause_TypeNameList */:
+                        return this.parseNameOrGenericType();
+
+                    case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */:
+                        return this.parseVariableDeclarator(true, false);
+
+                    case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */:
+                        return this.parseVariableDeclarator(false, false);
+
+                    case 32768 /* ObjectLiteralExpression_PropertyAssignments */:
+                        return this.parsePropertyAssignment(inErrorRecovery);
+
+                    case 65536 /* ArrayLiteralExpression_AssignmentExpressions */:
+                        return this.parseAssignmentOrOmittedExpression();
+
+                    case 131072 /* ParameterList_Parameters */:
+                        return this.parseParameter();
+
+                    case 262144 /* TypeArgumentList_Types */:
+                        return this.parseType();
+
+                    case 524288 /* TypeParameterList_TypeParameters */:
+                        return this.parseTypeParameter();
+
+                    default:
+                        throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.getExpectedListElementType = function (currentListType) {
+                switch (currentListType) {
+                    case 1 /* SourceUnit_ModuleElements */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.module_class_interface_enum_import_or_statement, null);
+
+                    case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */:
+                        return '{';
+
+                    case 2 /* ClassDeclaration_ClassElements */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.constructor_function_accessor_or_variable, null);
+
+                    case 4 /* ModuleDeclaration_ModuleElements */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.module_class_interface_enum_import_or_statement, null);
+
+                    case 8 /* SwitchStatement_SwitchClauses */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.case_or_default_clause, null);
+
+                    case 16 /* SwitchClause_Statements */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.statement, null);
+
+                    case 32 /* Block_Statements */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.statement, null);
+
+                    case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */:
+                    case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null);
+
+                    case 256 /* EnumDeclaration_EnumElements */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null);
+
+                    case 512 /* ObjectType_TypeMembers */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.call_construct_index_property_or_function_signature, null);
+
+                    case 16384 /* ArgumentList_AssignmentExpressions */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.expression, null);
+
+                    case 2048 /* HeritageClause_TypeNameList */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type_name, null);
+
+                    case 32768 /* ObjectLiteralExpression_PropertyAssignments */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.property_or_accessor, null);
+
+                    case 131072 /* ParameterList_Parameters */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.parameter, null);
+
+                    case 262144 /* TypeArgumentList_Types */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type, null);
+
+                    case 524288 /* TypeParameterList_TypeParameters */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type_parameter, null);
+
+                    case 65536 /* ArrayLiteralExpression_AssignmentExpressions */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.expression, null);
+
+                    default:
+                        throw TypeScript.Errors.invalidOperation();
+                }
+            };
+            return ParserImpl;
+        })();
+
+        function parse(fileName, text, isDeclaration, options) {
+            var source = new NormalParserSource(fileName, text, options.languageVersion());
+
+            return new ParserImpl(fileName, text.lineMap(), source, options, text).parseSyntaxTree(isDeclaration);
+        }
+        Parser.parse = parse;
+
+        function incrementalParse(oldSyntaxTree, textChangeRange, newText) {
+            if (textChangeRange.isUnchanged()) {
+                return oldSyntaxTree;
+            }
+
+            var source = new IncrementalParserSource(oldSyntaxTree, textChangeRange, newText);
+
+            return new ParserImpl(oldSyntaxTree.fileName(), newText.lineMap(), source, oldSyntaxTree.parseOptions(), newText).parseSyntaxTree(oldSyntaxTree.isDeclaration());
+        }
+        Parser.incrementalParse = incrementalParse;
+    })(TypeScript.Parser || (TypeScript.Parser = {}));
+    var Parser = TypeScript.Parser;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxTree = (function () {
+        function SyntaxTree(sourceUnit, isDeclaration, diagnostics, fileName, lineMap, parseOtions) {
+            this._allDiagnostics = null;
+            this._sourceUnit = sourceUnit;
+            this._isDeclaration = isDeclaration;
+            this._parserDiagnostics = diagnostics;
+            this._fileName = fileName;
+            this._lineMap = lineMap;
+            this._parseOptions = parseOtions;
+        }
+        SyntaxTree.prototype.toJSON = function (key) {
+            var result = {};
+
+            result.isDeclaration = this._isDeclaration;
+            result.languageVersion = TypeScript.LanguageVersion[this._parseOptions.languageVersion()];
+            result.parseOptions = this._parseOptions;
+
+            if (this.diagnostics().length > 0) {
+                result.diagnostics = this.diagnostics();
+            }
+
+            result.sourceUnit = this._sourceUnit;
+            result.lineMap = this._lineMap;
+
+            return result;
+        };
+
+        SyntaxTree.prototype.sourceUnit = function () {
+            return this._sourceUnit;
+        };
+
+        SyntaxTree.prototype.isDeclaration = function () {
+            return this._isDeclaration;
+        };
+
+        SyntaxTree.prototype.computeDiagnostics = function () {
+            if (this._parserDiagnostics.length > 0) {
+                return this._parserDiagnostics;
+            }
+
+            var diagnostics = [];
+            this.sourceUnit().accept(new GrammarCheckerWalker(this, diagnostics));
+
+            return diagnostics;
+        };
+
+        SyntaxTree.prototype.diagnostics = function () {
+            if (this._allDiagnostics === null) {
+                this._allDiagnostics = this.computeDiagnostics();
+            }
+
+            return this._allDiagnostics;
+        };
+
+        SyntaxTree.prototype.fileName = function () {
+            return this._fileName;
+        };
+
+        SyntaxTree.prototype.lineMap = function () {
+            return this._lineMap;
+        };
+
+        SyntaxTree.prototype.parseOptions = function () {
+            return this._parseOptions;
+        };
+
+        SyntaxTree.prototype.structuralEquals = function (tree) {
+            return TypeScript.ArrayUtilities.sequenceEquals(this.diagnostics(), tree.diagnostics(), TypeScript.Diagnostic.equals) && this.sourceUnit().structuralEquals(tree.sourceUnit());
+        };
+        return SyntaxTree;
+    })();
+    TypeScript.SyntaxTree = SyntaxTree;
+
+    var GrammarCheckerWalker = (function (_super) {
+        __extends(GrammarCheckerWalker, _super);
+        function GrammarCheckerWalker(syntaxTree, diagnostics) {
+            _super.call(this);
+            this.syntaxTree = syntaxTree;
+            this.diagnostics = diagnostics;
+            this.inAmbientDeclaration = false;
+            this.inBlock = false;
+            this.inObjectLiteralExpression = false;
+            this.currentConstructor = null;
+        }
+        GrammarCheckerWalker.prototype.childFullStart = function (parent, child) {
+            return this.position() + TypeScript.Syntax.childOffset(parent, child);
+        };
+
+        GrammarCheckerWalker.prototype.childStart = function (parent, child) {
+            return this.childFullStart(parent, child) + child.leadingTriviaWidth();
+        };
+
+        GrammarCheckerWalker.prototype.pushDiagnostic = function (start, length, diagnosticKey, args) {
+            if (typeof args === "undefined") { args = null; }
+            this.diagnostics.push(new TypeScript.Diagnostic(this.syntaxTree.fileName(), this.syntaxTree.lineMap(), start, length, diagnosticKey, args));
+        };
+
+        GrammarCheckerWalker.prototype.pushDiagnostic1 = function (elementFullStart, element, diagnosticKey, args) {
+            if (typeof args === "undefined") { args = null; }
+            this.diagnostics.push(new TypeScript.Diagnostic(this.syntaxTree.fileName(), this.syntaxTree.lineMap(), elementFullStart + element.leadingTriviaWidth(), element.width(), diagnosticKey, args));
+        };
+
+        GrammarCheckerWalker.prototype.visitCatchClause = function (node) {
+            if (node.typeAnnotation) {
+                this.pushDiagnostic(this.childStart(node, node.typeAnnotation), node.typeAnnotation.width(), TypeScript.DiagnosticCode.Catch_clause_parameter_cannot_have_a_type_annotation);
+            }
+
+            _super.prototype.visitCatchClause.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkParameterListOrder = function (node) {
+            var parameterFullStart = this.childFullStart(node, node.parameters);
+
+            var seenOptionalParameter = false;
+            var parameterCount = node.parameters.nonSeparatorCount();
+
+            for (var i = 0, n = node.parameters.childCount(); i < n; i++) {
+                var nodeOrToken = node.parameters.childAt(i);
+                if (i % 2 === 0) {
+                    var parameterIndex = i / 2;
+                    var parameter = node.parameters.childAt(i);
+
+                    if (parameter.dotDotDotToken) {
+                        if (parameterIndex !== (parameterCount - 1)) {
+                            this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Rest_parameter_must_be_last_in_list);
+                            return true;
+                        }
+
+                        if (parameter.questionToken) {
+                            this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Rest_parameter_cannot_be_optional);
+                            return true;
+                        }
+
+                        if (parameter.equalsValueClause) {
+                            this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Rest_parameter_cannot_have_an_initializer);
+                            return true;
+                        }
+                    } else if (parameter.questionToken || parameter.equalsValueClause) {
+                        seenOptionalParameter = true;
+
+                        if (parameter.questionToken && parameter.equalsValueClause) {
+                            this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Parameter_cannot_have_question_mark_and_initializer);
+                            return true;
+                        }
+                    } else {
+                        if (seenOptionalParameter) {
+                            this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Required_parameter_cannot_follow_optional_parameter);
+                            return true;
+                        }
+                    }
+                }
+
+                parameterFullStart += nodeOrToken.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkParameterListAcessibilityModifiers = function (node) {
+            var parameterFullStart = this.childFullStart(node, node.parameters);
+
+            for (var i = 0, n = node.parameters.childCount(); i < n; i++) {
+                var nodeOrToken = node.parameters.childAt(i);
+                if (i % 2 === 0) {
+                    var parameter = node.parameters.childAt(i);
+
+                    if (this.checkParameterAccessibilityModifiers(node, parameter, parameterFullStart)) {
+                        return true;
+                    }
+                }
+
+                parameterFullStart += nodeOrToken.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkParameterAccessibilityModifiers = function (parameterList, parameter, parameterFullStart) {
+            if (parameter.modifiers.childCount() > 0) {
+                var modifiers = parameter.modifiers;
+                var modifierFullStart = parameterFullStart + TypeScript.Syntax.childOffset(parameter, modifiers);
+
+                for (var i = 0, n = modifiers.childCount(); i < n; i++) {
+                    var modifier = modifiers.childAt(i);
+
+                    if (this.checkParameterAccessibilityModifier(parameterList, modifier, modifierFullStart, i)) {
+                        return true;
+                    }
+
+                    modifierFullStart += modifier.fullWidth();
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkParameterAccessibilityModifier = function (parameterList, modifier, modifierFullStart, modifierIndex) {
+            if (modifier.tokenKind !== 57 /* PublicKeyword */ && modifier.tokenKind !== 55 /* PrivateKeyword */) {
+                this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_parameter, [modifier.text()]);
+                return true;
+            } else {
+                if (modifierIndex > 0) {
+                    this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Accessibility_modifier_already_seen);
+                    return true;
+                }
+
+                if (!this.inAmbientDeclaration && this.currentConstructor && !this.currentConstructor.block && this.currentConstructor.callSignature.parameterList === parameterList) {
+                    this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Parameter_property_declarations_cannot_be_used_in_a_constructor_overload);
+                    return true;
+                } else if (this.inAmbientDeclaration || this.currentConstructor === null || this.currentConstructor.callSignature.parameterList !== parameterList) {
+                    this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Parameter_property_declarations_can_only_be_used_in_a_non_ambient_constructor_declaration);
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkForTrailingSeparator = function (parent, list) {
+            if (list.childCount() === 0 || list.childCount() % 2 === 1) {
+                return false;
+            }
+
+            var currentElementFullStart = this.childFullStart(parent, list);
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var child = list.childAt(i);
+                if (i === n - 1) {
+                    this.pushDiagnostic1(currentElementFullStart, child, TypeScript.DiagnosticCode.Trailing_separator_not_allowed);
+                }
+
+                currentElementFullStart += child.fullWidth();
+            }
+
+            return true;
+        };
+
+        GrammarCheckerWalker.prototype.checkForAtLeastOneElement = function (parent, list, expected) {
+            if (list.childCount() > 0) {
+                return false;
+            }
+
+            var listFullStart = this.childFullStart(parent, list);
+            var tokenAtStart = this.syntaxTree.sourceUnit().findToken(listFullStart);
+
+            this.pushDiagnostic1(listFullStart, tokenAtStart.token(), TypeScript.DiagnosticCode.Unexpected_token_0_expected, [expected]);
+
+            return true;
+        };
+
+        GrammarCheckerWalker.prototype.visitParameterList = function (node) {
+            if (this.checkParameterListAcessibilityModifiers(node) || this.checkParameterListOrder(node) || this.checkForTrailingSeparator(node, node.parameters)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitParameterList.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitHeritageClause = function (node) {
+            if (this.checkForTrailingSeparator(node, node.typeNames) || this.checkForAtLeastOneElement(node, node.typeNames, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type_name, null))) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitHeritageClause.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitArgumentList = function (node) {
+            if (this.checkForTrailingSeparator(node, node.arguments)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitArgumentList.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitVariableDeclaration = function (node) {
+            if (this.checkForTrailingSeparator(node, node.variableDeclarators) || this.checkForAtLeastOneElement(node, node.variableDeclarators, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null))) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitVariableDeclaration.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitTypeArgumentList = function (node) {
+            if (this.checkForTrailingSeparator(node, node.typeArguments) || this.checkForAtLeastOneElement(node, node.typeArguments, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null))) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitTypeArgumentList.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitTypeParameterList = function (node) {
+            if (this.checkForTrailingSeparator(node, node.typeParameters) || this.checkForAtLeastOneElement(node, node.typeParameters, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null))) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitTypeParameterList.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkIndexSignatureParameter = function (node) {
+            var parameterFullStart = this.childFullStart(node, node.parameter);
+            var parameter = node.parameter;
+
+            if (parameter.dotDotDotToken) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signatures_cannot_have_rest_parameters);
+                return true;
+            } else if (parameter.modifiers.childCount() > 0) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_cannot_have_accessibility_modifiers);
+                return true;
+            } else if (parameter.questionToken) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_cannot_have_a_question_mark);
+                return true;
+            } else if (parameter.equalsValueClause) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_cannot_have_an_initializer);
+                return true;
+            } else if (!parameter.typeAnnotation) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_must_have_a_type_annotation);
+                return true;
+            } else if (parameter.typeAnnotation.type.kind() !== 69 /* StringKeyword */ && parameter.typeAnnotation.type.kind() !== 67 /* NumberKeyword */) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_type_must_be_string_or_number);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitIndexSignature = function (node) {
+            if (this.checkIndexSignatureParameter(node)) {
+                this.skip(node);
+                return;
+            }
+
+            if (!node.typeAnnotation) {
+                this.pushDiagnostic1(this.position(), node, TypeScript.DiagnosticCode.Index_signature_must_have_a_type_annotation);
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitIndexSignature.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkClassDeclarationHeritageClauses = function (node) {
+            var heritageClauseFullStart = this.childFullStart(node, node.heritageClauses);
+
+            var seenExtendsClause = false;
+            var seenImplementsClause = false;
+
+            for (var i = 0, n = node.heritageClauses.childCount(); i < n; i++) {
+                TypeScript.Debug.assert(i <= 2);
+                var heritageClause = node.heritageClauses.childAt(i);
+
+                if (heritageClause.extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */) {
+                    if (seenExtendsClause) {
+                        this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.extends_clause_already_seen);
+                        return true;
+                    }
+
+                    if (seenImplementsClause) {
+                        this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.extends_clause_must_precede_implements_clause);
+                        return true;
+                    }
+
+                    if (heritageClause.typeNames.nonSeparatorCount() > 1) {
+                        this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.Classes_can_only_extend_a_single_class);
+                        return true;
+                    }
+
+                    seenExtendsClause = true;
+                } else {
+                    TypeScript.Debug.assert(heritageClause.extendsOrImplementsKeyword.tokenKind === 51 /* ImplementsKeyword */);
+                    if (seenImplementsClause) {
+                        this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.implements_clause_already_seen);
+                        return true;
+                    }
+
+                    seenImplementsClause = true;
+                }
+
+                heritageClauseFullStart += heritageClause.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkForDisallowedDeclareModifier = function (modifiers) {
+            if (this.inAmbientDeclaration) {
+                var declareToken = TypeScript.SyntaxUtilities.getToken(modifiers, 63 /* DeclareKeyword */);
+
+                if (declareToken) {
+                    this.pushDiagnostic1(this.childFullStart(modifiers, declareToken), declareToken, TypeScript.DiagnosticCode.declare_modifier_not_allowed_for_code_already_in_an_ambient_context);
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkForRequiredDeclareModifier = function (moduleElement, typeKeyword, modifiers) {
+            if (!this.inAmbientDeclaration && this.syntaxTree.isDeclaration()) {
+                if (!TypeScript.SyntaxUtilities.containsToken(modifiers, 63 /* DeclareKeyword */)) {
+                    this.pushDiagnostic1(this.childFullStart(moduleElement, typeKeyword), typeKeyword.firstToken(), TypeScript.DiagnosticCode.declare_modifier_required_for_top_level_element);
+                    return true;
+                }
+            }
+        };
+
+        GrammarCheckerWalker.prototype.checkFunctionOverloads = function (node, moduleElements) {
+            if (!this.inAmbientDeclaration && !this.syntaxTree.isDeclaration()) {
+                var moduleElementFullStart = this.childFullStart(node, moduleElements);
+
+                var inFunctionOverloadChain = false;
+                var functionOverloadChainName = null;
+
+                for (var i = 0, n = moduleElements.childCount(); i < n; i++) {
+                    var moduleElement = moduleElements.childAt(i);
+                    var lastElement = i === (n - 1);
+
+                    if (inFunctionOverloadChain) {
+                        if (moduleElement.kind() !== 129 /* FunctionDeclaration */) {
+                            this.pushDiagnostic1(moduleElementFullStart, moduleElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected);
+                            return true;
+                        }
+
+                        var functionDeclaration = moduleElement;
+                        if (functionDeclaration.identifier.valueText() !== functionOverloadChainName) {
+                            var identifierFullStart = moduleElementFullStart + TypeScript.Syntax.childOffset(moduleElement, functionDeclaration.identifier);
+                            this.pushDiagnostic1(identifierFullStart, functionDeclaration.identifier, TypeScript.DiagnosticCode.Function_overload_name_must_be_0, [functionOverloadChainName]);
+                            return true;
+                        }
+                    }
+
+                    if (moduleElement.kind() === 129 /* FunctionDeclaration */) {
+                        functionDeclaration = moduleElement;
+                        if (!TypeScript.SyntaxUtilities.containsToken(functionDeclaration.modifiers, 63 /* DeclareKeyword */)) {
+                            inFunctionOverloadChain = functionDeclaration.block === null;
+                            functionOverloadChainName = functionDeclaration.identifier.valueText();
+
+                            if (inFunctionOverloadChain) {
+                                if (lastElement) {
+                                    this.pushDiagnostic1(moduleElementFullStart, moduleElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected);
+                                    return true;
+                                } else {
+                                    var nextElement = moduleElements.childAt(i + 1);
+                                    if (nextElement.kind() === 129 /* FunctionDeclaration */) {
+                                        var nextFunction = nextElement;
+
+                                        if (nextFunction.identifier.valueText() !== functionOverloadChainName && nextFunction.block === null) {
+                                            var identifierFullStart = moduleElementFullStart + TypeScript.Syntax.childOffset(moduleElement, functionDeclaration.identifier);
+                                            this.pushDiagnostic1(identifierFullStart, functionDeclaration.identifier, TypeScript.DiagnosticCode.Function_implementation_expected);
+                                            return true;
+                                        }
+                                    }
+                                }
+                            }
+                        } else {
+                            inFunctionOverloadChain = false;
+                            functionOverloadChainName = "";
+                        }
+                    }
+
+                    moduleElementFullStart += moduleElement.fullWidth();
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkClassOverloads = function (node) {
+            if (!this.inAmbientDeclaration && !TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */)) {
+                var classElementFullStart = this.childFullStart(node, node.classElements);
+
+                var inFunctionOverloadChain = false;
+                var inConstructorOverloadChain = false;
+
+                var functionOverloadChainName = null;
+                var isInStaticOverloadChain = null;
+                var memberFunctionDeclaration = null;
+
+                for (var i = 0, n = node.classElements.childCount(); i < n; i++) {
+                    var classElement = node.classElements.childAt(i);
+                    var lastElement = i === (n - 1);
+                    var isStaticOverload = null;
+
+                    if (inFunctionOverloadChain) {
+                        if (classElement.kind() !== 135 /* MemberFunctionDeclaration */) {
+                            this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected);
+                            return true;
+                        }
+
+                        memberFunctionDeclaration = classElement;
+                        if (memberFunctionDeclaration.propertyName.valueText() !== functionOverloadChainName) {
+                            var propertyNameFullStart = classElementFullStart + TypeScript.Syntax.childOffset(classElement, memberFunctionDeclaration.propertyName);
+                            this.pushDiagnostic1(propertyNameFullStart, memberFunctionDeclaration.propertyName, TypeScript.DiagnosticCode.Function_overload_name_must_be_0, [functionOverloadChainName]);
+                            return true;
+                        }
+
+                        isStaticOverload = TypeScript.SyntaxUtilities.containsToken(memberFunctionDeclaration.modifiers, 58 /* StaticKeyword */);
+                        if (isStaticOverload !== isInStaticOverloadChain) {
+                            var propertyNameFullStart = classElementFullStart + TypeScript.Syntax.childOffset(classElement, memberFunctionDeclaration.propertyName);
+                            var diagnostic = isInStaticOverloadChain ? TypeScript.DiagnosticCode.Function_overload_must_be_static : TypeScript.DiagnosticCode.Function_overload_must_not_be_static;
+                            this.pushDiagnostic1(propertyNameFullStart, memberFunctionDeclaration.propertyName, diagnostic, null);
+                            return true;
+                        }
+                    } else if (inConstructorOverloadChain) {
+                        if (classElement.kind() !== 137 /* ConstructorDeclaration */) {
+                            this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Constructor_implementation_expected);
+                            return true;
+                        }
+                    }
+
+                    if (classElement.kind() === 135 /* MemberFunctionDeclaration */) {
+                        memberFunctionDeclaration = classElement;
+
+                        inFunctionOverloadChain = memberFunctionDeclaration.block === null;
+                        functionOverloadChainName = memberFunctionDeclaration.propertyName.valueText();
+                        isInStaticOverloadChain = TypeScript.SyntaxUtilities.containsToken(memberFunctionDeclaration.modifiers, 58 /* StaticKeyword */);
+
+                        if (inFunctionOverloadChain) {
+                            if (lastElement) {
+                                this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected);
+                                return true;
+                            } else {
+                                var nextElement = node.classElements.childAt(i + 1);
+                                if (nextElement.kind() === 135 /* MemberFunctionDeclaration */) {
+                                    var nextMemberFunction = nextElement;
+
+                                    if (nextMemberFunction.propertyName.valueText() !== functionOverloadChainName && nextMemberFunction.block === null) {
+                                        var propertyNameFullStart = classElementFullStart + TypeScript.Syntax.childOffset(classElement, memberFunctionDeclaration.propertyName);
+                                        this.pushDiagnostic1(propertyNameFullStart, memberFunctionDeclaration.propertyName, TypeScript.DiagnosticCode.Function_implementation_expected);
+                                        return true;
+                                    }
+                                }
+                            }
+                        }
+                    } else if (classElement.kind() === 137 /* ConstructorDeclaration */) {
+                        var constructorDeclaration = classElement;
+
+                        inConstructorOverloadChain = constructorDeclaration.block === null;
+                        if (lastElement && inConstructorOverloadChain) {
+                            this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Constructor_implementation_expected);
+                            return true;
+                        }
+                    }
+
+                    classElementFullStart += classElement.fullWidth();
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkForReservedName = function (parent, name, diagnosticKey) {
+            var nameFullStart = this.childFullStart(parent, name);
+            var token;
+            var tokenFullStart;
+
+            var current = name;
+            while (current !== null) {
+                if (current.kind() === 121 /* QualifiedName */) {
+                    var qualifiedName = current;
+                    token = qualifiedName.right;
+                    tokenFullStart = nameFullStart + this.childFullStart(qualifiedName, token);
+                    current = qualifiedName.left;
+                } else {
+                    TypeScript.Debug.assert(current.kind() === 11 /* IdentifierName */);
+                    token = current;
+                    tokenFullStart = nameFullStart;
+                    current = null;
+                }
+
+                switch (token.valueText()) {
+                    case "any":
+                    case "number":
+                    case "boolean":
+                    case "string":
+                    case "void":
+                        this.pushDiagnostic(tokenFullStart + token.leadingTriviaWidth(), token.width(), diagnosticKey, [token.valueText()]);
+                        return true;
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitClassDeclaration = function (node) {
+            if (this.checkForReservedName(node, node.identifier, TypeScript.DiagnosticCode.Class_name_cannot_be_0) || this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForRequiredDeclareModifier(node, node.classKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers) || this.checkClassDeclarationHeritageClauses(node) || this.checkClassOverloads(node)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */);
+            _super.prototype.visitClassDeclaration.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.checkInterfaceDeclarationHeritageClauses = function (node) {
+            var heritageClauseFullStart = this.childFullStart(node, node.heritageClauses);
+
+            var seenExtendsClause = false;
+
+            for (var i = 0, n = node.heritageClauses.childCount(); i < n; i++) {
+                TypeScript.Debug.assert(i <= 1);
+                var heritageClause = node.heritageClauses.childAt(i);
+
+                if (heritageClause.extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */) {
+                    if (seenExtendsClause) {
+                        this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.extends_clause_already_seen);
+                        return true;
+                    }
+
+                    seenExtendsClause = true;
+                } else {
+                    TypeScript.Debug.assert(heritageClause.extendsOrImplementsKeyword.tokenKind === 51 /* ImplementsKeyword */);
+                    this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.Interface_declaration_cannot_have_implements_clause);
+                    return true;
+                }
+
+                heritageClauseFullStart += heritageClause.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkInterfaceModifiers = function (modifiers) {
+            var modifierFullStart = this.position();
+
+            for (var i = 0, n = modifiers.childCount(); i < n; i++) {
+                var modifier = modifiers.childAt(i);
+                if (modifier.tokenKind === 63 /* DeclareKeyword */) {
+                    this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.declare_modifier_cannot_appear_on_an_interface_declaration);
+                    return true;
+                }
+
+                modifierFullStart += modifier.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitInterfaceDeclaration = function (node) {
+            if (this.checkForReservedName(node, node.identifier, TypeScript.DiagnosticCode.Interface_name_cannot_be_0) || this.checkInterfaceModifiers(node.modifiers) || this.checkModuleElementModifiers(node.modifiers) || this.checkInterfaceDeclarationHeritageClauses(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitInterfaceDeclaration.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkClassElementModifiers = function (list) {
+            var modifierFullStart = this.position();
+
+            var seenAccessibilityModifier = false;
+            var seenStaticModifier = false;
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var modifier = list.childAt(i);
+                if (modifier.tokenKind === 57 /* PublicKeyword */ || modifier.tokenKind === 55 /* PrivateKeyword */) {
+                    if (seenAccessibilityModifier) {
+                        this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Accessibility_modifier_already_seen);
+                        return true;
+                    }
+
+                    if (seenStaticModifier) {
+                        var previousToken = list.childAt(i - 1);
+                        this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_must_precede_1_modifier, [modifier.text(), previousToken.text()]);
+                        return true;
+                    }
+
+                    seenAccessibilityModifier = true;
+                } else if (modifier.tokenKind === 58 /* StaticKeyword */) {
+                    if (seenStaticModifier) {
+                        this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_already_seen, [modifier.text()]);
+                        return true;
+                    }
+
+                    seenStaticModifier = true;
+                } else {
+                    this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_class_element, [modifier.text()]);
+                    return true;
+                }
+
+                modifierFullStart += modifier.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitMemberVariableDeclaration = function (node) {
+            if (this.checkClassElementModifiers(node.modifiers)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitMemberVariableDeclaration.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitMemberFunctionDeclaration = function (node) {
+            if (this.checkClassElementModifiers(node.modifiers)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitMemberFunctionDeclaration.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkGetAccessorParameter = function (node, getKeyword, parameterList) {
+            var getKeywordFullStart = this.childFullStart(node, getKeyword);
+            if (parameterList.parameters.childCount() !== 0) {
+                this.pushDiagnostic1(getKeywordFullStart, getKeyword, TypeScript.DiagnosticCode.get_accessor_cannot_have_parameters);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitIndexMemberDeclaration = function (node) {
+            if (this.checkIndexMemberModifiers(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitIndexMemberDeclaration.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkIndexMemberModifiers = function (node) {
+            if (node.modifiers.childCount() > 0) {
+                var modifierFullStart = this.childFullStart(node, node.modifiers);
+                this.pushDiagnostic1(modifierFullStart, node.modifiers.childAt(0), TypeScript.DiagnosticCode.Modifiers_cannot_appear_here);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkEcmaScriptVersionIsAtLeast = function (parent, node, languageVersion, diagnosticKey) {
+            if (this.syntaxTree.parseOptions().languageVersion() < languageVersion) {
+                var nodeFullStart = this.childFullStart(parent, node);
+                this.pushDiagnostic1(nodeFullStart, node, diagnosticKey);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitObjectLiteralExpression = function (node) {
+            var savedInObjectLiteralExpression = this.inObjectLiteralExpression;
+            this.inObjectLiteralExpression = true;
+            _super.prototype.visitObjectLiteralExpression.call(this, node);
+            this.inObjectLiteralExpression = savedInObjectLiteralExpression;
+        };
+
+        GrammarCheckerWalker.prototype.visitGetAccessor = function (node) {
+            if (this.checkForAccessorDeclarationInAmbientContext(node) || this.checkEcmaScriptVersionIsAtLeast(node, node.getKeyword, 1 /* EcmaScript5 */, TypeScript.DiagnosticCode.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkClassElementModifiers(node.modifiers) || this.checkGetAccessorParameter(node, node.getKeyword, node.parameterList)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitGetAccessor.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkForAccessorDeclarationInAmbientContext = function (accessor) {
+            if (this.inAmbientDeclaration) {
+                this.pushDiagnostic1(this.position(), accessor, TypeScript.DiagnosticCode.Accessors_are_not_allowed_in_ambient_contexts, null);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkSetAccessorParameter = function (node, setKeyword, parameterList) {
+            var setKeywordFullStart = this.childFullStart(node, setKeyword);
+            if (parameterList.parameters.childCount() !== 1) {
+                this.pushDiagnostic1(setKeywordFullStart, setKeyword, TypeScript.DiagnosticCode.set_accessor_must_have_one_and_only_one_parameter);
+                return true;
+            }
+
+            var parameterListFullStart = this.childFullStart(node, parameterList);
+            var parameterFullStart = parameterListFullStart + TypeScript.Syntax.childOffset(parameterList, parameterList.openParenToken);
+            var parameter = parameterList.parameters.childAt(0);
+
+            if (parameter.questionToken) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.set_accessor_parameter_cannot_be_optional);
+                return true;
+            }
+
+            if (parameter.equalsValueClause) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.set_accessor_parameter_cannot_have_an_initializer);
+                return true;
+            }
+
+            if (parameter.dotDotDotToken) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.set_accessor_cannot_have_rest_parameter);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitSetAccessor = function (node) {
+            if (this.checkForAccessorDeclarationInAmbientContext(node) || this.checkEcmaScriptVersionIsAtLeast(node, node.setKeyword, 1 /* EcmaScript5 */, TypeScript.DiagnosticCode.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkClassElementModifiers(node.modifiers) || this.checkSetAccessorParameter(node, node.setKeyword, node.parameterList)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitSetAccessor.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitEnumDeclaration = function (node) {
+            if (this.checkForReservedName(node, node.identifier, TypeScript.DiagnosticCode.Enum_name_cannot_be_0) || this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForRequiredDeclareModifier(node, node.enumKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers), this.checkEnumElements(node)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */);
+            _super.prototype.visitEnumDeclaration.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.checkEnumElements = function (node) {
+            var enumElementFullStart = this.childFullStart(node, node.enumElements);
+
+            var previousValueWasComputed = false;
+            for (var i = 0, n = node.enumElements.childCount(); i < n; i++) {
+                var child = node.enumElements.childAt(i);
+
+                if (i % 2 === 0) {
+                    var enumElement = child;
+
+                    if (!enumElement.equalsValueClause && previousValueWasComputed) {
+                        this.pushDiagnostic1(enumElementFullStart, enumElement, TypeScript.DiagnosticCode.Enum_member_must_have_initializer, null);
+                        return true;
+                    }
+
+                    if (enumElement.equalsValueClause) {
+                        var value = enumElement.equalsValueClause.value;
+                        previousValueWasComputed = !TypeScript.Syntax.isIntegerLiteral(value);
+                    }
+                }
+
+                enumElementFullStart += child.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitEnumElement = function (node) {
+            if (this.inAmbientDeclaration && node.equalsValueClause) {
+                var expression = node.equalsValueClause.value;
+                if (!TypeScript.Syntax.isIntegerLiteral(expression)) {
+                    this.pushDiagnostic1(this.childFullStart(node, node.equalsValueClause), node.equalsValueClause.firstToken(), TypeScript.DiagnosticCode.Ambient_enum_elements_can_only_have_integer_literal_initializers);
+                    this.skip(node);
+                    return;
+                }
+            }
+
+            _super.prototype.visitEnumElement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitInvocationExpression = function (node) {
+            if (node.expression.kind() === 50 /* SuperKeyword */ && node.argumentList.typeArgumentList !== null) {
+                this.pushDiagnostic1(this.position(), node, TypeScript.DiagnosticCode.super_invocation_cannot_have_type_arguments);
+            }
+
+            _super.prototype.visitInvocationExpression.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkModuleElementModifiers = function (modifiers) {
+            var modifierFullStart = this.position();
+            var seenExportModifier = false;
+            var seenDeclareModifier = false;
+
+            for (var i = 0, n = modifiers.childCount(); i < n; i++) {
+                var modifier = modifiers.childAt(i);
+                if (modifier.tokenKind === 57 /* PublicKeyword */ || modifier.tokenKind === 55 /* PrivateKeyword */ || modifier.tokenKind === 58 /* StaticKeyword */) {
+                    this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_module_element, [modifier.text()]);
+                    return true;
+                }
+
+                if (modifier.tokenKind === 63 /* DeclareKeyword */) {
+                    if (seenDeclareModifier) {
+                        this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Accessibility_modifier_already_seen);
+                        return;
+                    }
+
+                    seenDeclareModifier = true;
+                } else if (modifier.tokenKind === 47 /* ExportKeyword */) {
+                    if (seenExportModifier) {
+                        this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_already_seen, [modifier.text()]);
+                        return;
+                    }
+
+                    if (seenDeclareModifier) {
+                        this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_must_precede_1_modifier, [TypeScript.SyntaxFacts.getText(47 /* ExportKeyword */), TypeScript.SyntaxFacts.getText(63 /* DeclareKeyword */)]);
+                        return;
+                    }
+
+                    seenExportModifier = true;
+                }
+
+                modifierFullStart += modifier.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkForDisallowedImportDeclaration = function (node) {
+            var currentElementFullStart = this.childFullStart(node, node.moduleElements);
+
+            for (var i = 0, n = node.moduleElements.childCount(); i < n; i++) {
+                var child = node.moduleElements.childAt(i);
+                if (child.kind() === 133 /* ImportDeclaration */) {
+                    var importDeclaration = child;
+                    if (importDeclaration.moduleReference.kind() === 245 /* ExternalModuleReference */) {
+                        if (node.stringLiteral === null) {
+                            this.pushDiagnostic1(currentElementFullStart, importDeclaration, TypeScript.DiagnosticCode.Import_declarations_in_an_internal_module_cannot_reference_an_external_module, null);
+                        }
+                    }
+                }
+
+                currentElementFullStart += child.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkForDisallowedDeclareModifierOnImportDeclaration = function (modifiers) {
+            var declareToken = TypeScript.SyntaxUtilities.getToken(modifiers, 63 /* DeclareKeyword */);
+
+            if (declareToken) {
+                this.pushDiagnostic1(this.childFullStart(modifiers, declareToken), declareToken, TypeScript.DiagnosticCode.declare_modifier_not_allowed_on_import_declaration);
+                return true;
+            }
+        };
+
+        GrammarCheckerWalker.prototype.visitImportDeclaration = function (node) {
+            if (this.checkForDisallowedDeclareModifierOnImportDeclaration(node.modifiers) || this.checkModuleElementModifiers(node.modifiers)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitImportDeclaration.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitModuleDeclaration = function (node) {
+            if (this.checkForReservedName(node, node.name, TypeScript.DiagnosticCode.Module_name_cannot_be_0) || this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForRequiredDeclareModifier(node, node.moduleKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers) || this.checkForDisallowedImportDeclaration(node) || this.checkForDisallowedExports(node, node.moduleElements) || this.checkForMultipleExportAssignments(node, node.moduleElements)) {
+                this.skip(node);
+                return;
+            }
+
+            if (!TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */) && this.checkFunctionOverloads(node, node.moduleElements)) {
+                this.skip(node);
+                return;
+            }
+
+            if (node.stringLiteral) {
+                if (!this.inAmbientDeclaration && !TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */)) {
+                    var stringLiteralFullStart = this.childFullStart(node, node.stringLiteral);
+                    this.pushDiagnostic1(stringLiteralFullStart, node.stringLiteral, TypeScript.DiagnosticCode.Only_ambient_modules_can_use_quoted_names);
+                    this.skip(node);
+                    return;
+                }
+            }
+
+            if (!node.stringLiteral && this.checkForDisallowedExportAssignment(node)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */);
+            _super.prototype.visitModuleDeclaration.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.checkForDisallowedExports = function (node, moduleElements) {
+            var seenExportedElement = false;
+            for (var i = 0, n = moduleElements.childCount(); i < n; i++) {
+                var child = moduleElements.childAt(i);
+
+                if (TypeScript.SyntaxUtilities.hasExportKeyword(child)) {
+                    seenExportedElement = true;
+                    break;
+                }
+            }
+
+            var moduleElementFullStart = this.childFullStart(node, moduleElements);
+            if (seenExportedElement) {
+                for (var i = 0, n = moduleElements.childCount(); i < n; i++) {
+                    var child = moduleElements.childAt(i);
+
+                    if (child.kind() === 134 /* ExportAssignment */) {
+                        this.pushDiagnostic1(moduleElementFullStart, child, TypeScript.DiagnosticCode.Export_assignment_not_allowed_in_module_with_exported_element);
+                        return true;
+                    }
+
+                    moduleElementFullStart += child.fullWidth();
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkForMultipleExportAssignments = function (node, moduleElements) {
+            var moduleElementFullStart = this.childFullStart(node, moduleElements);
+            var seenExportAssignment = false;
+            var errorFound = false;
+            for (var i = 0, n = moduleElements.childCount(); i < n; i++) {
+                var child = moduleElements.childAt(i);
+                if (child.kind() === 134 /* ExportAssignment */) {
+                    if (seenExportAssignment) {
+                        this.pushDiagnostic1(moduleElementFullStart, child, TypeScript.DiagnosticCode.Module_cannot_have_multiple_export_assignments);
+                        errorFound = true;
+                    }
+                    seenExportAssignment = true;
+                }
+
+                moduleElementFullStart += child.fullWidth();
+            }
+
+            return errorFound;
+        };
+
+        GrammarCheckerWalker.prototype.checkForDisallowedExportAssignment = function (node) {
+            var moduleElementFullStart = this.childFullStart(node, node.moduleElements);
+
+            for (var i = 0, n = node.moduleElements.childCount(); i < n; i++) {
+                var child = node.moduleElements.childAt(i);
+
+                if (child.kind() === 134 /* ExportAssignment */) {
+                    this.pushDiagnostic1(moduleElementFullStart, child, TypeScript.DiagnosticCode.Export_assignment_cannot_be_used_in_internal_modules);
+
+                    return true;
+                }
+
+                moduleElementFullStart += child.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitBlock = function (node) {
+            if (this.inAmbientDeclaration || this.syntaxTree.isDeclaration()) {
+                this.pushDiagnostic1(this.position(), node.firstToken(), TypeScript.DiagnosticCode.Implementations_are_not_allowed_in_ambient_contexts);
+                this.skip(node);
+                return;
+            }
+
+            if (this.checkFunctionOverloads(node, node.statements)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedInBlock = this.inBlock;
+            this.inBlock = true;
+            _super.prototype.visitBlock.call(this, node);
+            this.inBlock = savedInBlock;
+        };
+
+        GrammarCheckerWalker.prototype.checkForStatementInAmbientContxt = function (node) {
+            if (this.inAmbientDeclaration || this.syntaxTree.isDeclaration()) {
+                this.pushDiagnostic1(this.position(), node.firstToken(), TypeScript.DiagnosticCode.Statements_are_not_allowed_in_ambient_contexts);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitBreakStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitBreakStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitContinueStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitContinueStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitDebuggerStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitDebuggerStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitDoStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitDoStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitEmptyStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitEmptyStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitExpressionStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitExpressionStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitForInStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node) || this.checkForInStatementVariableDeclaration(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitForInStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkForInStatementVariableDeclaration = function (node) {
+            if (node.variableDeclaration && node.variableDeclaration.variableDeclarators.nonSeparatorCount() > 1) {
+                var variableDeclarationFullStart = this.childFullStart(node, node.variableDeclaration);
+
+                this.pushDiagnostic1(variableDeclarationFullStart, node.variableDeclaration, TypeScript.DiagnosticCode.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitForStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitForStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitIfStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitIfStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitLabeledStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitLabeledStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitReturnStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitReturnStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitSwitchStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitSwitchStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitThrowStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitThrowStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitTryStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitTryStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitWhileStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitWhileStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitWithStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitWithStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkForDisallowedModifiers = function (parent, modifiers) {
+            if (this.inBlock || this.inObjectLiteralExpression) {
+                if (modifiers.childCount() > 0) {
+                    var modifierFullStart = this.childFullStart(parent, modifiers);
+                    this.pushDiagnostic1(modifierFullStart, modifiers.childAt(0), TypeScript.DiagnosticCode.Modifiers_cannot_appear_here);
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitFunctionDeclaration = function (node) {
+            if (this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkForRequiredDeclareModifier(node, node.functionKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */);
+            _super.prototype.visitFunctionDeclaration.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.visitVariableStatement = function (node) {
+            if (this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkForRequiredDeclareModifier(node, node.variableDeclaration, node.modifiers) || this.checkModuleElementModifiers(node.modifiers)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */);
+            _super.prototype.visitVariableStatement.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.checkListSeparators = function (parent, list, kind) {
+            var currentElementFullStart = this.childFullStart(parent, list);
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var child = list.childAt(i);
+                if (i % 2 === 1 && child.kind() !== kind) {
+                    this.pushDiagnostic1(currentElementFullStart, child, TypeScript.DiagnosticCode._0_expected, [TypeScript.SyntaxFacts.getText(kind)]);
+                }
+
+                currentElementFullStart += child.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitObjectType = function (node) {
+            if (this.checkListSeparators(node, node.typeMembers, 78 /* SemicolonToken */)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = true;
+            _super.prototype.visitObjectType.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.visitArrayType = function (node) {
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = true;
+            _super.prototype.visitArrayType.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.visitFunctionType = function (node) {
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = true;
+            _super.prototype.visitFunctionType.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.visitConstructorType = function (node) {
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = true;
+            _super.prototype.visitConstructorType.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.visitVariableDeclarator = function (node) {
+            if (this.inAmbientDeclaration && node.equalsValueClause) {
+                this.pushDiagnostic1(this.childFullStart(node, node.equalsValueClause), node.equalsValueClause.firstToken(), TypeScript.DiagnosticCode.Initializers_are_not_allowed_in_ambient_contexts);
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitVariableDeclarator.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitConstructorDeclaration = function (node) {
+            if (this.checkClassElementModifiers(node.modifiers) || this.checkConstructorModifiers(node.modifiers) || this.checkConstructorTypeParameterList(node) || this.checkConstructorTypeAnnotation(node)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedCurrentConstructor = this.currentConstructor;
+            this.currentConstructor = node;
+            _super.prototype.visitConstructorDeclaration.call(this, node);
+            this.currentConstructor = savedCurrentConstructor;
+        };
+
+        GrammarCheckerWalker.prototype.checkConstructorModifiers = function (modifiers) {
+            var currentElementFullStart = this.position();
+
+            for (var i = 0, n = modifiers.childCount(); i < n; i++) {
+                var child = modifiers.childAt(i);
+                if (child.kind() !== 57 /* PublicKeyword */) {
+                    this.pushDiagnostic1(currentElementFullStart, child, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_constructor_declaration, [TypeScript.SyntaxFacts.getText(child.kind())]);
+                    return true;
+                }
+
+                currentElementFullStart += child.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkConstructorTypeParameterList = function (node) {
+            var currentElementFullStart = this.position();
+
+            if (node.callSignature.typeParameterList) {
+                var callSignatureFullStart = this.childFullStart(node, node.callSignature);
+                var typeParameterListFullStart = callSignatureFullStart + TypeScript.Syntax.childOffset(node.callSignature, node.callSignature.typeAnnotation);
+                this.pushDiagnostic1(callSignatureFullStart, node.callSignature.typeParameterList, TypeScript.DiagnosticCode.Type_parameters_cannot_appear_on_a_constructor_declaration);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkConstructorTypeAnnotation = function (node) {
+            var currentElementFullStart = this.position();
+
+            if (node.callSignature.typeAnnotation) {
+                var callSignatureFullStart = this.childFullStart(node, node.callSignature);
+                var typeAnnotationFullStart = callSignatureFullStart + TypeScript.Syntax.childOffset(node.callSignature, node.callSignature.typeAnnotation);
+                this.pushDiagnostic1(typeAnnotationFullStart, node.callSignature.typeAnnotation, TypeScript.DiagnosticCode.Type_annotation_cannot_appear_on_a_constructor_declaration);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitSourceUnit = function (node) {
+            if (this.checkFunctionOverloads(node, node.moduleElements) || this.checkForDisallowedExports(node, node.moduleElements) || this.checkForMultipleExportAssignments(node, node.moduleElements)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitSourceUnit.call(this, node);
+        };
+        return GrammarCheckerWalker;
+    })(TypeScript.PositionTrackingWalker);
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var Unicode = (function () {
+        function Unicode() {
+        }
+        Unicode.lookupInUnicodeMap = function (code, map) {
+            if (code < map[0]) {
+                return false;
+            }
+
+            var lo = 0;
+            var hi = map.length;
+            var mid;
+
+            while (lo + 1 < hi) {
+                mid = lo + (hi - lo) / 2;
+
+                mid -= mid % 2;
+                if (map[mid] <= code && code <= map[mid + 1]) {
+                    return true;
+                }
+
+                if (code < map[mid]) {
+                    hi = mid;
+                } else {
+                    lo = mid + 2;
+                }
+            }
+
+            return false;
+        };
+
+        Unicode.isIdentifierStart = function (code, languageVersion) {
+            if (languageVersion === 0 /* EcmaScript3 */) {
+                return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES3IdentifierStart);
+            } else if (languageVersion === 1 /* EcmaScript5 */) {
+                return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES5IdentifierStart);
+            } else {
+                throw TypeScript.Errors.argumentOutOfRange("languageVersion");
+            }
+        };
+
+        Unicode.isIdentifierPart = function (code, languageVersion) {
+            if (languageVersion === 0 /* EcmaScript3 */) {
+                return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES3IdentifierPart);
+            } else if (languageVersion === 1 /* EcmaScript5 */) {
+                return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES5IdentifierPart);
+            } else {
+                throw TypeScript.Errors.argumentOutOfRange("languageVersion");
+            }
+        };
+        Unicode.unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
+        Unicode.unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
+
+        Unicode.unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
+        Unicode.unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
+        return Unicode;
+    })();
+    TypeScript.Unicode = Unicode;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (CompilerDiagnostics) {
+        CompilerDiagnostics.debug = false;
+
+        CompilerDiagnostics.diagnosticWriter = null;
+
+        CompilerDiagnostics.analysisPass = 0;
+
+        function Alert(output) {
+            if (CompilerDiagnostics.diagnosticWriter) {
+                CompilerDiagnostics.diagnosticWriter.Alert(output);
+            }
+        }
+        CompilerDiagnostics.Alert = Alert;
+
+        function debugPrint(s) {
+            if (CompilerDiagnostics.debug) {
+                Alert(s);
+            }
+        }
+        CompilerDiagnostics.debugPrint = debugPrint;
+
+        function assert(condition, s) {
+            if (CompilerDiagnostics.debug) {
+                if (!condition) {
+                    Alert(s);
+                }
+            }
+        }
+        CompilerDiagnostics.assert = assert;
+    })(TypeScript.CompilerDiagnostics || (TypeScript.CompilerDiagnostics = {}));
+    var CompilerDiagnostics = TypeScript.CompilerDiagnostics;
+
+    var NullLogger = (function () {
+        function NullLogger() {
+        }
+        NullLogger.prototype.information = function () {
+            return false;
+        };
+        NullLogger.prototype.debug = function () {
+            return false;
+        };
+        NullLogger.prototype.warning = function () {
+            return false;
+        };
+        NullLogger.prototype.error = function () {
+            return false;
+        };
+        NullLogger.prototype.fatal = function () {
+            return false;
+        };
+        NullLogger.prototype.log = function (s) {
+        };
+        return NullLogger;
+    })();
+    TypeScript.NullLogger = NullLogger;
+
+    function timeFunction(logger, funcDescription, func) {
+        var start = (new Date()).getTime();
+        var result = func();
+        var end = (new Date()).getTime();
+        if (logger.information()) {
+            logger.log(funcDescription + " completed in " + (end - start) + " msec");
+        }
+        return result;
+    }
+    TypeScript.timeFunction = timeFunction;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var Document = (function () {
+        function Document(_compiler, _semanticInfoChain, fileName, referencedFiles, _scriptSnapshot, byteOrderMark, version, isOpen, _syntaxTree, _topLevelDecl) {
+            this._compiler = _compiler;
+            this._semanticInfoChain = _semanticInfoChain;
+            this.fileName = fileName;
+            this.referencedFiles = referencedFiles;
+            this._scriptSnapshot = _scriptSnapshot;
+            this.byteOrderMark = byteOrderMark;
+            this.version = version;
+            this.isOpen = isOpen;
+            this._syntaxTree = _syntaxTree;
+            this._topLevelDecl = _topLevelDecl;
+            this._diagnostics = null;
+            this._bloomFilter = null;
+            this._sourceUnit = null;
+            this._lineMap = null;
+            this._declASTMap = [];
+            this._astDeclMap = [];
+            this._amdDependencies = undefined;
+            this._externalModuleIndicatorSpan = undefined;
+        }
+        Document.prototype.invalidate = function () {
+            this._declASTMap.length = 0;
+            this._astDeclMap.length = 0;
+            this._topLevelDecl = null;
+
+            this._syntaxTree = null;
+            this._sourceUnit = null;
+            this._diagnostics = null;
+            this._bloomFilter = null;
+        };
+
+        Document.prototype.isDeclareFile = function () {
+            return TypeScript.isDTSFile(this.fileName);
+        };
+
+        Document.prototype.cacheSyntaxTreeInfo = function (syntaxTree) {
+            var start = new Date().getTime();
+            this._diagnostics = syntaxTree.diagnostics();
+            TypeScript.syntaxDiagnosticsTime += new Date().getTime() - start;
+
+            this._lineMap = syntaxTree.lineMap();
+
+            var sourceUnit = syntaxTree.sourceUnit();
+            var leadingTrivia = sourceUnit.leadingTrivia();
+
+            this._externalModuleIndicatorSpan = this.getImplicitImportSpan(leadingTrivia) || this.getTopLevelImportOrExportSpan(sourceUnit);
+
+            var amdDependencies = [];
+            for (var i = 0, n = leadingTrivia.count(); i < n; i++) {
+                var trivia = leadingTrivia.syntaxTriviaAt(i);
+                if (trivia.isComment()) {
+                    var amdDependency = this.getAmdDependency(trivia.fullText());
+                    if (amdDependency) {
+                        amdDependencies.push(amdDependency);
+                    }
+                }
+            }
+
+            this._amdDependencies = amdDependencies;
+        };
+
+        Document.prototype.getAmdDependency = function (comment) {
+            var amdDependencyRegEx = /^\/\/\/\s*<amd-dependency\s+path=('|")(.+?)\1/gim;
+            var match = amdDependencyRegEx.exec(comment);
+            return match ? match[2] : null;
+        };
+
+        Document.prototype.getImplicitImportSpan = function (sourceUnitLeadingTrivia) {
+            var position = 0;
+
+            for (var i = 0, n = sourceUnitLeadingTrivia.count(); i < n; i++) {
+                var trivia = sourceUnitLeadingTrivia.syntaxTriviaAt(i);
+
+                if (trivia.isComment()) {
+                    var span = this.getImplicitImportSpanWorker(trivia, position);
+                    if (span) {
+                        return span;
+                    }
+                }
+
+                position += trivia.fullWidth();
+            }
+
+            return null;
+        };
+
+        Document.prototype.getImplicitImportSpanWorker = function (trivia, position) {
+            var implicitImportRegEx = /^(\/\/\/\s*<implicit-import\s*)*\/>/gim;
+            var match = implicitImportRegEx.exec(trivia.fullText());
+
+            if (match) {
+                return new TypeScript.TextSpan(position, trivia.fullWidth());
+            }
+
+            return null;
+        };
+
+        Document.prototype.getTopLevelImportOrExportSpan = function (node) {
+            var firstToken;
+            var position = 0;
+
+            for (var i = 0, n = node.moduleElements.childCount(); i < n; i++) {
+                var moduleElement = node.moduleElements.childAt(i);
+
+                firstToken = moduleElement.firstToken();
+                if (firstToken !== null && firstToken.tokenKind === 47 /* ExportKeyword */) {
+                    return new TypeScript.TextSpan(position + firstToken.leadingTriviaWidth(), firstToken.width());
+                }
+
+                if (moduleElement.kind() === 133 /* ImportDeclaration */) {
+                    var importDecl = moduleElement;
+                    if (importDecl.moduleReference.kind() === 245 /* ExternalModuleReference */) {
+                        return new TypeScript.TextSpan(position + importDecl.leadingTriviaWidth(), importDecl.width());
+                    }
+                }
+
+                position += moduleElement.fullWidth();
+            }
+
+            return null;
+            ;
+        };
+
+        Document.prototype.sourceUnit = function () {
+            if (!this._sourceUnit) {
+                var start = new Date().getTime();
+                var syntaxTree = this.syntaxTree();
+                this._sourceUnit = TypeScript.SyntaxTreeToAstVisitor.visit(syntaxTree, this.fileName, this._compiler.compilationSettings(), this.isOpen);
+                TypeScript.astTranslationTime += new Date().getTime() - start;
+
+                if (!this.isOpen) {
+                    this._syntaxTree = null;
+                }
+            }
+
+            return this._sourceUnit;
+        };
+
+        Document.prototype.diagnostics = function () {
+            if (this._diagnostics === null) {
+                this.syntaxTree();
+                TypeScript.Debug.assert(this._diagnostics);
+            }
+
+            return this._diagnostics;
+        };
+
+        Document.prototype.lineMap = function () {
+            if (this._lineMap === null) {
+                this.syntaxTree();
+                TypeScript.Debug.assert(this._lineMap);
+            }
+
+            return this._lineMap;
+        };
+
+        Document.prototype.isExternalModule = function () {
+            return this.externalModuleIndicatorSpan() !== null;
+        };
+
+        Document.prototype.externalModuleIndicatorSpan = function () {
+            if (this._externalModuleIndicatorSpan === undefined) {
+                this.syntaxTree();
+                TypeScript.Debug.assert(this._externalModuleIndicatorSpan !== undefined);
+            }
+
+            return this._externalModuleIndicatorSpan;
+        };
+
+        Document.prototype.amdDependencies = function () {
+            if (this._amdDependencies === undefined) {
+                this.syntaxTree();
+                TypeScript.Debug.assert(this._amdDependencies !== undefined);
+            }
+
+            return this._amdDependencies;
+        };
+
+        Document.prototype.syntaxTree = function () {
+            var result = this._syntaxTree;
+            if (!result) {
+                var start = new Date().getTime();
+
+                result = TypeScript.Parser.parse(this.fileName, TypeScript.SimpleText.fromScriptSnapshot(this._scriptSnapshot), TypeScript.isDTSFile(this.fileName), TypeScript.getParseOptions(this._compiler.compilationSettings()));
+
+                TypeScript.syntaxTreeParseTime += new Date().getTime() - start;
+
+                if (this.isOpen || !this._sourceUnit) {
+                    this._syntaxTree = result;
+                }
+            }
+
+            this.cacheSyntaxTreeInfo(result);
+            return result;
+        };
+
+        Document.prototype.bloomFilter = function () {
+            if (!this._bloomFilter) {
+                var identifiers = TypeScript.createIntrinsicsObject();
+                var pre = function (cur) {
+                    if (TypeScript.ASTHelpers.isValidAstNode(cur)) {
+                        if (cur.kind() === 11 /* IdentifierName */) {
+                            var nodeText = cur.valueText();
+
+                            identifiers[nodeText] = true;
+                        }
+                    }
+                };
+
+                TypeScript.getAstWalkerFactory().simpleWalk(this.sourceUnit(), pre, null, identifiers);
+
+                var identifierCount = 0;
+                for (var name in identifiers) {
+                    if (identifiers[name]) {
+                        identifierCount++;
+                    }
+                }
+
+                this._bloomFilter = new TypeScript.BloomFilter(identifierCount);
+                this._bloomFilter.addKeys(identifiers);
+            }
+            return this._bloomFilter;
+        };
+
+        Document.prototype.emitToOwnOutputFile = function () {
+            return !this._compiler.compilationSettings().outFileOption() || this.isExternalModule();
+        };
+
+        Document.prototype.update = function (scriptSnapshot, version, isOpen, textChangeRange) {
+            var oldSyntaxTree = this._syntaxTree;
+
+            if (textChangeRange !== null && TypeScript.Debug.shouldAssert(1 /* Normal */)) {
+                var oldText = this._scriptSnapshot;
+                var newText = scriptSnapshot;
+
+                TypeScript.Debug.assert((oldText.getLength() - textChangeRange.span().length() + textChangeRange.newLength()) === newText.getLength());
+
+                if (TypeScript.Debug.shouldAssert(3 /* VeryAggressive */)) {
+                    var oldTextPrefix = oldText.getText(0, textChangeRange.span().start());
+                    var newTextPrefix = newText.getText(0, textChangeRange.span().start());
+                    TypeScript.Debug.assert(oldTextPrefix === newTextPrefix);
+
+                    var oldTextSuffix = oldText.getText(textChangeRange.span().end(), oldText.getLength());
+                    var newTextSuffix = newText.getText(textChangeRange.newSpan().end(), newText.getLength());
+                    TypeScript.Debug.assert(oldTextSuffix === newTextSuffix);
+                }
+            }
+
+            var text = TypeScript.SimpleText.fromScriptSnapshot(scriptSnapshot);
+
+            var newSyntaxTree = textChangeRange === null || oldSyntaxTree === null ? TypeScript.Parser.parse(this.fileName, text, TypeScript.isDTSFile(this.fileName), TypeScript.getParseOptions(this._compiler.compilationSettings())) : TypeScript.Parser.incrementalParse(oldSyntaxTree, textChangeRange, text);
+
+            return new Document(this._compiler, this._semanticInfoChain, this.fileName, this.referencedFiles, scriptSnapshot, this.byteOrderMark, version, isOpen, newSyntaxTree, null);
+        };
+
+        Document.create = function (compiler, semanticInfoChain, fileName, scriptSnapshot, byteOrderMark, version, isOpen, referencedFiles) {
+            return new Document(compiler, semanticInfoChain, fileName, referencedFiles, scriptSnapshot, byteOrderMark, version, isOpen, null, null);
+        };
+
+        Document.prototype.topLevelDecl = function () {
+            if (this._topLevelDecl === null) {
+                this._topLevelDecl = TypeScript.DeclarationCreator.create(this, this._semanticInfoChain, this._compiler.compilationSettings());
+            }
+
+            return this._topLevelDecl;
+        };
+
+        Document.prototype._getDeclForAST = function (ast) {
+            this.topLevelDecl();
+            return this._astDeclMap[ast.syntaxID()];
+        };
+
+        Document.prototype.getEnclosingDecl = function (ast) {
+            if (ast.kind() === 120 /* SourceUnit */) {
+                return this._getDeclForAST(ast);
+            }
+
+            ast = ast.parent;
+            var decl = null;
+            while (ast) {
+                decl = this._getDeclForAST(ast);
+
+                if (decl) {
+                    break;
+                }
+
+                ast = ast.parent;
+            }
+
+            return decl._getEnclosingDeclFromParentDecl();
+        };
+
+        Document.prototype._setDeclForAST = function (ast, decl) {
+            TypeScript.Debug.assert(decl.fileName() === this.fileName);
+            this._astDeclMap[ast.syntaxID()] = decl;
+        };
+
+        Document.prototype._getASTForDecl = function (decl) {
+            return this._declASTMap[decl.declID];
+        };
+
+        Document.prototype._setASTForDecl = function (decl, ast) {
+            TypeScript.Debug.assert(decl.fileName() === this.fileName);
+            this._declASTMap[decl.declID] = ast;
+        };
+        return Document;
+    })();
+    TypeScript.Document = Document;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    function hasFlag(val, flag) {
+        return (val & flag) !== 0;
+    }
+    TypeScript.hasFlag = hasFlag;
+
+    (function (TypeRelationshipFlags) {
+        TypeRelationshipFlags[TypeRelationshipFlags["SuccessfulComparison"] = 0] = "SuccessfulComparison";
+        TypeRelationshipFlags[TypeRelationshipFlags["RequiredPropertyIsMissing"] = 1 << 1] = "RequiredPropertyIsMissing";
+        TypeRelationshipFlags[TypeRelationshipFlags["IncompatibleSignatures"] = 1 << 2] = "IncompatibleSignatures";
+        TypeRelationshipFlags[TypeRelationshipFlags["SourceSignatureHasTooManyParameters"] = 3] = "SourceSignatureHasTooManyParameters";
+        TypeRelationshipFlags[TypeRelationshipFlags["IncompatibleReturnTypes"] = 1 << 4] = "IncompatibleReturnTypes";
+        TypeRelationshipFlags[TypeRelationshipFlags["IncompatiblePropertyTypes"] = 1 << 5] = "IncompatiblePropertyTypes";
+        TypeRelationshipFlags[TypeRelationshipFlags["IncompatibleParameterTypes"] = 1 << 6] = "IncompatibleParameterTypes";
+        TypeRelationshipFlags[TypeRelationshipFlags["InconsistantPropertyAccesibility"] = 1 << 7] = "InconsistantPropertyAccesibility";
+    })(TypeScript.TypeRelationshipFlags || (TypeScript.TypeRelationshipFlags = {}));
+    var TypeRelationshipFlags = TypeScript.TypeRelationshipFlags;
+
+    (function (ModuleGenTarget) {
+        ModuleGenTarget[ModuleGenTarget["Unspecified"] = 0] = "Unspecified";
+        ModuleGenTarget[ModuleGenTarget["Synchronous"] = 1] = "Synchronous";
+        ModuleGenTarget[ModuleGenTarget["Asynchronous"] = 2] = "Asynchronous";
+    })(TypeScript.ModuleGenTarget || (TypeScript.ModuleGenTarget = {}));
+    var ModuleGenTarget = TypeScript.ModuleGenTarget;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var proto = "__proto__";
+
+    var BlockIntrinsics = (function () {
+        function BlockIntrinsics() {
+            this.prototype = undefined;
+            this.toString = undefined;
+            this.toLocaleString = undefined;
+            this.valueOf = undefined;
+            this.hasOwnProperty = undefined;
+            this.propertyIsEnumerable = undefined;
+            this.isPrototypeOf = undefined;
+            this["constructor"] = undefined;
+
+            this[proto] = null;
+            this[proto] = undefined;
+        }
+        return BlockIntrinsics;
+    })();
+
+    function createIntrinsicsObject() {
+        return new BlockIntrinsics();
+    }
+    TypeScript.createIntrinsicsObject = createIntrinsicsObject;
+
+    var StringHashTable = (function () {
+        function StringHashTable() {
+            this.itemCount = 0;
+            this.table = createIntrinsicsObject();
+        }
+        StringHashTable.prototype.getAllKeys = function () {
+            var result = [];
+
+            for (var k in this.table) {
+                if (this.table[k] !== undefined) {
+                    result.push(k);
+                }
+            }
+
+            return result;
+        };
+
+        StringHashTable.prototype.add = function (key, data) {
+            if (this.table[key] !== undefined) {
+                return false;
+            }
+
+            this.table[key] = data;
+            this.itemCount++;
+            return true;
+        };
+
+        StringHashTable.prototype.addOrUpdate = function (key, data) {
+            if (this.table[key] !== undefined) {
+                this.table[key] = data;
+                return false;
+            }
+
+            this.table[key] = data;
+            this.itemCount++;
+            return true;
+        };
+
+        StringHashTable.prototype.map = function (fn, context) {
+            for (var k in this.table) {
+                var data = this.table[k];
+
+                if (data !== undefined) {
+                    fn(k, this.table[k], context);
+                }
+            }
+        };
+
+        StringHashTable.prototype.every = function (fn, context) {
+            for (var k in this.table) {
+                var data = this.table[k];
+
+                if (data !== undefined) {
+                    if (!fn(k, this.table[k], context)) {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        };
+
+        StringHashTable.prototype.some = function (fn, context) {
+            for (var k in this.table) {
+                var data = this.table[k];
+
+                if (data !== undefined) {
+                    if (fn(k, this.table[k], context)) {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        StringHashTable.prototype.count = function () {
+            return this.itemCount;
+        };
+
+        StringHashTable.prototype.lookup = function (key) {
+            var data = this.table[key];
+            return data === undefined ? null : data;
+        };
+
+        StringHashTable.prototype.remove = function (key) {
+            if (this.table[key] !== undefined) {
+                this.table[key] = undefined;
+                this.itemCount--;
+            }
+        };
+        return StringHashTable;
+    })();
+    TypeScript.StringHashTable = StringHashTable;
+
+    var IdentiferNameHashTable = (function (_super) {
+        __extends(IdentiferNameHashTable, _super);
+        function IdentiferNameHashTable() {
+            _super.apply(this, arguments);
+        }
+        IdentiferNameHashTable.prototype.getAllKeys = function () {
+            var result = [];
+
+            _super.prototype.map.call(this, function (k, v, c) {
+                if (v !== undefined) {
+                    result.push(k.substring(1));
+                }
+            }, null);
+
+            return result;
+        };
+
+        IdentiferNameHashTable.prototype.add = function (key, data) {
+            return _super.prototype.add.call(this, "#" + key, data);
+        };
+
+        IdentiferNameHashTable.prototype.addOrUpdate = function (key, data) {
+            return _super.prototype.addOrUpdate.call(this, "#" + key, data);
+        };
+
+        IdentiferNameHashTable.prototype.map = function (fn, context) {
+            return _super.prototype.map.call(this, function (k, v, c) {
+                return fn(k.substring(1), v, c);
+            }, context);
+        };
+
+        IdentiferNameHashTable.prototype.every = function (fn, context) {
+            return _super.prototype.every.call(this, function (k, v, c) {
+                return fn(k.substring(1), v, c);
+            }, context);
+        };
+
+        IdentiferNameHashTable.prototype.some = function (fn, context) {
+            return _super.prototype.some.call(this, function (k, v, c) {
+                return fn(k.substring(1), v, c);
+            }, context);
+        };
+
+        IdentiferNameHashTable.prototype.lookup = function (key) {
+            return _super.prototype.lookup.call(this, "#" + key);
+        };
+        return IdentiferNameHashTable;
+    })(StringHashTable);
+    TypeScript.IdentiferNameHashTable = IdentiferNameHashTable;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    (function (ASTHelpers) {
+        function scriptIsElided(sourceUnit) {
+            return TypeScript.isDTSFile(sourceUnit.fileName()) || moduleMembersAreElided(sourceUnit.moduleElements);
+        }
+        ASTHelpers.scriptIsElided = scriptIsElided;
+
+        function moduleIsElided(declaration) {
+            return TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */) || moduleMembersAreElided(declaration.moduleElements);
+        }
+        ASTHelpers.moduleIsElided = moduleIsElided;
+
+        function moduleMembersAreElided(members) {
+            for (var i = 0, n = members.childCount(); i < n; i++) {
+                var member = members.childAt(i);
+
+                if (member.kind() === 130 /* ModuleDeclaration */) {
+                    if (!moduleIsElided(member)) {
+                        return false;
+                    }
+                } else if (member.kind() !== 128 /* InterfaceDeclaration */) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        function enumIsElided(declaration) {
+            if (TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */)) {
+                return true;
+            }
+
+            return false;
+        }
+        ASTHelpers.enumIsElided = enumIsElided;
+
+        function isValidAstNode(ast) {
+            if (!ast)
+                return false;
+
+            if (ast.start() === -1 || ast.end() === -1)
+                return false;
+
+            return true;
+        }
+        ASTHelpers.isValidAstNode = isValidAstNode;
+
+        function getAstAtPosition(script, pos, useTrailingTriviaAsLimChar, forceInclusive) {
+            if (typeof useTrailingTriviaAsLimChar === "undefined") { useTrailingTriviaAsLimChar = true; }
+            if (typeof forceInclusive === "undefined") { forceInclusive = false; }
+            var top = null;
+
+            var pre = function (cur, walker) {
+                if (isValidAstNode(cur)) {
+                    var isInvalid1 = cur.kind() === 149 /* ExpressionStatement */ && cur.width() === 0;
+
+                    if (isInvalid1) {
+                        walker.options.goChildren = false;
+                    } else {
+                        var inclusive = forceInclusive || cur.kind() === 11 /* IdentifierName */ || cur.kind() === 212 /* MemberAccessExpression */ || cur.kind() === 121 /* QualifiedName */ || cur.kind() === 224 /* VariableDeclaration */ || cur.kind() === 225 /* VariableDeclarator */ || cur.kind() === 213 /* InvocationExpression */ || pos === script.end() + script.trailingTriviaWidth();
+
+                        var minChar = cur.start();
+                        var limChar = cur.end() + (useTrailingTriviaAsLimChar ? cur.trailingTriviaWidth() : 0) + (inclusive ? 1 : 0);
+                        if (pos >= minChar && pos < limChar) {
+                            if ((cur.kind() !== 1 /* List */ && cur.kind() !== 2 /* SeparatedList */) || cur.end() > cur.start()) {
+                                if (top === null) {
+                                    top = cur;
+                                } else if (cur.start() >= top.start() && (cur.end() + (useTrailingTriviaAsLimChar ? cur.trailingTriviaWidth() : 0)) <= (top.end() + (useTrailingTriviaAsLimChar ? top.trailingTriviaWidth() : 0))) {
+                                    if (top.width() !== 0 || cur.width() !== 0) {
+                                        top = cur;
+                                    }
+                                }
+                            }
+                        }
+
+                        walker.options.goChildren = (minChar <= pos && pos <= limChar);
+                    }
+                }
+            };
+
+            TypeScript.getAstWalkerFactory().walk(script, pre);
+            return top;
+        }
+        ASTHelpers.getAstAtPosition = getAstAtPosition;
+
+        function getExtendsHeritageClause(clauses) {
+            if (!clauses) {
+                return null;
+            }
+
+            return clauses.firstOrDefault(function (c) {
+                return c.typeNames.nonSeparatorCount() > 0 && c.kind() === 230 /* ExtendsHeritageClause */;
+            });
+        }
+        ASTHelpers.getExtendsHeritageClause = getExtendsHeritageClause;
+
+        function getImplementsHeritageClause(clauses) {
+            if (!clauses) {
+                return null;
+            }
+
+            return clauses.firstOrDefault(function (c) {
+                return c.typeNames.nonSeparatorCount() > 0 && c.kind() === 231 /* ImplementsHeritageClause */;
+            });
+        }
+        ASTHelpers.getImplementsHeritageClause = getImplementsHeritageClause;
+
+        function isCallExpression(ast) {
+            return (ast && ast.kind() === 213 /* InvocationExpression */) || (ast && ast.kind() === 216 /* ObjectCreationExpression */);
+        }
+        ASTHelpers.isCallExpression = isCallExpression;
+
+        function isCallExpressionTarget(ast) {
+            if (!ast) {
+                return false;
+            }
+
+            var current = ast;
+
+            while (current && current.parent) {
+                if (current.parent.kind() === 212 /* MemberAccessExpression */ && current.parent.name === current) {
+                    current = current.parent;
+                    continue;
+                }
+
+                break;
+            }
+
+            if (current && current.parent) {
+                if (current.parent.kind() === 213 /* InvocationExpression */ || current.parent.kind() === 216 /* ObjectCreationExpression */) {
+                    return current === current.parent.expression;
+                }
+            }
+
+            return false;
+        }
+        ASTHelpers.isCallExpressionTarget = isCallExpressionTarget;
+
+        function isNameOfSomeDeclaration(ast) {
+            if (ast === null || ast.parent === null) {
+                return false;
+            }
+            if (ast.kind() !== 11 /* IdentifierName */) {
+                return false;
+            }
+
+            switch (ast.parent.kind()) {
+                case 131 /* ClassDeclaration */:
+                    return ast.parent.identifier === ast;
+                case 128 /* InterfaceDeclaration */:
+                    return ast.parent.identifier === ast;
+                case 132 /* EnumDeclaration */:
+                    return ast.parent.identifier === ast;
+                case 130 /* ModuleDeclaration */:
+                    return ast.parent.name === ast || ast.parent.stringLiteral === ast;
+                case 225 /* VariableDeclarator */:
+                    return ast.parent.propertyName === ast;
+                case 129 /* FunctionDeclaration */:
+                    return ast.parent.identifier === ast;
+                case 135 /* MemberFunctionDeclaration */:
+                    return ast.parent.propertyName === ast;
+                case 242 /* Parameter */:
+                    return ast.parent.identifier === ast;
+                case 238 /* TypeParameter */:
+                    return ast.parent.identifier === ast;
+                case 240 /* SimplePropertyAssignment */:
+                    return ast.parent.propertyName === ast;
+                case 241 /* FunctionPropertyAssignment */:
+                    return ast.parent.propertyName === ast;
+                case 243 /* EnumElement */:
+                    return ast.parent.propertyName === ast;
+                case 133 /* ImportDeclaration */:
+                    return ast.parent.identifier === ast;
+            }
+
+            return false;
+        }
+
+        function isDeclarationASTOrDeclarationNameAST(ast) {
+            return isNameOfSomeDeclaration(ast) || isDeclarationAST(ast);
+        }
+        ASTHelpers.isDeclarationASTOrDeclarationNameAST = isDeclarationASTOrDeclarationNameAST;
+
+        function getEnclosingParameterForInitializer(ast) {
+            var current = ast;
+            while (current) {
+                switch (current.kind()) {
+                    case 232 /* EqualsValueClause */:
+                        if (current.parent && current.parent.kind() === 242 /* Parameter */) {
+                            return current.parent;
+                        }
+                        break;
+                    case 131 /* ClassDeclaration */:
+                    case 128 /* InterfaceDeclaration */:
+                    case 130 /* ModuleDeclaration */:
+                        return null;
+                }
+
+                current = current.parent;
+            }
+            return null;
+        }
+        ASTHelpers.getEnclosingParameterForInitializer = getEnclosingParameterForInitializer;
+
+        function getEnclosingMemberVariableDeclaration(ast) {
+            var current = ast;
+
+            while (current) {
+                switch (current.kind()) {
+                    case 136 /* MemberVariableDeclaration */:
+                        return current;
+                    case 131 /* ClassDeclaration */:
+                    case 128 /* InterfaceDeclaration */:
+                    case 130 /* ModuleDeclaration */:
+                        return null;
+                }
+                current = current.parent;
+            }
+
+            return null;
+        }
+        ASTHelpers.getEnclosingMemberVariableDeclaration = getEnclosingMemberVariableDeclaration;
+
+        function isNameOfFunction(ast) {
+            return ast && ast.parent && ast.kind() === 11 /* IdentifierName */ && ast.parent.kind() === 129 /* FunctionDeclaration */ && ast.parent.identifier === ast;
+        }
+        ASTHelpers.isNameOfFunction = isNameOfFunction;
+
+        function isNameOfMemberFunction(ast) {
+            return ast && ast.parent && ast.kind() === 11 /* IdentifierName */ && ast.parent.kind() === 135 /* MemberFunctionDeclaration */ && ast.parent.propertyName === ast;
+        }
+        ASTHelpers.isNameOfMemberFunction = isNameOfMemberFunction;
+
+        function isNameOfMemberAccessExpression(ast) {
+            if (ast && ast.parent && ast.parent.kind() === 212 /* MemberAccessExpression */ && ast.parent.name === ast) {
+                return true;
+            }
+
+            return false;
+        }
+        ASTHelpers.isNameOfMemberAccessExpression = isNameOfMemberAccessExpression;
+
+        function isRightSideOfQualifiedName(ast) {
+            if (ast && ast.parent && ast.parent.kind() === 121 /* QualifiedName */ && ast.parent.right === ast) {
+                return true;
+            }
+
+            return false;
+        }
+        ASTHelpers.isRightSideOfQualifiedName = isRightSideOfQualifiedName;
+
+        function parametersFromIdentifier(id) {
+            return {
+                length: 1,
+                lastParameterIsRest: function () {
+                    return false;
+                },
+                ast: id,
+                astAt: function (index) {
+                    return id;
+                },
+                identifierAt: function (index) {
+                    return id;
+                },
+                typeAt: function (index) {
+                    return null;
+                },
+                initializerAt: function (index) {
+                    return null;
+                },
+                isOptionalAt: function (index) {
+                    return false;
+                }
+            };
+        }
+        ASTHelpers.parametersFromIdentifier = parametersFromIdentifier;
+
+        function parametersFromParameter(parameter) {
+            return {
+                length: 1,
+                lastParameterIsRest: function () {
+                    return parameter.dotDotDotToken !== null;
+                },
+                ast: parameter,
+                astAt: function (index) {
+                    return parameter;
+                },
+                identifierAt: function (index) {
+                    return parameter.identifier;
+                },
+                typeAt: function (index) {
+                    return getType(parameter);
+                },
+                initializerAt: function (index) {
+                    return parameter.equalsValueClause;
+                },
+                isOptionalAt: function (index) {
+                    return parameterIsOptional(parameter);
+                }
+            };
+        }
+        ASTHelpers.parametersFromParameter = parametersFromParameter;
+
+        function parameterIsOptional(parameter) {
+            return parameter.questionToken !== null || parameter.equalsValueClause !== null;
+        }
+
+        function parametersFromParameterList(list) {
+            return {
+                length: list.parameters.nonSeparatorCount(),
+                lastParameterIsRest: function () {
+                    return TypeScript.lastParameterIsRest(list);
+                },
+                ast: list.parameters,
+                astAt: function (index) {
+                    return list.parameters.nonSeparatorAt(index);
+                },
+                identifierAt: function (index) {
+                    return list.parameters.nonSeparatorAt(index).identifier;
+                },
+                typeAt: function (index) {
+                    return getType(list.parameters.nonSeparatorAt(index));
+                },
+                initializerAt: function (index) {
+                    return list.parameters.nonSeparatorAt(index).equalsValueClause;
+                },
+                isOptionalAt: function (index) {
+                    return parameterIsOptional(list.parameters.nonSeparatorAt(index));
+                }
+            };
+        }
+        ASTHelpers.parametersFromParameterList = parametersFromParameterList;
+
+        function isDeclarationAST(ast) {
+            switch (ast.kind()) {
+                case 225 /* VariableDeclarator */:
+                    return getVariableStatement(ast) !== null;
+
+                case 133 /* ImportDeclaration */:
+                case 131 /* ClassDeclaration */:
+                case 128 /* InterfaceDeclaration */:
+                case 242 /* Parameter */:
+                case 219 /* SimpleArrowFunctionExpression */:
+                case 218 /* ParenthesizedArrowFunctionExpression */:
+                case 144 /* IndexSignature */:
+                case 129 /* FunctionDeclaration */:
+                case 130 /* ModuleDeclaration */:
+                case 124 /* ArrayType */:
+                case 122 /* ObjectType */:
+                case 238 /* TypeParameter */:
+                case 137 /* ConstructorDeclaration */:
+                case 135 /* MemberFunctionDeclaration */:
+                case 139 /* GetAccessor */:
+                case 140 /* SetAccessor */:
+                case 136 /* MemberVariableDeclaration */:
+                case 138 /* IndexMemberDeclaration */:
+                case 132 /* EnumDeclaration */:
+                case 243 /* EnumElement */:
+                case 240 /* SimplePropertyAssignment */:
+                case 241 /* FunctionPropertyAssignment */:
+                case 222 /* FunctionExpression */:
+                case 142 /* CallSignature */:
+                case 143 /* ConstructSignature */:
+                case 145 /* MethodSignature */:
+                case 141 /* PropertySignature */:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        ASTHelpers.isDeclarationAST = isDeclarationAST;
+
+        function docComments(ast) {
+            if (isDeclarationAST(ast)) {
+                var preComments = ast.kind() === 225 /* VariableDeclarator */ ? getVariableStatement(ast).preComments() : ast.preComments();
+
+                if (preComments && preComments.length > 0) {
+                    var preCommentsLength = preComments.length;
+                    var docComments = new Array();
+                    for (var i = preCommentsLength - 1; i >= 0; i--) {
+                        if (isDocComment(preComments[i])) {
+                            docComments.push(preComments[i]);
+                            continue;
+                        }
+
+                        break;
+                    }
+
+                    return docComments.reverse();
+                }
+            }
+
+            return TypeScript.sentinelEmptyArray;
+        }
+        ASTHelpers.docComments = docComments;
+
+        function isDocComment(comment) {
+            if (comment.kind() === 6 /* MultiLineCommentTrivia */) {
+                var fullText = comment.fullText();
+                return fullText.charAt(2) === "*" && fullText.charAt(3) !== "/";
+            }
+
+            return false;
+        }
+
+        function getParameterList(ast) {
+            if (ast) {
+                switch (ast.kind()) {
+                    case 137 /* ConstructorDeclaration */:
+                        return getParameterList(ast.callSignature);
+                    case 129 /* FunctionDeclaration */:
+                        return getParameterList(ast.callSignature);
+                    case 218 /* ParenthesizedArrowFunctionExpression */:
+                        return getParameterList(ast.callSignature);
+                    case 143 /* ConstructSignature */:
+                        return getParameterList(ast.callSignature);
+                    case 135 /* MemberFunctionDeclaration */:
+                        return getParameterList(ast.callSignature);
+                    case 241 /* FunctionPropertyAssignment */:
+                        return getParameterList(ast.callSignature);
+                    case 222 /* FunctionExpression */:
+                        return getParameterList(ast.callSignature);
+                    case 145 /* MethodSignature */:
+                        return getParameterList(ast.callSignature);
+                    case 125 /* ConstructorType */:
+                        return ast.parameterList;
+                    case 123 /* FunctionType */:
+                        return ast.parameterList;
+                    case 142 /* CallSignature */:
+                        return ast.parameterList;
+                    case 139 /* GetAccessor */:
+                        return ast.parameterList;
+                    case 140 /* SetAccessor */:
+                        return ast.parameterList;
+                }
+            }
+
+            return null;
+        }
+        ASTHelpers.getParameterList = getParameterList;
+
+        function getType(ast) {
+            if (ast) {
+                switch (ast.kind()) {
+                    case 129 /* FunctionDeclaration */:
+                        return getType(ast.callSignature);
+                    case 218 /* ParenthesizedArrowFunctionExpression */:
+                        return getType(ast.callSignature);
+                    case 143 /* ConstructSignature */:
+                        return getType(ast.callSignature);
+                    case 135 /* MemberFunctionDeclaration */:
+                        return getType(ast.callSignature);
+                    case 241 /* FunctionPropertyAssignment */:
+                        return getType(ast.callSignature);
+                    case 222 /* FunctionExpression */:
+                        return getType(ast.callSignature);
+                    case 145 /* MethodSignature */:
+                        return getType(ast.callSignature);
+                    case 142 /* CallSignature */:
+                        return getType(ast.typeAnnotation);
+                    case 144 /* IndexSignature */:
+                        return getType(ast.typeAnnotation);
+                    case 141 /* PropertySignature */:
+                        return getType(ast.typeAnnotation);
+                    case 139 /* GetAccessor */:
+                        return getType(ast.typeAnnotation);
+                    case 242 /* Parameter */:
+                        return getType(ast.typeAnnotation);
+                    case 136 /* MemberVariableDeclaration */:
+                        return getType(ast.variableDeclarator);
+                    case 225 /* VariableDeclarator */:
+                        return getType(ast.typeAnnotation);
+                    case 236 /* CatchClause */:
+                        return getType(ast.typeAnnotation);
+                    case 125 /* ConstructorType */:
+                        return ast.type;
+                    case 123 /* FunctionType */:
+                        return ast.type;
+                    case 244 /* TypeAnnotation */:
+                        return ast.type;
+                }
+            }
+
+            return null;
+        }
+        ASTHelpers.getType = getType;
+
+        function getVariableStatement(variableDeclarator) {
+            if (variableDeclarator && variableDeclarator.parent && variableDeclarator.parent.parent && variableDeclarator.parent.parent.parent && variableDeclarator.parent.kind() === 2 /* SeparatedList */ && variableDeclarator.parent.parent.kind() === 224 /* VariableDeclaration */ && variableDeclarator.parent.parent.parent.kind() === 148 /* VariableStatement */) {
+                return variableDeclarator.parent.parent.parent;
+            }
+
+            return null;
+        }
+
+        function getVariableDeclaratorModifiers(variableDeclarator) {
+            var variableStatement = getVariableStatement(variableDeclarator);
+            return variableStatement ? variableStatement.modifiers : TypeScript.sentinelEmptyArray;
+        }
+        ASTHelpers.getVariableDeclaratorModifiers = getVariableDeclaratorModifiers;
+
+        function isIntegerLiteralAST(expression) {
+            if (expression) {
+                switch (expression.kind()) {
+                    case 164 /* PlusExpression */:
+                    case 165 /* NegateExpression */:
+                        expression = expression.operand;
+                        return expression.kind() === 13 /* NumericLiteral */ && TypeScript.IntegerUtilities.isInteger(expression.text());
+
+                    case 13 /* NumericLiteral */:
+                        var text = expression.text();
+                        return TypeScript.IntegerUtilities.isInteger(text) || TypeScript.IntegerUtilities.isHexInteger(text);
+                }
+            }
+
+            return false;
+        }
+        ASTHelpers.isIntegerLiteralAST = isIntegerLiteralAST;
+
+        function getEnclosingModuleDeclaration(ast) {
+            while (ast) {
+                if (ast.kind() === 130 /* ModuleDeclaration */) {
+                    return ast;
+                }
+
+                ast = ast.parent;
+            }
+
+            return null;
+        }
+        ASTHelpers.getEnclosingModuleDeclaration = getEnclosingModuleDeclaration;
+
+        function isLastNameOfModule(ast, astName) {
+            if (ast) {
+                if (ast.stringLiteral) {
+                    return astName === ast.stringLiteral;
+                } else {
+                    var moduleNames = getModuleNames(ast.name);
+                    var nameIndex = moduleNames.indexOf(astName);
+
+                    return nameIndex === (moduleNames.length - 1);
+                }
+            }
+
+            return false;
+        }
+        ASTHelpers.isLastNameOfModule = isLastNameOfModule;
+
+        function isAnyNameOfModule(ast, astName) {
+            if (ast) {
+                if (ast.stringLiteral) {
+                    return ast.stringLiteral === astName;
+                } else {
+                    var moduleNames = getModuleNames(ast.name);
+                    var nameIndex = moduleNames.indexOf(astName);
+
+                    return nameIndex >= 0;
+                }
+            }
+
+            return false;
+        }
+        ASTHelpers.isAnyNameOfModule = isAnyNameOfModule;
+
+        function getNameOfIdenfierOrQualifiedName(name) {
+            if (name.kind() === 11 /* IdentifierName */) {
+                return name.text();
+            } else {
+                TypeScript.Debug.assert(name.kind() == 121 /* QualifiedName */);
+                var dotExpr = name;
+                return getNameOfIdenfierOrQualifiedName(dotExpr.left) + "." + getNameOfIdenfierOrQualifiedName(dotExpr.right);
+            }
+        }
+        ASTHelpers.getNameOfIdenfierOrQualifiedName = getNameOfIdenfierOrQualifiedName;
+
+        function getModuleNames(name, result) {
+            result = result || [];
+
+            if (name.kind() === 121 /* QualifiedName */) {
+                getModuleNames(name.left, result);
+                result.push(name.right);
+            } else {
+                result.push(name);
+            }
+
+            return result;
+        }
+        ASTHelpers.getModuleNames = getModuleNames;
+    })(TypeScript.ASTHelpers || (TypeScript.ASTHelpers = {}));
+    var ASTHelpers = TypeScript.ASTHelpers;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    function walkListChildren(preAst, walker) {
+        for (var i = 0, n = preAst.childCount(); i < n; i++) {
+            walker.walk(preAst.childAt(i));
+        }
+    }
+
+    function walkThrowStatementChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+    }
+
+    function walkPrefixUnaryExpressionChildren(preAst, walker) {
+        walker.walk(preAst.operand);
+    }
+
+    function walkPostfixUnaryExpressionChildren(preAst, walker) {
+        walker.walk(preAst.operand);
+    }
+
+    function walkDeleteExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+    }
+
+    function walkTypeArgumentListChildren(preAst, walker) {
+        walker.walk(preAst.typeArguments);
+    }
+
+    function walkTypeOfExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+    }
+
+    function walkVoidExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+    }
+
+    function walkArgumentListChildren(preAst, walker) {
+        walker.walk(preAst.typeArgumentList);
+        walker.walk(preAst.arguments);
+    }
+
+    function walkArrayLiteralExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expressions);
+    }
+
+    function walkSimplePropertyAssignmentChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.expression);
+    }
+
+    function walkFunctionPropertyAssignmentChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.callSignature);
+        walker.walk(preAst.block);
+    }
+
+    function walkGetAccessorChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.parameterList);
+        walker.walk(preAst.typeAnnotation);
+        walker.walk(preAst.block);
+    }
+
+    function walkSeparatedListChildren(preAst, walker) {
+        for (var i = 0, n = preAst.nonSeparatorCount(); i < n; i++) {
+            walker.walk(preAst.nonSeparatorAt(i));
+        }
+    }
+
+    function walkSetAccessorChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.parameterList);
+        walker.walk(preAst.block);
+    }
+
+    function walkObjectLiteralExpressionChildren(preAst, walker) {
+        walker.walk(preAst.propertyAssignments);
+    }
+
+    function walkCastExpressionChildren(preAst, walker) {
+        walker.walk(preAst.type);
+        walker.walk(preAst.expression);
+    }
+
+    function walkParenthesizedExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+    }
+
+    function walkElementAccessExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+        walker.walk(preAst.argumentExpression);
+    }
+
+    function walkMemberAccessExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+        walker.walk(preAst.name);
+    }
+
+    function walkQualifiedNameChildren(preAst, walker) {
+        walker.walk(preAst.left);
+        walker.walk(preAst.right);
+    }
+
+    function walkBinaryExpressionChildren(preAst, walker) {
+        walker.walk(preAst.left);
+        walker.walk(preAst.right);
+    }
+
+    function walkEqualsValueClauseChildren(preAst, walker) {
+        walker.walk(preAst.value);
+    }
+
+    function walkTypeParameterChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.constraint);
+    }
+
+    function walkTypeParameterListChildren(preAst, walker) {
+        walker.walk(preAst.typeParameters);
+    }
+
+    function walkGenericTypeChildren(preAst, walker) {
+        walker.walk(preAst.name);
+        walker.walk(preAst.typeArgumentList);
+    }
+
+    function walkTypeAnnotationChildren(preAst, walker) {
+        walker.walk(preAst.type);
+    }
+
+    function walkTypeQueryChildren(preAst, walker) {
+        walker.walk(preAst.name);
+    }
+
+    function walkInvocationExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+        walker.walk(preAst.argumentList);
+    }
+
+    function walkObjectCreationExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+        walker.walk(preAst.argumentList);
+    }
+
+    function walkTrinaryExpressionChildren(preAst, walker) {
+        walker.walk(preAst.condition);
+        walker.walk(preAst.whenTrue);
+        walker.walk(preAst.whenFalse);
+    }
+
+    function walkFunctionExpressionChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.callSignature);
+        walker.walk(preAst.block);
+    }
+
+    function walkFunctionTypeChildren(preAst, walker) {
+        walker.walk(preAst.typeParameterList);
+        walker.walk(preAst.parameterList);
+        walker.walk(preAst.type);
+    }
+
+    function walkParenthesizedArrowFunctionExpressionChildren(preAst, walker) {
+        walker.walk(preAst.callSignature);
+        walker.walk(preAst.block);
+        walker.walk(preAst.expression);
+    }
+
+    function walkSimpleArrowFunctionExpressionChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.block);
+        walker.walk(preAst.expression);
+    }
+
+    function walkMemberFunctionDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.callSignature);
+        walker.walk(preAst.block);
+    }
+
+    function walkFuncDeclChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.callSignature);
+        walker.walk(preAst.block);
+    }
+
+    function walkIndexMemberDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.indexSignature);
+    }
+
+    function walkIndexSignatureChildren(preAst, walker) {
+        walker.walk(preAst.parameter);
+        walker.walk(preAst.typeAnnotation);
+    }
+
+    function walkCallSignatureChildren(preAst, walker) {
+        walker.walk(preAst.typeParameterList);
+        walker.walk(preAst.parameterList);
+        walker.walk(preAst.typeAnnotation);
+    }
+
+    function walkConstraintChildren(preAst, walker) {
+        walker.walk(preAst.type);
+    }
+
+    function walkConstructorDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.callSignature);
+        walker.walk(preAst.block);
+    }
+
+    function walkConstructorTypeChildren(preAst, walker) {
+        walker.walk(preAst.typeParameterList);
+        walker.walk(preAst.parameterList);
+        walker.walk(preAst.type);
+    }
+
+    function walkConstructSignatureChildren(preAst, walker) {
+        walker.walk(preAst.callSignature);
+    }
+
+    function walkParameterChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.typeAnnotation);
+        walker.walk(preAst.equalsValueClause);
+    }
+
+    function walkParameterListChildren(preAst, walker) {
+        walker.walk(preAst.parameters);
+    }
+
+    function walkPropertySignatureChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.typeAnnotation);
+    }
+
+    function walkVariableDeclaratorChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.typeAnnotation);
+        walker.walk(preAst.equalsValueClause);
+    }
+
+    function walkMemberVariableDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.variableDeclarator);
+    }
+
+    function walkMethodSignatureChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.callSignature);
+    }
+
+    function walkReturnStatementChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+    }
+
+    function walkForStatementChildren(preAst, walker) {
+        walker.walk(preAst.variableDeclaration);
+        walker.walk(preAst.initializer);
+        walker.walk(preAst.condition);
+        walker.walk(preAst.incrementor);
+        walker.walk(preAst.statement);
+    }
+
+    function walkForInStatementChildren(preAst, walker) {
+        walker.walk(preAst.variableDeclaration);
+        walker.walk(preAst.left);
+        walker.walk(preAst.expression);
+        walker.walk(preAst.statement);
+    }
+
+    function walkIfStatementChildren(preAst, walker) {
+        walker.walk(preAst.condition);
+        walker.walk(preAst.statement);
+        walker.walk(preAst.elseClause);
+    }
+
+    function walkElseClauseChildren(preAst, walker) {
+        walker.walk(preAst.statement);
+    }
+
+    function walkWhileStatementChildren(preAst, walker) {
+        walker.walk(preAst.condition);
+        walker.walk(preAst.statement);
+    }
+
+    function walkDoStatementChildren(preAst, walker) {
+        walker.walk(preAst.condition);
+        walker.walk(preAst.statement);
+    }
+
+    function walkBlockChildren(preAst, walker) {
+        walker.walk(preAst.statements);
+    }
+
+    function walkVariableDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.declarators);
+    }
+
+    function walkCaseSwitchClauseChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+        walker.walk(preAst.statements);
+    }
+
+    function walkDefaultSwitchClauseChildren(preAst, walker) {
+        walker.walk(preAst.statements);
+    }
+
+    function walkSwitchStatementChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+        walker.walk(preAst.switchClauses);
+    }
+
+    function walkTryStatementChildren(preAst, walker) {
+        walker.walk(preAst.block);
+        walker.walk(preAst.catchClause);
+        walker.walk(preAst.finallyClause);
+    }
+
+    function walkCatchClauseChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.typeAnnotation);
+        walker.walk(preAst.block);
+    }
+
+    function walkExternalModuleReferenceChildren(preAst, walker) {
+        walker.walk(preAst.stringLiteral);
+    }
+
+    function walkFinallyClauseChildren(preAst, walker) {
+        walker.walk(preAst.block);
+    }
+
+    function walkClassDeclChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.typeParameterList);
+        walker.walk(preAst.heritageClauses);
+        walker.walk(preAst.classElements);
+    }
+
+    function walkScriptChildren(preAst, walker) {
+        walker.walk(preAst.moduleElements);
+    }
+
+    function walkHeritageClauseChildren(preAst, walker) {
+        walker.walk(preAst.typeNames);
+    }
+
+    function walkInterfaceDeclerationChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.typeParameterList);
+        walker.walk(preAst.heritageClauses);
+        walker.walk(preAst.body);
+    }
+
+    function walkObjectTypeChildren(preAst, walker) {
+        walker.walk(preAst.typeMembers);
+    }
+
+    function walkArrayTypeChildren(preAst, walker) {
+        walker.walk(preAst.type);
+    }
+
+    function walkModuleDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.name);
+        walker.walk(preAst.stringLiteral);
+        walker.walk(preAst.moduleElements);
+    }
+
+    function walkModuleNameModuleReferenceChildren(preAst, walker) {
+        walker.walk(preAst.moduleName);
+    }
+
+    function walkEnumDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.enumElements);
+    }
+
+    function walkEnumElementChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.equalsValueClause);
+    }
+
+    function walkImportDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.moduleReference);
+    }
+
+    function walkExportAssignmentChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+    }
+
+    function walkWithStatementChildren(preAst, walker) {
+        walker.walk(preAst.condition);
+        walker.walk(preAst.statement);
+    }
+
+    function walkExpressionStatementChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+    }
+
+    function walkLabeledStatementChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.statement);
+    }
+
+    function walkVariableStatementChildren(preAst, walker) {
+        walker.walk(preAst.declaration);
+    }
+
+    var childrenWalkers = new Array(246 /* Last */ + 1);
+
+    for (var i = 9 /* FirstToken */, n = 119 /* LastToken */; i <= n; i++) {
+        childrenWalkers[i] = null;
+    }
+    for (var i = 4 /* FirstTrivia */, n = 8 /* LastTrivia */; i <= n; i++) {
+        childrenWalkers[i] = null;
+    }
+
+    childrenWalkers[175 /* AddAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[208 /* AddExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[180 /* AndAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[60 /* AnyKeyword */] = null;
+    childrenWalkers[226 /* ArgumentList */] = walkArgumentListChildren;
+    childrenWalkers[214 /* ArrayLiteralExpression */] = walkArrayLiteralExpressionChildren;
+    childrenWalkers[124 /* ArrayType */] = walkArrayTypeChildren;
+    childrenWalkers[219 /* SimpleArrowFunctionExpression */] = walkSimpleArrowFunctionExpressionChildren;
+    childrenWalkers[218 /* ParenthesizedArrowFunctionExpression */] = walkParenthesizedArrowFunctionExpressionChildren;
+    childrenWalkers[174 /* AssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[191 /* BitwiseAndExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[190 /* BitwiseExclusiveOrExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[166 /* BitwiseNotExpression */] = walkPrefixUnaryExpressionChildren;
+    childrenWalkers[189 /* BitwiseOrExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[146 /* Block */] = walkBlockChildren;
+    childrenWalkers[61 /* BooleanKeyword */] = null;
+    childrenWalkers[152 /* BreakStatement */] = null;
+    childrenWalkers[142 /* CallSignature */] = walkCallSignatureChildren;
+    childrenWalkers[233 /* CaseSwitchClause */] = walkCaseSwitchClauseChildren;
+    childrenWalkers[220 /* CastExpression */] = walkCastExpressionChildren;
+    childrenWalkers[236 /* CatchClause */] = walkCatchClauseChildren;
+    childrenWalkers[131 /* ClassDeclaration */] = walkClassDeclChildren;
+    childrenWalkers[173 /* CommaExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[186 /* ConditionalExpression */] = walkTrinaryExpressionChildren;
+    childrenWalkers[239 /* Constraint */] = walkConstraintChildren;
+    childrenWalkers[137 /* ConstructorDeclaration */] = walkConstructorDeclarationChildren;
+    childrenWalkers[143 /* ConstructSignature */] = walkConstructSignatureChildren;
+    childrenWalkers[153 /* ContinueStatement */] = null;
+    childrenWalkers[125 /* ConstructorType */] = walkConstructorTypeChildren;
+    childrenWalkers[162 /* DebuggerStatement */] = null;
+    childrenWalkers[234 /* DefaultSwitchClause */] = walkDefaultSwitchClauseChildren;
+    childrenWalkers[170 /* DeleteExpression */] = walkDeleteExpressionChildren;
+    childrenWalkers[178 /* DivideAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[206 /* DivideExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[161 /* DoStatement */] = walkDoStatementChildren;
+    childrenWalkers[221 /* ElementAccessExpression */] = walkElementAccessExpressionChildren;
+    childrenWalkers[235 /* ElseClause */] = walkElseClauseChildren;
+    childrenWalkers[156 /* EmptyStatement */] = null;
+    childrenWalkers[132 /* EnumDeclaration */] = walkEnumDeclarationChildren;
+    childrenWalkers[243 /* EnumElement */] = walkEnumElementChildren;
+    childrenWalkers[194 /* EqualsExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[232 /* EqualsValueClause */] = walkEqualsValueClauseChildren;
+    childrenWalkers[192 /* EqualsWithTypeConversionExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[181 /* ExclusiveOrAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[134 /* ExportAssignment */] = walkExportAssignmentChildren;
+    childrenWalkers[149 /* ExpressionStatement */] = walkExpressionStatementChildren;
+    childrenWalkers[230 /* ExtendsHeritageClause */] = walkHeritageClauseChildren;
+    childrenWalkers[245 /* ExternalModuleReference */] = walkExternalModuleReferenceChildren;
+    childrenWalkers[24 /* FalseKeyword */] = null;
+    childrenWalkers[237 /* FinallyClause */] = walkFinallyClauseChildren;
+    childrenWalkers[155 /* ForInStatement */] = walkForInStatementChildren;
+    childrenWalkers[154 /* ForStatement */] = walkForStatementChildren;
+    childrenWalkers[129 /* FunctionDeclaration */] = walkFuncDeclChildren;
+    childrenWalkers[222 /* FunctionExpression */] = walkFunctionExpressionChildren;
+    childrenWalkers[241 /* FunctionPropertyAssignment */] = walkFunctionPropertyAssignmentChildren;
+    childrenWalkers[123 /* FunctionType */] = walkFunctionTypeChildren;
+    childrenWalkers[126 /* GenericType */] = walkGenericTypeChildren;
+    childrenWalkers[139 /* GetAccessor */] = walkGetAccessorChildren;
+    childrenWalkers[197 /* GreaterThanExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[199 /* GreaterThanOrEqualExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[147 /* IfStatement */] = walkIfStatementChildren;
+    childrenWalkers[231 /* ImplementsHeritageClause */] = walkHeritageClauseChildren;
+    childrenWalkers[133 /* ImportDeclaration */] = walkImportDeclarationChildren;
+    childrenWalkers[138 /* IndexMemberDeclaration */] = walkIndexMemberDeclarationChildren;
+    childrenWalkers[144 /* IndexSignature */] = walkIndexSignatureChildren;
+    childrenWalkers[201 /* InExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[200 /* InstanceOfExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[128 /* InterfaceDeclaration */] = walkInterfaceDeclerationChildren;
+    childrenWalkers[213 /* InvocationExpression */] = walkInvocationExpressionChildren;
+    childrenWalkers[160 /* LabeledStatement */] = walkLabeledStatementChildren;
+    childrenWalkers[183 /* LeftShiftAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[202 /* LeftShiftExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[196 /* LessThanExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[198 /* LessThanOrEqualExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[1 /* List */] = walkListChildren;
+    childrenWalkers[188 /* LogicalAndExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[167 /* LogicalNotExpression */] = walkPrefixUnaryExpressionChildren;
+    childrenWalkers[187 /* LogicalOrExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[212 /* MemberAccessExpression */] = walkMemberAccessExpressionChildren;
+    childrenWalkers[135 /* MemberFunctionDeclaration */] = walkMemberFunctionDeclarationChildren;
+    childrenWalkers[136 /* MemberVariableDeclaration */] = walkMemberVariableDeclarationChildren;
+    childrenWalkers[145 /* MethodSignature */] = walkMethodSignatureChildren;
+    childrenWalkers[130 /* ModuleDeclaration */] = walkModuleDeclarationChildren;
+    childrenWalkers[246 /* ModuleNameModuleReference */] = walkModuleNameModuleReferenceChildren;
+    childrenWalkers[179 /* ModuloAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[207 /* ModuloExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[177 /* MultiplyAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[205 /* MultiplyExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[11 /* IdentifierName */] = null;
+    childrenWalkers[165 /* NegateExpression */] = walkPrefixUnaryExpressionChildren;
+    childrenWalkers[0 /* None */] = null;
+    childrenWalkers[195 /* NotEqualsExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[193 /* NotEqualsWithTypeConversionExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[32 /* NullKeyword */] = null;
+    childrenWalkers[67 /* NumberKeyword */] = null;
+    childrenWalkers[13 /* NumericLiteral */] = null;
+    childrenWalkers[216 /* ObjectCreationExpression */] = walkObjectCreationExpressionChildren;
+    childrenWalkers[215 /* ObjectLiteralExpression */] = walkObjectLiteralExpressionChildren;
+    childrenWalkers[122 /* ObjectType */] = walkObjectTypeChildren;
+    childrenWalkers[223 /* OmittedExpression */] = null;
+    childrenWalkers[182 /* OrAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[242 /* Parameter */] = walkParameterChildren;
+    childrenWalkers[227 /* ParameterList */] = walkParameterListChildren;
+    childrenWalkers[217 /* ParenthesizedExpression */] = walkParenthesizedExpressionChildren;
+    childrenWalkers[164 /* PlusExpression */] = walkPrefixUnaryExpressionChildren;
+    childrenWalkers[211 /* PostDecrementExpression */] = walkPostfixUnaryExpressionChildren;
+    childrenWalkers[210 /* PostIncrementExpression */] = walkPostfixUnaryExpressionChildren;
+    childrenWalkers[169 /* PreDecrementExpression */] = walkPrefixUnaryExpressionChildren;
+    childrenWalkers[168 /* PreIncrementExpression */] = walkPrefixUnaryExpressionChildren;
+    childrenWalkers[141 /* PropertySignature */] = walkPropertySignatureChildren;
+    childrenWalkers[121 /* QualifiedName */] = walkQualifiedNameChildren;
+    childrenWalkers[12 /* RegularExpressionLiteral */] = null;
+    childrenWalkers[150 /* ReturnStatement */] = walkReturnStatementChildren;
+    childrenWalkers[120 /* SourceUnit */] = walkScriptChildren;
+    childrenWalkers[2 /* SeparatedList */] = walkSeparatedListChildren;
+    childrenWalkers[140 /* SetAccessor */] = walkSetAccessorChildren;
+    childrenWalkers[184 /* SignedRightShiftAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[203 /* SignedRightShiftExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[240 /* SimplePropertyAssignment */] = walkSimplePropertyAssignmentChildren;
+    childrenWalkers[14 /* StringLiteral */] = null;
+    childrenWalkers[69 /* StringKeyword */] = null;
+    childrenWalkers[176 /* SubtractAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[209 /* SubtractExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[50 /* SuperKeyword */] = null;
+    childrenWalkers[151 /* SwitchStatement */] = walkSwitchStatementChildren;
+    childrenWalkers[35 /* ThisKeyword */] = null;
+    childrenWalkers[157 /* ThrowStatement */] = walkThrowStatementChildren;
+    childrenWalkers[3 /* TriviaList */] = null;
+    childrenWalkers[37 /* TrueKeyword */] = null;
+    childrenWalkers[159 /* TryStatement */] = walkTryStatementChildren;
+    childrenWalkers[244 /* TypeAnnotation */] = walkTypeAnnotationChildren;
+    childrenWalkers[228 /* TypeArgumentList */] = walkTypeArgumentListChildren;
+    childrenWalkers[171 /* TypeOfExpression */] = walkTypeOfExpressionChildren;
+    childrenWalkers[238 /* TypeParameter */] = walkTypeParameterChildren;
+    childrenWalkers[229 /* TypeParameterList */] = walkTypeParameterListChildren;
+    childrenWalkers[127 /* TypeQuery */] = walkTypeQueryChildren;
+    childrenWalkers[185 /* UnsignedRightShiftAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[204 /* UnsignedRightShiftExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[224 /* VariableDeclaration */] = walkVariableDeclarationChildren;
+    childrenWalkers[225 /* VariableDeclarator */] = walkVariableDeclaratorChildren;
+    childrenWalkers[148 /* VariableStatement */] = walkVariableStatementChildren;
+    childrenWalkers[172 /* VoidExpression */] = walkVoidExpressionChildren;
+    childrenWalkers[41 /* VoidKeyword */] = null;
+    childrenWalkers[158 /* WhileStatement */] = walkWhileStatementChildren;
+    childrenWalkers[163 /* WithStatement */] = walkWithStatementChildren;
+
+    for (var e in TypeScript.SyntaxKind) {
+        if (TypeScript.SyntaxKind.hasOwnProperty(e) && TypeScript.StringUtilities.isString(TypeScript.SyntaxKind[e])) {
+            TypeScript.Debug.assert(childrenWalkers[e] !== undefined, "Fix initWalkers: " + TypeScript.SyntaxKind[e]);
+        }
+    }
+
+    var AstWalkOptions = (function () {
+        function AstWalkOptions() {
+            this.goChildren = true;
+            this.stopWalking = false;
+        }
+        return AstWalkOptions;
+    })();
+    TypeScript.AstWalkOptions = AstWalkOptions;
+
+    var SimplePreAstWalker = (function () {
+        function SimplePreAstWalker(pre, state) {
+            this.pre = pre;
+            this.state = state;
+            this.options = new AstWalkOptions();
+        }
+        SimplePreAstWalker.prototype.walk = function (ast) {
+            if (!ast) {
+                return;
+            }
+
+            this.pre(ast, this.state);
+
+            var walker = childrenWalkers[ast.kind()];
+            if (walker) {
+                walker(ast, this);
+            }
+        };
+        return SimplePreAstWalker;
+    })();
+
+    var SimplePrePostAstWalker = (function () {
+        function SimplePrePostAstWalker(pre, post, state) {
+            this.pre = pre;
+            this.post = post;
+            this.state = state;
+            this.options = new AstWalkOptions();
+        }
+        SimplePrePostAstWalker.prototype.walk = function (ast) {
+            if (!ast) {
+                return;
+            }
+
+            this.pre(ast, this.state);
+
+            var walker = childrenWalkers[ast.kind()];
+            if (walker) {
+                walker(ast, this);
+            }
+
+            this.post(ast, this.state);
+        };
+        return SimplePrePostAstWalker;
+    })();
+
+    var NormalAstWalker = (function () {
+        function NormalAstWalker(pre, post, state) {
+            this.pre = pre;
+            this.post = post;
+            this.state = state;
+            this.options = new AstWalkOptions();
+        }
+        NormalAstWalker.prototype.walk = function (ast) {
+            if (!ast) {
+                return;
+            }
+
+            if (this.options.stopWalking) {
+                return;
+            }
+
+            this.pre(ast, this);
+
+            if (this.options.stopWalking) {
+                return;
+            }
+
+            if (this.options.goChildren) {
+                var walker = childrenWalkers[ast.kind()];
+                if (walker) {
+                    walker(ast, this);
+                }
+            } else {
+                this.options.goChildren = true;
+            }
+
+            if (this.post) {
+                this.post(ast, this);
+            }
+        };
+        return NormalAstWalker;
+    })();
+
+    var AstWalkerFactory = (function () {
+        function AstWalkerFactory() {
+        }
+        AstWalkerFactory.prototype.walk = function (ast, pre, post, state) {
+            new NormalAstWalker(pre, post, state).walk(ast);
+        };
+
+        AstWalkerFactory.prototype.simpleWalk = function (ast, pre, post, state) {
+            if (post) {
+                new SimplePrePostAstWalker(pre, post, state).walk(ast);
+            } else {
+                new SimplePreAstWalker(pre, state).walk(ast);
+            }
+        };
+        return AstWalkerFactory;
+    })();
+    TypeScript.AstWalkerFactory = AstWalkerFactory;
+
+    var globalAstWalkerFactory = new AstWalkerFactory();
+
+    function getAstWalkerFactory() {
+        return globalAstWalkerFactory;
+    }
+    TypeScript.getAstWalkerFactory = getAstWalkerFactory;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var Base64Format = (function () {
+        function Base64Format() {
+        }
+        Base64Format.encode = function (inValue) {
+            if (inValue < 64) {
+                return Base64Format.encodedValues.charAt(inValue);
+            }
+            throw TypeError(inValue + ": not a 64 based value");
+        };
+
+        Base64Format.decodeChar = function (inChar) {
+            if (inChar.length === 1) {
+                return Base64Format.encodedValues.indexOf(inChar);
+            } else {
+                throw TypeError('"' + inChar + '" must have length 1');
+            }
+        };
+        Base64Format.encodedValues = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+        return Base64Format;
+    })();
+
+    var Base64VLQFormat = (function () {
+        function Base64VLQFormat() {
+        }
+        Base64VLQFormat.encode = function (inValue) {
+            if (inValue < 0) {
+                inValue = ((-inValue) << 1) + 1;
+            } else {
+                inValue = inValue << 1;
+            }
+
+            var encodedStr = "";
+            do {
+                var currentDigit = inValue & 31;
+                inValue = inValue >> 5;
+                if (inValue > 0) {
+                    currentDigit = currentDigit | 32;
+                }
+                encodedStr = encodedStr + Base64Format.encode(currentDigit);
+            } while(inValue > 0);
+
+            return encodedStr;
+        };
+
+        Base64VLQFormat.decode = function (inString) {
+            var result = 0;
+            var negative = false;
+
+            var shift = 0;
+            for (var i = 0; i < inString.length; i++) {
+                var byte = Base64Format.decodeChar(inString[i]);
+                if (i === 0) {
+                    if ((byte & 1) === 1) {
+                        negative = true;
+                    }
+                    result = (byte >> 1) & 15;
+                } else {
+                    result = result | ((byte & 31) << shift);
+                }
+
+                shift += (i === 0) ? 4 : 5;
+
+                if ((byte & 32) === 32) {
+                } else {
+                    return { value: negative ? -(result) : result, rest: inString.substr(i + 1) };
+                }
+            }
+
+            throw new Error(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Base64_value_0_finished_with_a_continuation_bit, [inString]));
+        };
+        return Base64VLQFormat;
+    })();
+    TypeScript.Base64VLQFormat = Base64VLQFormat;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SourceMapPosition = (function () {
+        function SourceMapPosition() {
+        }
+        return SourceMapPosition;
+    })();
+    TypeScript.SourceMapPosition = SourceMapPosition;
+
+    var SourceMapping = (function () {
+        function SourceMapping() {
+            this.start = new SourceMapPosition();
+            this.end = new SourceMapPosition();
+            this.nameIndex = -1;
+            this.childMappings = [];
+        }
+        return SourceMapping;
+    })();
+    TypeScript.SourceMapping = SourceMapping;
+
+    var SourceMapEntry = (function () {
+        function SourceMapEntry(emittedFile, emittedLine, emittedColumn, sourceFile, sourceLine, sourceColumn, sourceName) {
+            this.emittedFile = emittedFile;
+            this.emittedLine = emittedLine;
+            this.emittedColumn = emittedColumn;
+            this.sourceFile = sourceFile;
+            this.sourceLine = sourceLine;
+            this.sourceColumn = sourceColumn;
+            this.sourceName = sourceName;
+            TypeScript.Debug.assert(isFinite(emittedLine));
+            TypeScript.Debug.assert(isFinite(emittedColumn));
+            TypeScript.Debug.assert(isFinite(sourceColumn));
+            TypeScript.Debug.assert(isFinite(sourceLine));
+        }
+        return SourceMapEntry;
+    })();
+    TypeScript.SourceMapEntry = SourceMapEntry;
+
+    var SourceMapper = (function () {
+        function SourceMapper(jsFile, sourceMapOut, document, jsFilePath, emitOptions, resolvePath) {
+            this.jsFile = jsFile;
+            this.sourceMapOut = sourceMapOut;
+            this.names = [];
+            this.mappingLevel = [];
+            this.tsFilePaths = [];
+            this.allSourceMappings = [];
+            this.sourceMapEntries = [];
+            this.setSourceMapOptions(document, jsFilePath, emitOptions, resolvePath);
+            this.setNewSourceFile(document, emitOptions);
+        }
+        SourceMapper.prototype.getOutputFile = function () {
+            var result = this.sourceMapOut.getOutputFile();
+            result.sourceMapEntries = this.sourceMapEntries;
+
+            return result;
+        };
+
+        SourceMapper.prototype.increaseMappingLevel = function (ast) {
+            this.mappingLevel.push(ast);
+        };
+
+        SourceMapper.prototype.decreaseMappingLevel = function (ast) {
+            TypeScript.Debug.assert(this.mappingLevel.length > 0, "Mapping level should never be less than 0. This suggests a missing start call.");
+            var expectedAst = this.mappingLevel.pop();
+            var expectedAstInfo = expectedAst.kind ? TypeScript.SyntaxKind[expectedAst.kind()] : [expectedAst.start(), expectedAst.end()];
+            var astInfo = ast.kind ? TypeScript.SyntaxKind[ast.kind()] : [ast.start(), ast.end()];
+            TypeScript.Debug.assert(ast === expectedAst, "Provided ast is not the expected AST, Expected: " + expectedAstInfo + " Given: " + astInfo);
+        };
+
+        SourceMapper.prototype.setNewSourceFile = function (document, emitOptions) {
+            var sourceMappings = [];
+            this.allSourceMappings.push(sourceMappings);
+            this.currentMappings = [sourceMappings];
+            this.currentNameIndex = [];
+
+            this.setNewSourceFilePath(document, emitOptions);
+        };
+
+        SourceMapper.prototype.setSourceMapOptions = function (document, jsFilePath, emitOptions, resolvePath) {
+            var prettyJsFileName = TypeScript.getPrettyName(jsFilePath, false, true);
+            var prettyMapFileName = prettyJsFileName + SourceMapper.MapFileExtension;
+            this.jsFileName = prettyJsFileName;
+
+            if (emitOptions.sourceMapRootDirectory()) {
+                this.sourceMapDirectory = emitOptions.sourceMapRootDirectory();
+                if (document.emitToOwnOutputFile()) {
+                    this.sourceMapDirectory = this.sourceMapDirectory + TypeScript.switchToForwardSlashes(TypeScript.getRootFilePath((document.fileName)).replace(emitOptions.commonDirectoryPath(), ""));
+                }
+
+                if (TypeScript.isRelative(this.sourceMapDirectory)) {
+                    this.sourceMapDirectory = emitOptions.commonDirectoryPath() + this.sourceMapDirectory;
+                    this.sourceMapDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(resolvePath(this.sourceMapDirectory)));
+                    this.sourceMapPath = TypeScript.getRelativePathToFixedPath(TypeScript.getRootFilePath(jsFilePath), this.sourceMapDirectory + prettyMapFileName);
+                } else {
+                    this.sourceMapPath = this.sourceMapDirectory + prettyMapFileName;
+                }
+            } else {
+                this.sourceMapPath = prettyMapFileName;
+                this.sourceMapDirectory = TypeScript.getRootFilePath(jsFilePath);
+            }
+            this.sourceRoot = emitOptions.sourceRootDirectory();
+        };
+
+        SourceMapper.prototype.setNewSourceFilePath = function (document, emitOptions) {
+            var tsFilePath = TypeScript.switchToForwardSlashes(document.fileName);
+            if (emitOptions.sourceRootDirectory()) {
+                tsFilePath = TypeScript.getRelativePathToFixedPath(emitOptions.commonDirectoryPath(), tsFilePath);
+            } else {
+                tsFilePath = TypeScript.getRelativePathToFixedPath(this.sourceMapDirectory, tsFilePath);
+            }
+            this.tsFilePaths.push(tsFilePath);
+        };
+
+        SourceMapper.prototype.emitSourceMapping = function () {
+            var _this = this;
+            TypeScript.Debug.assert(this.mappingLevel.length === 0, "Mapping level is not 0. This suggest a missing end call. Value: " + this.mappingLevel.map(function (item) {
+                return ['Node of type', TypeScript.SyntaxKind[item.kind()], 'at', item.start(), 'to', item.end()].join(' ');
+            }).join(', '));
+
+            this.jsFile.WriteLine("//# sourceMappingURL=" + this.sourceMapPath);
+
+            var mappingsString = "";
+
+            var prevEmittedColumn = 0;
+            var prevEmittedLine = 0;
+            var prevSourceColumn = 0;
+            var prevSourceLine = 0;
+            var prevSourceIndex = 0;
+            var prevNameIndex = 0;
+            var emitComma = false;
+
+            var recordedPosition = null;
+            for (var sourceIndex = 0; sourceIndex < this.tsFilePaths.length; sourceIndex++) {
+                var recordSourceMapping = function (mappedPosition, nameIndex) {
+                    if (recordedPosition !== null && recordedPosition.emittedColumn === mappedPosition.emittedColumn && recordedPosition.emittedLine === mappedPosition.emittedLine) {
+                        return;
+                    }
+
+                    if (prevEmittedLine !== mappedPosition.emittedLine) {
+                        while (prevEmittedLine < mappedPosition.emittedLine) {
+                            prevEmittedColumn = 0;
+                            mappingsString = mappingsString + ";";
+                            prevEmittedLine++;
+                        }
+                        emitComma = false;
+                    } else if (emitComma) {
+                        mappingsString = mappingsString + ",";
+                    }
+
+                    _this.sourceMapEntries.push(new SourceMapEntry(_this.jsFileName, mappedPosition.emittedLine + 1, mappedPosition.emittedColumn + 1, _this.tsFilePaths[sourceIndex], mappedPosition.sourceLine, mappedPosition.sourceColumn + 1, nameIndex >= 0 ? _this.names[nameIndex] : undefined));
+
+                    mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.emittedColumn - prevEmittedColumn);
+                    prevEmittedColumn = mappedPosition.emittedColumn;
+
+                    mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(sourceIndex - prevSourceIndex);
+                    prevSourceIndex = sourceIndex;
+
+                    mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.sourceLine - 1 - prevSourceLine);
+                    prevSourceLine = mappedPosition.sourceLine - 1;
+
+                    mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.sourceColumn - prevSourceColumn);
+                    prevSourceColumn = mappedPosition.sourceColumn;
+
+                    if (nameIndex >= 0) {
+                        mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(nameIndex - prevNameIndex);
+                        prevNameIndex = nameIndex;
+                    }
+
+                    emitComma = true;
+                    recordedPosition = mappedPosition;
+                };
+
+                var recordSourceMappingSiblings = function (sourceMappings) {
+                    for (var i = 0; i < sourceMappings.length; i++) {
+                        var sourceMapping = sourceMappings[i];
+                        recordSourceMapping(sourceMapping.start, sourceMapping.nameIndex);
+                        recordSourceMappingSiblings(sourceMapping.childMappings);
+                        recordSourceMapping(sourceMapping.end, sourceMapping.nameIndex);
+                    }
+                };
+
+                recordSourceMappingSiblings(this.allSourceMappings[sourceIndex]);
+            }
+
+            this.sourceMapOut.Write(JSON.stringify({
+                version: 3,
+                file: this.jsFileName,
+                sourceRoot: this.sourceRoot,
+                sources: this.tsFilePaths,
+                names: this.names,
+                mappings: mappingsString
+            }));
+
+            this.sourceMapOut.Close();
+        };
+        SourceMapper.MapFileExtension = ".map";
+        return SourceMapper;
+    })();
+    TypeScript.SourceMapper = SourceMapper;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (EmitContainer) {
+        EmitContainer[EmitContainer["Prog"] = 0] = "Prog";
+        EmitContainer[EmitContainer["Module"] = 1] = "Module";
+        EmitContainer[EmitContainer["DynamicModule"] = 2] = "DynamicModule";
+        EmitContainer[EmitContainer["Class"] = 3] = "Class";
+        EmitContainer[EmitContainer["Constructor"] = 4] = "Constructor";
+        EmitContainer[EmitContainer["Function"] = 5] = "Function";
+        EmitContainer[EmitContainer["Args"] = 6] = "Args";
+        EmitContainer[EmitContainer["Interface"] = 7] = "Interface";
+    })(TypeScript.EmitContainer || (TypeScript.EmitContainer = {}));
+    var EmitContainer = TypeScript.EmitContainer;
+
+    var EmitState = (function () {
+        function EmitState() {
+            this.column = 0;
+            this.line = 0;
+            this.container = 0 /* Prog */;
+        }
+        return EmitState;
+    })();
+    TypeScript.EmitState = EmitState;
+
+    var EmitOptions = (function () {
+        function EmitOptions(compiler, resolvePath) {
+            this.resolvePath = resolvePath;
+            this._diagnostic = null;
+            this._settings = null;
+            this._commonDirectoryPath = "";
+            this._sharedOutputFile = "";
+            this._sourceRootDirectory = "";
+            this._sourceMapRootDirectory = "";
+            this._outputDirectory = "";
+            var settings = compiler.compilationSettings();
+            this._settings = settings;
+
+            if (settings.moduleGenTarget() === 0 /* Unspecified */) {
+                var fileNames = compiler.fileNames();
+                for (var i = 0, n = fileNames.length; i < n; i++) {
+                    var document = compiler.getDocument(fileNames[i]);
+                    if (!document.isDeclareFile() && document.isExternalModule()) {
+                        var errorSpan = document.externalModuleIndicatorSpan();
+                        this._diagnostic = new TypeScript.Diagnostic(document.fileName, document.lineMap(), errorSpan.start(), errorSpan.length(), TypeScript.DiagnosticCode.Cannot_compile_external_modules_unless_the_module_flag_is_provided);
+
+                        return;
+                    }
+                }
+            }
+
+            if (!settings.mapSourceFiles()) {
+                if (settings.mapRoot()) {
+                    if (settings.sourceRoot()) {
+                        this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Options_mapRoot_and_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option, null);
+                        return;
+                    } else {
+                        this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Option_mapRoot_cannot_be_specified_without_specifying_sourcemap_option, null);
+                        return;
+                    }
+                } else if (settings.sourceRoot()) {
+                    this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Option_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option, null);
+                    return;
+                }
+            }
+
+            this._sourceMapRootDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(settings.mapRoot()));
+            this._sourceRootDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(settings.sourceRoot()));
+
+            if (settings.outFileOption() || settings.outDirOption() || settings.mapRoot() || settings.sourceRoot()) {
+                if (settings.outFileOption()) {
+                    this._sharedOutputFile = TypeScript.switchToForwardSlashes(resolvePath(settings.outFileOption()));
+                }
+
+                if (settings.outDirOption()) {
+                    this._outputDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(resolvePath(settings.outDirOption())));
+                }
+
+                if (this._outputDirectory || this._sourceMapRootDirectory || this.sourceRootDirectory) {
+                    this.determineCommonDirectoryPath(compiler);
+                }
+            }
+        }
+        EmitOptions.prototype.diagnostic = function () {
+            return this._diagnostic;
+        };
+
+        EmitOptions.prototype.commonDirectoryPath = function () {
+            return this._commonDirectoryPath;
+        };
+        EmitOptions.prototype.sharedOutputFile = function () {
+            return this._sharedOutputFile;
+        };
+        EmitOptions.prototype.sourceRootDirectory = function () {
+            return this._sourceRootDirectory;
+        };
+        EmitOptions.prototype.sourceMapRootDirectory = function () {
+            return this._sourceMapRootDirectory;
+        };
+        EmitOptions.prototype.outputDirectory = function () {
+            return this._outputDirectory;
+        };
+
+        EmitOptions.prototype.compilationSettings = function () {
+            return this._settings;
+        };
+
+        EmitOptions.prototype.determineCommonDirectoryPath = function (compiler) {
+            var commonComponents = [];
+            var commonComponentsLength = -1;
+
+            var fileNames = compiler.fileNames();
+            for (var i = 0, len = fileNames.length; i < len; i++) {
+                var fileName = fileNames[i];
+                var document = compiler.getDocument(fileNames[i]);
+                var sourceUnit = document.sourceUnit();
+
+                if (!document.isDeclareFile()) {
+                    var fileComponents = TypeScript.filePathComponents(fileName);
+                    if (commonComponentsLength === -1) {
+                        commonComponents = fileComponents;
+                        commonComponentsLength = commonComponents.length;
+                    } else {
+                        var updatedPath = false;
+                        for (var j = 0; j < commonComponentsLength && j < fileComponents.length; j++) {
+                            if (commonComponents[j] !== fileComponents[j]) {
+                                commonComponentsLength = j;
+                                updatedPath = true;
+
+                                if (j === 0) {
+                                    var isDynamicModuleCompilation = TypeScript.ArrayUtilities.any(fileNames, function (fileName) {
+                                        document = compiler.getDocument(fileName);
+                                        return !document.isDeclareFile() && document.isExternalModule();
+                                    });
+
+                                    if (this._outputDirectory || this._sourceRootDirectory || (this._sourceMapRootDirectory && (!this._sharedOutputFile || isDynamicModuleCompilation))) {
+                                        this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Cannot_find_the_common_subdirectory_path_for_the_input_files, null);
+                                        return;
+                                    }
+
+                                    return;
+                                }
+
+                                break;
+                            }
+                        }
+
+                        if (!updatedPath && fileComponents.length < commonComponentsLength) {
+                            commonComponentsLength = fileComponents.length;
+                        }
+                    }
+                }
+            }
+
+            this._commonDirectoryPath = commonComponents.slice(0, commonComponentsLength).join("/") + "/";
+        };
+        return EmitOptions;
+    })();
+    TypeScript.EmitOptions = EmitOptions;
+
+    var Indenter = (function () {
+        function Indenter() {
+            this.indentAmt = 0;
+        }
+        Indenter.prototype.increaseIndent = function () {
+            this.indentAmt += Indenter.indentStep;
+        };
+
+        Indenter.prototype.decreaseIndent = function () {
+            this.indentAmt -= Indenter.indentStep;
+        };
+
+        Indenter.prototype.getIndent = function () {
+            var indentString = Indenter.indentStrings[this.indentAmt];
+            if (indentString === undefined) {
+                indentString = "";
+                for (var i = 0; i < this.indentAmt; i = i + Indenter.indentStep) {
+                    indentString += Indenter.indentStepString;
+                }
+                Indenter.indentStrings[this.indentAmt] = indentString;
+            }
+            return indentString;
+        };
+        Indenter.indentStep = 4;
+        Indenter.indentStepString = "    ";
+        Indenter.indentStrings = [];
+        return Indenter;
+    })();
+    TypeScript.Indenter = Indenter;
+
+    function lastParameterIsRest(parameterList) {
+        var parameters = parameterList.parameters;
+        return parameters.nonSeparatorCount() > 0 && parameters.nonSeparatorAt(parameters.nonSeparatorCount() - 1).dotDotDotToken !== null;
+    }
+    TypeScript.lastParameterIsRest = lastParameterIsRest;
+
+    var Emitter = (function () {
+        function Emitter(emittingFileName, outfile, emitOptions, semanticInfoChain) {
+            this.emittingFileName = emittingFileName;
+            this.outfile = outfile;
+            this.emitOptions = emitOptions;
+            this.semanticInfoChain = semanticInfoChain;
+            this.globalThisCapturePrologueEmitted = false;
+            this.extendsPrologueEmitted = false;
+            this.thisClassNode = null;
+            this.inArrowFunction = false;
+            this.moduleName = "";
+            this.emitState = new EmitState();
+            this.indenter = new Indenter();
+            this.sourceMapper = null;
+            this.captureThisStmtString = "var _this = this;";
+            this.declStack = [];
+            this.exportAssignment = null;
+            this.inWithBlock = false;
+            this.document = null;
+            this.detachedCommentsElement = null;
+        }
+        Emitter.prototype.pushDecl = function (decl) {
+            if (decl) {
+                this.declStack[this.declStack.length] = decl;
+            }
+        };
+
+        Emitter.prototype.popDecl = function (decl) {
+            if (decl) {
+                this.declStack.length--;
+            }
+        };
+
+        Emitter.prototype.getEnclosingDecl = function () {
+            var declStackLen = this.declStack.length;
+            var enclosingDecl = declStackLen > 0 ? this.declStack[declStackLen - 1] : null;
+            return enclosingDecl;
+        };
+
+        Emitter.prototype.setExportAssignment = function (exportAssignment) {
+            this.exportAssignment = exportAssignment;
+        };
+
+        Emitter.prototype.getExportAssignment = function () {
+            return this.exportAssignment;
+        };
+
+        Emitter.prototype.setDocument = function (document) {
+            this.document = document;
+        };
+
+        Emitter.prototype.shouldEmitImportDeclaration = function (importDeclAST) {
+            var isExternalModuleReference = importDeclAST.moduleReference.kind() === 245 /* ExternalModuleReference */;
+            var importDecl = this.semanticInfoChain.getDeclForAST(importDeclAST);
+            var isExported = TypeScript.hasFlag(importDecl.flags, 1 /* Exported */);
+            var isAmdCodeGen = this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */;
+
+            if (isExternalModuleReference && !isExported && isAmdCodeGen) {
+                return false;
+            }
+
+            var importSymbol = importDecl.getSymbol();
+            if (importSymbol.isUsedAsValue()) {
+                return true;
+            }
+
+            if (importDeclAST.moduleReference.kind() !== 245 /* ExternalModuleReference */) {
+                var canBeUsedExternally = isExported || importSymbol.typeUsedExternally() || importSymbol.isUsedInExportedAlias();
+                if (!canBeUsedExternally && !this.document.isExternalModule()) {
+                    canBeUsedExternally = TypeScript.hasFlag(importDecl.getParentDecl().kind, 1 /* Script */ | 32 /* DynamicModule */);
+                }
+
+                if (canBeUsedExternally) {
+                    if (importSymbol.getExportAssignedValueSymbol()) {
+                        return true;
+                    }
+
+                    var containerSymbol = importSymbol.getExportAssignedContainerSymbol();
+                    if (containerSymbol && containerSymbol.getInstanceSymbol()) {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        Emitter.prototype.emitImportDeclaration = function (importDeclAST) {
+            var isExternalModuleReference = importDeclAST.moduleReference.kind() === 245 /* ExternalModuleReference */;
+            var importDecl = this.semanticInfoChain.getDeclForAST(importDeclAST);
+            var isExported = TypeScript.hasFlag(importDecl.flags, 1 /* Exported */);
+            var isAmdCodeGen = this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */;
+
+            this.emitComments(importDeclAST, true);
+
+            var importSymbol = importDecl.getSymbol();
+
+            var parentSymbol = importSymbol.getContainer();
+            var parentKind = parentSymbol ? parentSymbol.kind : 0 /* None */;
+            var associatedParentSymbol = parentSymbol ? parentSymbol.getAssociatedContainerType() : null;
+            var associatedParentSymbolKind = associatedParentSymbol ? associatedParentSymbol.kind : 0 /* None */;
+
+            var needsPropertyAssignment = false;
+            var usePropertyAssignmentInsteadOfVarDecl = false;
+            var moduleNamePrefix;
+
+            if (isExported && (parentKind === 4 /* Container */ || parentKind === 32 /* DynamicModule */ || associatedParentSymbolKind === 4 /* Container */ || associatedParentSymbolKind === 32 /* DynamicModule */)) {
+                if (importSymbol.getExportAssignedTypeSymbol() || importSymbol.getExportAssignedContainerSymbol()) {
+                    needsPropertyAssignment = true;
+                } else {
+                    var valueSymbol = importSymbol.getExportAssignedValueSymbol();
+                    if (valueSymbol && (valueSymbol.kind === 65536 /* Method */ || valueSymbol.kind === 16384 /* Function */)) {
+                        needsPropertyAssignment = true;
+                    } else {
+                        usePropertyAssignmentInsteadOfVarDecl = true;
+                    }
+                }
+
+                if (this.emitState.container === 2 /* DynamicModule */) {
+                    moduleNamePrefix = "exports.";
+                } else {
+                    moduleNamePrefix = this.moduleName + ".";
+                }
+            }
+
+            if (isAmdCodeGen && isExternalModuleReference) {
+                needsPropertyAssignment = true;
+            } else {
+                this.recordSourceMappingStart(importDeclAST);
+                if (usePropertyAssignmentInsteadOfVarDecl) {
+                    this.writeToOutput(moduleNamePrefix);
+                } else {
+                    this.writeToOutput("var ");
+                }
+                this.writeToOutput(importDeclAST.identifier.text() + " = ");
+                var aliasAST = importDeclAST.moduleReference;
+
+                if (isExternalModuleReference) {
+                    this.writeToOutput("require(" + aliasAST.stringLiteral.text() + ")");
+                } else {
+                    this.emitJavascript(aliasAST.moduleName, false);
+                }
+
+                this.recordSourceMappingEnd(importDeclAST);
+                this.writeToOutput(";");
+
+                if (needsPropertyAssignment) {
+                    this.writeLineToOutput("");
+                    this.emitIndent();
+                }
+            }
+
+            if (needsPropertyAssignment) {
+                this.writeToOutputWithSourceMapRecord(moduleNamePrefix + importDeclAST.identifier.text() + " = " + importDeclAST.identifier.text(), importDeclAST);
+                this.writeToOutput(";");
+            }
+            this.emitComments(importDeclAST, false);
+        };
+
+        Emitter.prototype.createSourceMapper = function (document, jsFileName, jsFile, sourceMapOut, resolvePath) {
+            this.sourceMapper = new TypeScript.SourceMapper(jsFile, sourceMapOut, document, jsFileName, this.emitOptions, resolvePath);
+        };
+
+        Emitter.prototype.setSourceMapperNewSourceFile = function (document) {
+            this.sourceMapper.setNewSourceFile(document, this.emitOptions);
+        };
+
+        Emitter.prototype.updateLineAndColumn = function (s) {
+            var lineNumbers = TypeScript.TextUtilities.parseLineStarts(s);
+            if (lineNumbers.length > 1) {
+                this.emitState.line += lineNumbers.length - 1;
+                this.emitState.column = s.length - lineNumbers[lineNumbers.length - 1];
+            } else {
+                this.emitState.column += s.length;
+            }
+        };
+
+        Emitter.prototype.writeToOutputWithSourceMapRecord = function (s, astSpan) {
+            this.recordSourceMappingStart(astSpan);
+            this.writeToOutput(s);
+            this.recordSourceMappingEnd(astSpan);
+        };
+
+        Emitter.prototype.writeToOutput = function (s) {
+            this.outfile.Write(s);
+            this.updateLineAndColumn(s);
+        };
+
+        Emitter.prototype.writeLineToOutput = function (s, force) {
+            if (typeof force === "undefined") { force = false; }
+            if (!force && s === "" && this.emitState.column === 0) {
+                return;
+            }
+
+            this.outfile.WriteLine(s);
+            this.updateLineAndColumn(s);
+            this.emitState.column = 0;
+            this.emitState.line++;
+        };
+
+        Emitter.prototype.writeCaptureThisStatement = function (ast) {
+            this.emitIndent();
+            this.writeToOutputWithSourceMapRecord(this.captureThisStmtString, ast);
+            this.writeLineToOutput("");
+        };
+
+        Emitter.prototype.setContainer = function (c) {
+            var temp = this.emitState.container;
+            this.emitState.container = c;
+            return temp;
+        };
+
+        Emitter.prototype.getIndentString = function () {
+            return this.indenter.getIndent();
+        };
+
+        Emitter.prototype.emitIndent = function () {
+            this.writeToOutput(this.getIndentString());
+        };
+
+        Emitter.prototype.emitComment = function (comment, trailing, first) {
+            if (this.emitOptions.compilationSettings().removeComments()) {
+                return;
+            }
+
+            var text = getTrimmedTextLines(comment);
+            var emitColumn = this.emitState.column;
+
+            if (emitColumn === 0) {
+                this.emitIndent();
+            } else if (trailing && first) {
+                this.writeToOutput(" ");
+            }
+
+            if (comment.kind() === 6 /* MultiLineCommentTrivia */) {
+                this.recordSourceMappingStart(comment);
+                this.writeToOutput(text[0]);
+
+                if (text.length > 1 || comment.endsLine) {
+                    for (var i = 1; i < text.length; i++) {
+                        this.writeLineToOutput("");
+                        this.emitIndent();
+                        this.writeToOutput(text[i]);
+                    }
+                    this.recordSourceMappingEnd(comment);
+                    this.writeLineToOutput("");
+                } else {
+                    this.recordSourceMappingEnd(comment);
+                    this.writeToOutput(" ");
+                    return;
+                }
+            } else {
+                this.recordSourceMappingStart(comment);
+                this.writeToOutput(text[0]);
+                this.recordSourceMappingEnd(comment);
+                this.writeLineToOutput("");
+            }
+
+            if (!trailing && emitColumn !== 0) {
+                this.emitIndent();
+            }
+        };
+
+        Emitter.prototype.emitComments = function (ast, pre, onlyPinnedOrTripleSlashComments) {
+            var _this = this;
+            if (typeof onlyPinnedOrTripleSlashComments === "undefined") { onlyPinnedOrTripleSlashComments = false; }
+            if (ast && ast.kind() !== 146 /* Block */) {
+                if (ast.parent.kind() === 219 /* SimpleArrowFunctionExpression */ || ast.parent.kind() === 218 /* ParenthesizedArrowFunctionExpression */) {
+                    return;
+                }
+            }
+
+            if (pre) {
+                var preComments = ast.preComments();
+
+                if (preComments && ast === this.detachedCommentsElement) {
+                    var detachedComments = this.getDetachedComments(ast);
+                    preComments = preComments.slice(detachedComments.length);
+                    this.detachedCommentsElement = null;
+                }
+
+                if (preComments && onlyPinnedOrTripleSlashComments) {
+                    preComments = TypeScript.ArrayUtilities.where(preComments, function (c) {
+                        return _this.isPinnedOrTripleSlash(c);
+                    });
+                }
+
+                this.emitCommentsArray(preComments, false);
+            } else {
+                this.emitCommentsArray(ast.postComments(), true);
+            }
+        };
+
+        Emitter.prototype.isPinnedOrTripleSlash = function (comment) {
+            var fullText = comment.fullText();
+            if (fullText.match(TypeScript.tripleSlashReferenceRegExp)) {
+                return true;
+            } else {
+                return fullText.indexOf("/*!") === 0;
+            }
+        };
+
+        Emitter.prototype.emitCommentsArray = function (comments, trailing) {
+            if (!this.emitOptions.compilationSettings().removeComments() && comments) {
+                for (var i = 0, n = comments.length; i < n; i++) {
+                    this.emitComment(comments[i], trailing, i === 0);
+                }
+            }
+        };
+
+        Emitter.prototype.emitObjectLiteralExpression = function (objectLiteral) {
+            this.recordSourceMappingStart(objectLiteral);
+
+            this.writeToOutput("{");
+            this.emitCommaSeparatedList(objectLiteral, objectLiteral.propertyAssignments, " ", true);
+            this.writeToOutput("}");
+
+            this.recordSourceMappingEnd(objectLiteral);
+        };
+
+        Emitter.prototype.emitArrayLiteralExpression = function (arrayLiteral) {
+            this.recordSourceMappingStart(arrayLiteral);
+
+            this.writeToOutput("[");
+            this.emitCommaSeparatedList(arrayLiteral, arrayLiteral.expressions, "", true);
+            this.writeToOutput("]");
+
+            this.recordSourceMappingEnd(arrayLiteral);
+        };
+
+        Emitter.prototype.emitObjectCreationExpression = function (objectCreationExpression) {
+            this.recordSourceMappingStart(objectCreationExpression);
+            this.writeToOutput("new ");
+            var target = objectCreationExpression.expression;
+
+            this.emit(target);
+            if (objectCreationExpression.argumentList) {
+                this.recordSourceMappingStart(objectCreationExpression.argumentList);
+                this.writeToOutput("(");
+                this.emitCommaSeparatedList(objectCreationExpression.argumentList, objectCreationExpression.argumentList.arguments, "", false);
+                this.writeToOutputWithSourceMapRecord(")", objectCreationExpression.argumentList.closeParenToken);
+                this.recordSourceMappingEnd(objectCreationExpression.argumentList);
+            }
+
+            this.recordSourceMappingEnd(objectCreationExpression);
+        };
+
+        Emitter.prototype.getConstantDecl = function (dotExpr) {
+            var pullSymbol = this.semanticInfoChain.getSymbolForAST(dotExpr);
+            if (pullSymbol && pullSymbol.kind === 67108864 /* EnumMember */) {
+                var pullDecls = pullSymbol.getDeclarations();
+                if (pullDecls.length === 1) {
+                    var pullDecl = pullDecls[0];
+                    if (pullDecl.kind === 67108864 /* EnumMember */) {
+                        return pullDecl;
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        Emitter.prototype.tryEmitConstant = function (dotExpr) {
+            var propertyName = dotExpr.name;
+            var boundDecl = this.getConstantDecl(dotExpr);
+            if (boundDecl) {
+                var value = boundDecl.constantValue;
+                if (value !== null) {
+                    this.recordSourceMappingStart(dotExpr);
+                    this.writeToOutput(value.toString());
+                    var comment = " /* ";
+                    comment += propertyName.text();
+                    comment += " */";
+                    this.writeToOutput(comment);
+                    this.recordSourceMappingEnd(dotExpr);
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        Emitter.prototype.emitInvocationExpression = function (callNode) {
+            this.recordSourceMappingStart(callNode);
+            var target = callNode.expression;
+            var args = callNode.argumentList.arguments;
+
+            if (target.kind() === 212 /* MemberAccessExpression */ && target.expression.kind() === 50 /* SuperKeyword */) {
+                this.emit(target);
+                this.writeToOutput(".call");
+                this.recordSourceMappingStart(args);
+                this.writeToOutput("(");
+                this.emitThis();
+                if (args && args.nonSeparatorCount() > 0) {
+                    this.writeToOutput(", ");
+                    this.emitCommaSeparatedList(callNode.argumentList, args, "", false);
+                }
+            } else {
+                if (callNode.expression.kind() === 50 /* SuperKeyword */ && this.emitState.container === 4 /* Constructor */) {
+                    this.writeToOutput("_super.call");
+                } else {
+                    this.emitJavascript(target, false);
+                }
+                this.recordSourceMappingStart(args);
+                this.writeToOutput("(");
+                if (callNode.expression.kind() === 50 /* SuperKeyword */ && this.emitState.container === 4 /* Constructor */) {
+                    this.writeToOutput("this");
+                    if (args && args.nonSeparatorCount() > 0) {
+                        this.writeToOutput(", ");
+                    }
+                }
+                this.emitCommaSeparatedList(callNode.argumentList, args, "", false);
+            }
+
+            this.writeToOutputWithSourceMapRecord(")", callNode.argumentList.closeParenToken);
+            this.recordSourceMappingEnd(args);
+            this.recordSourceMappingEnd(callNode);
+        };
+
+        Emitter.prototype.emitParameterList = function (list) {
+            this.writeToOutput("(");
+            this.emitCommentsArray(list.openParenTrailingComments, true);
+            this.emitFunctionParameters(TypeScript.ASTHelpers.parametersFromParameterList(list));
+            this.writeToOutput(")");
+        };
+
+        Emitter.prototype.emitFunctionParameters = function (parameters) {
+            var argsLen = 0;
+
+            if (parameters) {
+                this.emitComments(parameters.ast, true);
+
+                var tempContainer = this.setContainer(6 /* Args */);
+                argsLen = parameters.length;
+                var printLen = argsLen;
+                if (parameters.lastParameterIsRest()) {
+                    printLen--;
+                }
+                for (var i = 0; i < printLen; i++) {
+                    var arg = parameters.astAt(i);
+                    this.emit(arg);
+
+                    if (i < (printLen - 1)) {
+                        this.writeToOutput(", ");
+                    }
+                }
+                this.setContainer(tempContainer);
+
+                this.emitComments(parameters.ast, false);
+            }
+        };
+
+        Emitter.prototype.emitFunctionBodyStatements = function (name, funcDecl, parameterList, block, bodyExpression) {
+            this.writeLineToOutput(" {");
+            if (name) {
+                this.recordSourceMappingNameStart(name);
+            }
+
+            this.indenter.increaseIndent();
+
+            if (block) {
+                this.emitDetachedComments(block.statements);
+            }
+
+            if (this.shouldCaptureThis(funcDecl)) {
+                this.writeCaptureThisStatement(funcDecl);
+            }
+
+            if (parameterList) {
+                this.emitDefaultValueAssignments(parameterList);
+                this.emitRestParameterInitializer(parameterList);
+            }
+
+            if (block) {
+                this.emitList(block.statements);
+                this.emitCommentsArray(block.closeBraceLeadingComments, false);
+            } else {
+                this.emitIndent();
+                this.emitCommentsArray(bodyExpression.preComments(), false);
+                this.writeToOutput("return ");
+                this.emit(bodyExpression);
+                this.writeLineToOutput(";");
+                this.emitCommentsArray(bodyExpression.postComments(), true);
+            }
+
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+
+            if (block) {
+                this.writeToOutputWithSourceMapRecord("}", block.closeBraceToken);
+            } else {
+                this.writeToOutputWithSourceMapRecord("}", bodyExpression);
+            }
+
+            if (name) {
+                this.recordSourceMappingNameEnd();
+            }
+        };
+
+        Emitter.prototype.emitDefaultValueAssignments = function (parameters) {
+            var n = parameters.length;
+            if (parameters.lastParameterIsRest()) {
+                n--;
+            }
+
+            for (var i = 0; i < n; i++) {
+                var arg = parameters.astAt(i);
+                var id = parameters.identifierAt(i);
+                var equalsValueClause = parameters.initializerAt(i);
+                if (equalsValueClause) {
+                    this.emitIndent();
+                    this.recordSourceMappingStart(arg);
+                    this.writeToOutput("if (typeof " + id.text() + " === \"undefined\") { ");
+                    this.writeToOutputWithSourceMapRecord(id.text(), id);
+                    this.emitJavascript(equalsValueClause, false);
+                    this.writeLineToOutput("; }");
+                    this.recordSourceMappingEnd(arg);
+                }
+            }
+        };
+
+        Emitter.prototype.emitRestParameterInitializer = function (parameters) {
+            if (parameters.lastParameterIsRest()) {
+                var n = parameters.length;
+                var lastArg = parameters.astAt(n - 1);
+                var id = parameters.identifierAt(n - 1);
+                this.emitIndent();
+                this.recordSourceMappingStart(lastArg);
+                this.writeToOutput("var ");
+                this.writeToOutputWithSourceMapRecord(id.text(), id);
+                this.writeLineToOutput(" = [];");
+                this.recordSourceMappingEnd(lastArg);
+                this.emitIndent();
+                this.writeToOutput("for (");
+                this.writeToOutputWithSourceMapRecord("var _i = 0;", lastArg);
+                this.writeToOutput(" ");
+                this.writeToOutputWithSourceMapRecord("_i < (arguments.length - " + (n - 1) + ")", lastArg);
+                this.writeToOutput("; ");
+                this.writeToOutputWithSourceMapRecord("_i++", lastArg);
+                this.writeLineToOutput(") {");
+                this.indenter.increaseIndent();
+                this.emitIndent();
+
+                this.writeToOutputWithSourceMapRecord(id.text() + "[_i] = arguments[_i + " + (n - 1) + "];", lastArg);
+                this.writeLineToOutput("");
+                this.indenter.decreaseIndent();
+                this.emitIndent();
+                this.writeLineToOutput("}");
+            }
+        };
+
+        Emitter.prototype.getImportDecls = function (fileName) {
+            var topLevelDecl = this.semanticInfoChain.topLevelDecl(this.document.fileName);
+            var result = [];
+
+            var dynamicModuleDecl = topLevelDecl.getChildDecls()[0];
+            var queue = dynamicModuleDecl.getChildDecls();
+
+            for (var i = 0, n = queue.length; i < n; i++) {
+                var decl = queue[i];
+
+                if (decl.kind & 128 /* TypeAlias */) {
+                    var importStatementAST = this.semanticInfoChain.getASTForDecl(decl);
+                    if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) {
+                        var symbol = decl.getSymbol();
+                        var typeSymbol = symbol && symbol.type;
+                        if (typeSymbol && typeSymbol !== this.semanticInfoChain.anyTypeSymbol && !typeSymbol.isError()) {
+                            result.push(decl);
+                        }
+                    }
+                }
+            }
+
+            return result;
+        };
+
+        Emitter.prototype.getModuleImportAndDependencyList = function (sourceUnit) {
+            var importList = "";
+            var dependencyList = "";
+
+            var importDecls = this.getImportDecls(this.document.fileName);
+
+            if (importDecls.length) {
+                for (var i = 0; i < importDecls.length; i++) {
+                    var importStatementDecl = importDecls[i];
+                    var importStatementSymbol = importStatementDecl.getSymbol();
+                    var importStatementAST = this.semanticInfoChain.getASTForDecl(importStatementDecl);
+
+                    if (importStatementSymbol.isUsedAsValue()) {
+                        if (i <= importDecls.length - 1) {
+                            dependencyList += ", ";
+                            importList += ", ";
+                        }
+
+                        importList += importStatementDecl.name;
+                        dependencyList += importStatementAST.moduleReference.stringLiteral.text();
+                    }
+                }
+            }
+
+            var amdDependencies = this.document.amdDependencies();
+            for (var i = 0; i < amdDependencies.length; i++) {
+                dependencyList += ", \"" + amdDependencies[i] + "\"";
+            }
+
+            return {
+                importList: importList,
+                dependencyList: dependencyList
+            };
+        };
+
+        Emitter.prototype.shouldCaptureThis = function (ast) {
+            if (ast.kind() === 120 /* SourceUnit */) {
+                var scriptDecl = this.semanticInfoChain.topLevelDecl(this.document.fileName);
+                return TypeScript.hasFlag(scriptDecl.flags, 262144 /* MustCaptureThis */);
+            }
+
+            var decl = this.semanticInfoChain.getDeclForAST(ast);
+            if (decl) {
+                return TypeScript.hasFlag(decl.flags, 262144 /* MustCaptureThis */);
+            }
+
+            return false;
+        };
+
+        Emitter.prototype.emitEnum = function (moduleDecl) {
+            var pullDecl = this.semanticInfoChain.getDeclForAST(moduleDecl);
+            this.pushDecl(pullDecl);
+
+            var svModuleName = this.moduleName;
+            this.moduleName = moduleDecl.identifier.text();
+
+            var temp = this.setContainer(1 /* Module */);
+            var isExported = TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */);
+
+            if (!isExported) {
+                this.recordSourceMappingStart(moduleDecl);
+                this.writeToOutput("var ");
+                this.recordSourceMappingStart(moduleDecl.identifier);
+                this.writeToOutput(this.moduleName);
+                this.recordSourceMappingEnd(moduleDecl.identifier);
+                this.writeLineToOutput(";");
+                this.recordSourceMappingEnd(moduleDecl);
+                this.emitIndent();
+            }
+
+            this.writeToOutput("(");
+            this.recordSourceMappingStart(moduleDecl);
+            this.writeToOutput("function (");
+            this.writeToOutputWithSourceMapRecord(this.moduleName, moduleDecl.identifier);
+            this.writeLineToOutput(") {");
+
+            this.recordSourceMappingNameStart(this.moduleName);
+
+            this.indenter.increaseIndent();
+
+            if (this.shouldCaptureThis(moduleDecl)) {
+                this.writeCaptureThisStatement(moduleDecl);
+            }
+
+            this.emitSeparatedList(moduleDecl.enumElements);
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+
+            var parentIsDynamic = temp === 2 /* DynamicModule */;
+            if (temp === 0 /* Prog */ && isExported) {
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.writeToOutput(")(this." + this.moduleName + " || (this." + this.moduleName + " = {}));");
+            } else if (isExported || temp === 0 /* Prog */) {
+                var dotMod = svModuleName !== "" ? (parentIsDynamic ? "exports" : svModuleName) + "." : svModuleName;
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.writeToOutput(")(" + dotMod + this.moduleName + " || (" + dotMod + this.moduleName + " = {}));");
+            } else if (!isExported && temp !== 0 /* Prog */) {
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.writeToOutput(")(" + this.moduleName + " || (" + this.moduleName + " = {}));");
+            } else {
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.writeToOutput(")();");
+            }
+
+            this.recordSourceMappingEnd(moduleDecl);
+            if (temp !== 0 /* Prog */ && isExported) {
+                this.recordSourceMappingStart(moduleDecl);
+                if (parentIsDynamic) {
+                    this.writeLineToOutput("");
+                    this.emitIndent();
+                    this.writeToOutput("var " + this.moduleName + " = exports." + this.moduleName + ";");
+                } else {
+                    this.writeLineToOutput("");
+                    this.emitIndent();
+                    this.writeToOutput("var " + this.moduleName + " = " + svModuleName + "." + this.moduleName + ";");
+                }
+                this.recordSourceMappingEnd(moduleDecl);
+            }
+
+            this.setContainer(temp);
+            this.moduleName = svModuleName;
+
+            this.popDecl(pullDecl);
+        };
+
+        Emitter.prototype.getModuleDeclToVerifyChildNameCollision = function (moduleDecl, changeNameIfAnyDeclarationInContext) {
+            if (TypeScript.ArrayUtilities.contains(this.declStack, moduleDecl)) {
+                return moduleDecl;
+            } else if (changeNameIfAnyDeclarationInContext) {
+                var symbol = moduleDecl.getSymbol();
+                if (symbol) {
+                    var otherDecls = symbol.getDeclarations();
+                    for (var i = 0; i < otherDecls.length; i++) {
+                        if (TypeScript.ArrayUtilities.contains(this.declStack, otherDecls[i])) {
+                            return otherDecls[i];
+                        }
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        Emitter.prototype.hasChildNameCollision = function (moduleName, parentDecl) {
+            var _this = this;
+            var childDecls = parentDecl.getChildDecls();
+            return TypeScript.ArrayUtilities.any(childDecls, function (childDecl) {
+                var childAST = _this.semanticInfoChain.getASTForDecl(childDecl);
+
+                if (childDecl.kind != 67108864 /* EnumMember */ && _this.shouldEmit(childAST)) {
+                    if (childDecl.name === moduleName) {
+                        if (parentDecl.kind != 8 /* Class */) {
+                            return true;
+                        }
+
+                        if (!(childDecl.kind == 65536 /* Method */ || childDecl.kind == 4096 /* Property */ || childDecl.kind == 524288 /* SetAccessor */ || childDecl.kind == 262144 /* GetAccessor */)) {
+                            return true;
+                        }
+                    }
+
+                    if (_this.hasChildNameCollision(moduleName, childDecl)) {
+                        return true;
+                    }
+                }
+                return false;
+            });
+        };
+
+        Emitter.prototype.getModuleName = function (moduleDecl, changeNameIfAnyDeclarationInContext) {
+            var moduleName = moduleDecl.name;
+            var moduleDisplayName = moduleDecl.getDisplayName();
+
+            moduleDecl = this.getModuleDeclToVerifyChildNameCollision(moduleDecl, changeNameIfAnyDeclarationInContext);
+            if (moduleDecl && moduleDecl.kind != 64 /* Enum */) {
+                while (this.hasChildNameCollision(moduleName, moduleDecl)) {
+                    moduleName = "_" + moduleName;
+                    moduleDisplayName = "_" + moduleDisplayName;
+                }
+            }
+
+            return moduleDisplayName;
+        };
+
+        Emitter.prototype.emitModuleDeclarationWorker = function (moduleDecl) {
+            if (moduleDecl.stringLiteral) {
+                this.emitSingleModuleDeclaration(moduleDecl, moduleDecl.stringLiteral);
+            } else {
+                var moduleNames = TypeScript.ASTHelpers.getModuleNames(moduleDecl.name);
+                this.emitSingleModuleDeclaration(moduleDecl, moduleNames[0]);
+            }
+        };
+
+        Emitter.prototype.emitSingleModuleDeclaration = function (moduleDecl, moduleName) {
+            var isLastName = TypeScript.ASTHelpers.isLastNameOfModule(moduleDecl, moduleName);
+
+            if (isLastName) {
+                this.emitComments(moduleDecl, true);
+            }
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(moduleName);
+            this.pushDecl(pullDecl);
+
+            var svModuleName = this.moduleName;
+
+            if (moduleDecl.stringLiteral) {
+                this.moduleName = moduleDecl.stringLiteral.valueText();
+                if (TypeScript.isTSFile(this.moduleName)) {
+                    this.moduleName = this.moduleName.substring(0, this.moduleName.length - ".ts".length);
+                }
+            } else {
+                this.moduleName = moduleName.text();
+            }
+
+            var temp = this.setContainer(1 /* Module */);
+            var isExported = TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */);
+
+            if (!isExported) {
+                this.recordSourceMappingStart(moduleDecl);
+                this.writeToOutput("var ");
+                this.recordSourceMappingStart(moduleName);
+                this.writeToOutput(this.moduleName);
+                this.recordSourceMappingEnd(moduleName);
+                this.writeLineToOutput(";");
+                this.recordSourceMappingEnd(moduleDecl);
+                this.emitIndent();
+            }
+
+            this.writeToOutput("(");
+            this.recordSourceMappingStart(moduleDecl);
+            this.writeToOutput("function (");
+
+            this.moduleName = this.getModuleName(pullDecl);
+            this.writeToOutputWithSourceMapRecord(this.moduleName, moduleName);
+            this.writeLineToOutput(") {");
+
+            this.recordSourceMappingNameStart(moduleName.text());
+
+            this.indenter.increaseIndent();
+
+            if (this.shouldCaptureThis(moduleDecl)) {
+                this.writeCaptureThisStatement(moduleDecl);
+            }
+
+            if (moduleName === moduleDecl.stringLiteral) {
+                this.emitList(moduleDecl.moduleElements);
+            } else {
+                var moduleNames = TypeScript.ASTHelpers.getModuleNames(moduleDecl.name);
+                var nameIndex = moduleNames.indexOf(moduleName);
+                TypeScript.Debug.assert(nameIndex >= 0);
+
+                if (isLastName) {
+                    this.emitList(moduleDecl.moduleElements);
+                } else {
+                    this.emitIndent();
+                    this.emitSingleModuleDeclaration(moduleDecl, moduleNames[nameIndex + 1]);
+                    this.writeLineToOutput("");
+                }
+            }
+
+            this.moduleName = moduleName.text();
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+
+            var parentIsDynamic = temp === 2 /* DynamicModule */;
+            this.recordSourceMappingStart(moduleDecl.endingToken);
+            if (temp === 0 /* Prog */ && isExported) {
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.recordSourceMappingEnd(moduleDecl.endingToken);
+                this.writeToOutput(")(this." + this.moduleName + " || (this." + this.moduleName + " = {}));");
+            } else if (isExported || temp === 0 /* Prog */) {
+                var dotMod = svModuleName !== "" ? (parentIsDynamic ? "exports" : svModuleName) + "." : svModuleName;
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.recordSourceMappingEnd(moduleDecl.endingToken);
+                this.writeToOutput(")(" + dotMod + this.moduleName + " || (" + dotMod + this.moduleName + " = {}));");
+            } else if (!isExported && temp !== 0 /* Prog */) {
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.recordSourceMappingEnd(moduleDecl.endingToken);
+                this.writeToOutput(")(" + this.moduleName + " || (" + this.moduleName + " = {}));");
+            } else {
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.recordSourceMappingEnd(moduleDecl.endingToken);
+                this.writeToOutput(")();");
+            }
+
+            this.recordSourceMappingEnd(moduleDecl);
+            if (temp !== 0 /* Prog */ && isExported) {
+                this.recordSourceMappingStart(moduleDecl);
+                if (parentIsDynamic) {
+                    this.writeLineToOutput("");
+                    this.emitIndent();
+                    this.writeToOutput("var " + this.moduleName + " = exports." + this.moduleName + ";");
+                } else {
+                    this.writeLineToOutput("");
+                    this.emitIndent();
+                    this.writeToOutput("var " + this.moduleName + " = " + svModuleName + "." + this.moduleName + ";");
+                }
+                this.recordSourceMappingEnd(moduleDecl);
+            }
+
+            this.setContainer(temp);
+            this.moduleName = svModuleName;
+
+            this.popDecl(pullDecl);
+
+            if (isLastName) {
+                this.emitComments(moduleDecl, false);
+            }
+        };
+
+        Emitter.prototype.emitEnumElement = function (varDecl) {
+            var pullDecl = this.semanticInfoChain.getDeclForAST(varDecl);
+            TypeScript.Debug.assert(pullDecl && pullDecl.kind === 67108864 /* EnumMember */);
+
+            this.emitComments(varDecl, true);
+            this.recordSourceMappingStart(varDecl);
+            var name = varDecl.propertyName.text();
+            var quoted = TypeScript.isQuoted(name);
+            this.writeToOutput(this.moduleName);
+            this.writeToOutput('[');
+            this.writeToOutput(this.moduleName);
+            this.writeToOutput('[');
+            this.writeToOutput(quoted ? name : '"' + name + '"');
+            this.writeToOutput(']');
+
+            if (varDecl.equalsValueClause) {
+                this.emit(varDecl.equalsValueClause);
+            } else if (pullDecl.constantValue !== null) {
+                this.writeToOutput(' = ');
+                this.writeToOutput(pullDecl.constantValue.toString());
+            } else {
+                this.writeToOutput(' = null');
+            }
+
+            this.writeToOutput('] = ');
+            this.writeToOutput(quoted ? name : '"' + name + '"');
+            this.recordSourceMappingEnd(varDecl);
+            this.emitComments(varDecl, false);
+            this.writeToOutput(';');
+        };
+
+        Emitter.prototype.emitElementAccessExpression = function (expression) {
+            this.recordSourceMappingStart(expression);
+            this.emit(expression.expression);
+            this.writeToOutput("[");
+            this.emit(expression.argumentExpression);
+            this.writeToOutput("]");
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.emitSimpleArrowFunctionExpression = function (arrowFunction) {
+            this.emitAnyArrowFunctionExpression(arrowFunction, null, TypeScript.ASTHelpers.parametersFromIdentifier(arrowFunction.identifier), arrowFunction.block, arrowFunction.expression);
+        };
+
+        Emitter.prototype.emitParenthesizedArrowFunctionExpression = function (arrowFunction) {
+            this.emitAnyArrowFunctionExpression(arrowFunction, null, TypeScript.ASTHelpers.parametersFromParameterList(arrowFunction.callSignature.parameterList), arrowFunction.block, arrowFunction.expression);
+        };
+
+        Emitter.prototype.emitAnyArrowFunctionExpression = function (arrowFunction, funcName, parameters, block, expression) {
+            var savedInArrowFunction = this.inArrowFunction;
+            this.inArrowFunction = true;
+
+            var temp = this.setContainer(5 /* Function */);
+
+            this.recordSourceMappingStart(arrowFunction);
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(arrowFunction);
+            this.pushDecl(pullDecl);
+
+            this.emitComments(arrowFunction, true);
+
+            this.recordSourceMappingStart(arrowFunction);
+            this.writeToOutput("function ");
+            this.writeToOutput("(");
+            this.emitFunctionParameters(parameters);
+            this.writeToOutput(")");
+
+            this.emitFunctionBodyStatements(funcName, arrowFunction, parameters, block, expression);
+
+            this.recordSourceMappingEnd(arrowFunction);
+
+            this.recordSourceMappingEnd(arrowFunction);
+
+            this.emitComments(arrowFunction, false);
+
+            this.popDecl(pullDecl);
+            this.setContainer(temp);
+            this.inArrowFunction = savedInArrowFunction;
+        };
+
+        Emitter.prototype.emitConstructor = function (funcDecl) {
+            if (!funcDecl.block) {
+                return;
+            }
+            var temp = this.setContainer(4 /* Constructor */);
+
+            this.recordSourceMappingStart(funcDecl);
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            this.pushDecl(pullDecl);
+
+            this.emitComments(funcDecl, true);
+
+            this.recordSourceMappingStart(funcDecl);
+            this.writeToOutput("function ");
+            this.writeToOutput(this.thisClassNode.identifier.text());
+            this.writeToOutput("(");
+            var parameters = TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList);
+            this.emitFunctionParameters(parameters);
+            this.writeLineToOutput(") {");
+
+            this.recordSourceMappingNameStart("constructor");
+            this.indenter.increaseIndent();
+
+            this.emitDefaultValueAssignments(parameters);
+            this.emitRestParameterInitializer(parameters);
+
+            if (this.shouldCaptureThis(funcDecl)) {
+                this.writeCaptureThisStatement(funcDecl);
+            }
+
+            this.emitConstructorStatements(funcDecl);
+            this.emitCommentsArray(funcDecl.block.closeBraceLeadingComments, false);
+
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+            this.writeToOutputWithSourceMapRecord("}", funcDecl.block.closeBraceToken);
+
+            this.recordSourceMappingNameEnd();
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.emitComments(funcDecl, false);
+
+            this.popDecl(pullDecl);
+            this.setContainer(temp);
+        };
+
+        Emitter.prototype.emitGetAccessor = function (accessor) {
+            this.recordSourceMappingStart(accessor);
+            this.writeToOutput("get ");
+
+            var temp = this.setContainer(5 /* Function */);
+
+            this.recordSourceMappingStart(accessor);
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(accessor);
+            this.pushDecl(pullDecl);
+
+            this.recordSourceMappingStart(accessor);
+
+            var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(accessor, this.semanticInfoChain);
+            var container = accessorSymbol.getContainer();
+            var containerKind = container.kind;
+
+            this.recordSourceMappingNameStart(accessor.propertyName.text());
+            this.writeToOutput(accessor.propertyName.text());
+            this.writeToOutput("(");
+            this.writeToOutput(")");
+
+            this.emitFunctionBodyStatements(null, accessor, TypeScript.ASTHelpers.parametersFromParameterList(accessor.parameterList), accessor.block, null);
+
+            this.recordSourceMappingEnd(accessor);
+
+            this.recordSourceMappingEnd(accessor);
+
+            this.popDecl(pullDecl);
+            this.setContainer(temp);
+            this.recordSourceMappingEnd(accessor);
+        };
+
+        Emitter.prototype.emitSetAccessor = function (accessor) {
+            this.recordSourceMappingStart(accessor);
+            this.writeToOutput("set ");
+
+            var temp = this.setContainer(5 /* Function */);
+
+            this.recordSourceMappingStart(accessor);
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(accessor);
+            this.pushDecl(pullDecl);
+
+            this.recordSourceMappingStart(accessor);
+
+            var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(accessor, this.semanticInfoChain);
+            var container = accessorSymbol.getContainer();
+            var containerKind = container.kind;
+
+            this.recordSourceMappingNameStart(accessor.propertyName.text());
+            this.writeToOutput(accessor.propertyName.text());
+            this.writeToOutput("(");
+
+            var parameters = TypeScript.ASTHelpers.parametersFromParameterList(accessor.parameterList);
+            this.emitFunctionParameters(parameters);
+            this.writeToOutput(")");
+
+            this.emitFunctionBodyStatements(null, accessor, parameters, accessor.block, null);
+
+            this.recordSourceMappingEnd(accessor);
+
+            this.recordSourceMappingEnd(accessor);
+
+            this.popDecl(pullDecl);
+            this.setContainer(temp);
+            this.recordSourceMappingEnd(accessor);
+        };
+
+        Emitter.prototype.emitFunctionExpression = function (funcDecl) {
+            var savedInArrowFunction = this.inArrowFunction;
+            this.inArrowFunction = false;
+
+            var temp = this.setContainer(5 /* Function */);
+
+            var funcName = funcDecl.identifier ? funcDecl.identifier.text() : null;
+
+            this.recordSourceMappingStart(funcDecl);
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            this.pushDecl(pullDecl);
+
+            this.recordSourceMappingStart(funcDecl);
+            this.writeToOutput("function ");
+
+            if (funcDecl.identifier) {
+                this.recordSourceMappingStart(funcDecl.identifier);
+                this.writeToOutput(funcDecl.identifier.text());
+                this.recordSourceMappingEnd(funcDecl.identifier);
+            }
+
+            this.writeToOutput("(");
+
+            var parameters = TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList);
+            this.emitFunctionParameters(parameters);
+            this.writeToOutput(")");
+
+            this.emitFunctionBodyStatements(funcName, funcDecl, parameters, funcDecl.block, null);
+
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.emitComments(funcDecl, false);
+
+            this.popDecl(pullDecl);
+
+            this.setContainer(temp);
+            this.inArrowFunction = savedInArrowFunction;
+        };
+
+        Emitter.prototype.emitFunction = function (funcDecl) {
+            if (funcDecl.block === null) {
+                return;
+            }
+            var savedInArrowFunction = this.inArrowFunction;
+            this.inArrowFunction = false;
+
+            var temp = this.setContainer(5 /* Function */);
+
+            var funcName = funcDecl.identifier.text();
+
+            this.recordSourceMappingStart(funcDecl);
+
+            var printName = funcDecl.identifier !== null;
+            var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            this.pushDecl(pullDecl);
+
+            this.emitComments(funcDecl, true);
+
+            this.recordSourceMappingStart(funcDecl);
+            this.writeToOutput("function ");
+
+            if (printName) {
+                var id = funcDecl.identifier.text();
+                if (id) {
+                    if (funcDecl.identifier) {
+                        this.recordSourceMappingStart(funcDecl.identifier);
+                    }
+                    this.writeToOutput(id);
+                    if (funcDecl.identifier) {
+                        this.recordSourceMappingEnd(funcDecl.identifier);
+                    }
+                }
+            }
+
+            this.emitParameterList(funcDecl.callSignature.parameterList);
+
+            var parameters = TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList);
+            this.emitFunctionBodyStatements(funcDecl.identifier.text(), funcDecl, parameters, funcDecl.block, null);
+
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.emitComments(funcDecl, false);
+
+            this.popDecl(pullDecl);
+
+            this.setContainer(temp);
+            this.inArrowFunction = savedInArrowFunction;
+
+            if (funcDecl.block) {
+                var pullFunctionDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+                if ((this.emitState.container === 1 /* Module */ || this.emitState.container === 2 /* DynamicModule */) && pullFunctionDecl && TypeScript.hasFlag(pullFunctionDecl.flags, 1 /* Exported */)) {
+                    this.writeLineToOutput("");
+                    this.emitIndent();
+                    var modName = this.emitState.container === 1 /* Module */ ? this.moduleName : "exports";
+                    this.recordSourceMappingStart(funcDecl);
+                    this.writeToOutput(modName + "." + funcName + " = " + funcName + ";");
+                    this.recordSourceMappingEnd(funcDecl);
+                }
+            }
+        };
+
+        Emitter.prototype.emitAmbientVarDecl = function (varDecl) {
+            this.recordSourceMappingStart(this.currentVariableDeclaration);
+            if (varDecl.equalsValueClause) {
+                this.emitComments(varDecl, true);
+                this.recordSourceMappingStart(varDecl);
+                this.writeToOutputWithSourceMapRecord(varDecl.propertyName.text(), varDecl.propertyName);
+                this.emitJavascript(varDecl.equalsValueClause, false);
+                this.recordSourceMappingEnd(varDecl);
+                this.emitComments(varDecl, false);
+            }
+        };
+
+        Emitter.prototype.emitVarDeclVar = function () {
+            if (this.currentVariableDeclaration) {
+                this.writeToOutput("var ");
+            }
+        };
+
+        Emitter.prototype.emitVariableDeclaration = function (declaration) {
+            var varDecl = declaration.declarators.nonSeparatorAt(0);
+
+            var symbol = this.semanticInfoChain.getSymbolForAST(varDecl);
+
+            var parentSymbol = symbol ? symbol.getContainer() : null;
+            var parentKind = parentSymbol ? parentSymbol.kind : 0 /* None */;
+
+            this.emitComments(declaration, true);
+
+            var pullVarDecl = this.semanticInfoChain.getDeclForAST(varDecl);
+            var isAmbientWithoutInit = pullVarDecl && TypeScript.hasFlag(pullVarDecl.flags, 8 /* Ambient */) && varDecl.equalsValueClause === null;
+            if (!isAmbientWithoutInit) {
+                var prevVariableDeclaration = this.currentVariableDeclaration;
+                this.currentVariableDeclaration = declaration;
+
+                for (var i = 0, n = declaration.declarators.nonSeparatorCount(); i < n; i++) {
+                    var declarator = declaration.declarators.nonSeparatorAt(i);
+
+                    if (i > 0) {
+                        this.writeToOutput(", ");
+                    }
+
+                    this.emit(declarator);
+                }
+                this.currentVariableDeclaration = prevVariableDeclaration;
+
+                this.recordSourceMappingEnd(declaration);
+            }
+
+            this.emitComments(declaration, false);
+        };
+
+        Emitter.prototype.emitMemberVariableDeclaration = function (varDecl) {
+            TypeScript.Debug.assert(!TypeScript.hasModifier(varDecl.modifiers, 16 /* Static */) && varDecl.variableDeclarator.equalsValueClause);
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(varDecl);
+            this.pushDecl(pullDecl);
+
+            this.emitComments(varDecl, true);
+            this.recordSourceMappingStart(varDecl);
+
+            var varDeclName = varDecl.variableDeclarator.propertyName.text();
+            var quotedOrNumber = TypeScript.isQuoted(varDeclName) || varDecl.variableDeclarator.propertyName.kind() !== 11 /* IdentifierName */;
+
+            var symbol = this.semanticInfoChain.getSymbolForAST(varDecl);
+            var parentSymbol = symbol ? symbol.getContainer() : null;
+            var parentDecl = pullDecl && pullDecl.getParentDecl();
+
+            if (quotedOrNumber) {
+                this.writeToOutput("this[");
+            } else {
+                this.writeToOutput("this.");
+            }
+
+            this.writeToOutputWithSourceMapRecord(varDecl.variableDeclarator.propertyName.text(), varDecl.variableDeclarator.propertyName);
+
+            if (quotedOrNumber) {
+                this.writeToOutput("]");
+            }
+
+            if (varDecl.variableDeclarator.equalsValueClause) {
+                var prevVariableDeclaration = this.currentVariableDeclaration;
+                this.emit(varDecl.variableDeclarator.equalsValueClause);
+                this.currentVariableDeclaration = prevVariableDeclaration;
+            }
+
+            if (this.emitState.container !== 6 /* Args */) {
+                this.writeToOutput(";");
+            }
+
+            this.recordSourceMappingEnd(varDecl);
+            this.emitComments(varDecl, false);
+
+            this.popDecl(pullDecl);
+        };
+
+        Emitter.prototype.emitVariableDeclarator = function (varDecl) {
+            var pullDecl = this.semanticInfoChain.getDeclForAST(varDecl);
+            this.pushDecl(pullDecl);
+            if (pullDecl && (pullDecl.flags & 8 /* Ambient */) === 8 /* Ambient */) {
+                this.emitAmbientVarDecl(varDecl);
+            } else {
+                this.emitComments(varDecl, true);
+                this.recordSourceMappingStart(this.currentVariableDeclaration);
+                this.recordSourceMappingStart(varDecl);
+
+                var varDeclName = varDecl.propertyName.text();
+
+                var symbol = this.semanticInfoChain.getSymbolForAST(varDecl);
+                var parentSymbol = symbol ? symbol.getContainer() : null;
+                var parentDecl = pullDecl && pullDecl.getParentDecl();
+                var parentIsModule = parentDecl && (parentDecl.flags & 102400 /* SomeInitializedModule */);
+
+                if (parentIsModule) {
+                    if (!TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */)) {
+                        this.emitVarDeclVar();
+                    } else {
+                        if (this.emitState.container === 2 /* DynamicModule */) {
+                            this.writeToOutput("exports.");
+                        } else {
+                            this.writeToOutput(this.moduleName + ".");
+                        }
+                    }
+                } else {
+                    this.emitVarDeclVar();
+                }
+
+                this.writeToOutputWithSourceMapRecord(varDecl.propertyName.text(), varDecl.propertyName);
+
+                if (varDecl.equalsValueClause) {
+                    var prevVariableDeclaration = this.currentVariableDeclaration;
+                    this.emit(varDecl.equalsValueClause);
+                    this.currentVariableDeclaration = prevVariableDeclaration;
+                }
+
+                this.recordSourceMappingEnd(varDecl);
+                this.emitComments(varDecl, false);
+            }
+            this.currentVariableDeclaration = undefined;
+            this.popDecl(pullDecl);
+        };
+
+        Emitter.prototype.symbolIsUsedInItsEnclosingContainer = function (symbol, dynamic) {
+            if (typeof dynamic === "undefined") { dynamic = false; }
+            var symDecls = symbol.getDeclarations();
+
+            if (symDecls.length) {
+                var enclosingDecl = this.getEnclosingDecl();
+                if (enclosingDecl) {
+                    var parentDecl = symDecls[0].getParentDecl();
+                    if (parentDecl) {
+                        var symbolDeclarationEnclosingContainer = parentDecl;
+                        var enclosingContainer = enclosingDecl;
+
+                        while (symbolDeclarationEnclosingContainer) {
+                            if (symbolDeclarationEnclosingContainer.kind === (dynamic ? 32 /* DynamicModule */ : 4 /* Container */)) {
+                                break;
+                            }
+                            symbolDeclarationEnclosingContainer = symbolDeclarationEnclosingContainer.getParentDecl();
+                        }
+
+                        if (symbolDeclarationEnclosingContainer) {
+                            while (enclosingContainer) {
+                                if (enclosingContainer.kind === (dynamic ? 32 /* DynamicModule */ : 4 /* Container */)) {
+                                    break;
+                                }
+
+                                enclosingContainer = enclosingContainer.getParentDecl();
+                            }
+                        }
+
+                        if (symbolDeclarationEnclosingContainer && enclosingContainer) {
+                            var same = symbolDeclarationEnclosingContainer === enclosingContainer;
+
+                            if (!same && symbol.anyDeclHasFlag(32768 /* InitializedModule */)) {
+                                same = symbolDeclarationEnclosingContainer === enclosingContainer.getParentDecl();
+                            }
+
+                            return same;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        Emitter.prototype.shouldQualifySymbolNameWithParentName = function (symbol) {
+            var enclosingContextDeclPath = this.declStack;
+            var symbolDeclarations = symbol.getDeclarations();
+            for (var i = 0; i < symbolDeclarations.length; i++) {
+                var currentDecl = symbolDeclarations[i];
+                var declParent = currentDecl.getParentDecl();
+
+                if (currentDecl.kind === 67108864 /* EnumMember */) {
+                    return true;
+                }
+
+                if (!TypeScript.hasFlag(currentDecl.flags, 1 /* Exported */)) {
+                    return false;
+                }
+
+                if (currentDecl.kind === 512 /* Variable */ && !TypeScript.hasFlag(currentDecl.flags, 118784 /* ImplicitVariable */)) {
+                    return true;
+                }
+
+                if (TypeScript.ArrayUtilities.contains(this.declStack, declParent)) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        Emitter.prototype.getSymbolForEmit = function (ast) {
+            var pullSymbol = this.semanticInfoChain.getSymbolForAST(ast);
+            var pullSymbolAlias = this.semanticInfoChain.getAliasSymbolForAST(ast);
+            if (pullSymbol && pullSymbolAlias) {
+                var symbolToCompare = TypeScript.isTypesOnlyLocation(ast) ? pullSymbolAlias.getExportAssignedTypeSymbol() : pullSymbolAlias.getExportAssignedValueSymbol();
+
+                if (pullSymbol === symbolToCompare) {
+                    pullSymbol = pullSymbolAlias;
+                    pullSymbolAlias = null;
+                }
+            }
+            return { symbol: pullSymbol, aliasSymbol: pullSymbolAlias };
+        };
+
+        Emitter.prototype.emitName = function (name, addThis) {
+            this.emitComments(name, true);
+            this.recordSourceMappingStart(name);
+            if (name.text().length > 0) {
+                var symbolForEmit = this.getSymbolForEmit(name);
+                var pullSymbol = symbolForEmit.symbol;
+                if (!pullSymbol) {
+                    pullSymbol = this.semanticInfoChain.anyTypeSymbol;
+                }
+                var pullSymbolAlias = symbolForEmit.aliasSymbol;
+                var pullSymbolKind = pullSymbol.kind;
+                var isLocalAlias = pullSymbolAlias && (pullSymbolAlias.getDeclarations()[0].getParentDecl() === this.getEnclosingDecl());
+                if (addThis && (this.emitState.container !== 6 /* Args */) && pullSymbol) {
+                    var pullSymbolContainer = pullSymbol.getContainer();
+
+                    if (pullSymbolContainer) {
+                        var pullSymbolContainerKind = pullSymbolContainer.kind;
+
+                        if (TypeScript.PullHelpers.symbolIsModule(pullSymbolContainer) || pullSymbolContainerKind === 64 /* Enum */ || pullSymbolContainer.anyDeclHasFlag(32768 /* InitializedModule */ | 4096 /* Enum */)) {
+                            var needToEmitParentName = this.shouldQualifySymbolNameWithParentName(pullSymbol);
+                            if (needToEmitParentName) {
+                                var parentDecl = pullSymbol.getDeclarations()[0].getParentDecl();
+                                TypeScript.Debug.assert(parentDecl && !parentDecl.isRootDecl());
+                                this.writeToOutput(this.getModuleName(parentDecl, true) + ".");
+                            }
+                        } else if (pullSymbolContainerKind === 32 /* DynamicModule */ || pullSymbolContainer.anyDeclHasFlag(65536 /* InitializedDynamicModule */)) {
+                            if (pullSymbolKind === 4096 /* Property */) {
+                                this.writeToOutput("exports.");
+                            } else if (pullSymbol.anyDeclHasFlag(1 /* Exported */) && !isLocalAlias && !pullSymbol.anyDeclHasFlag(118784 /* ImplicitVariable */) && pullSymbol.kind !== 32768 /* ConstructorMethod */ && pullSymbol.kind !== 8 /* Class */ && pullSymbol.kind !== 64 /* Enum */) {
+                                this.writeToOutput("exports.");
+                            }
+                        }
+                    }
+                }
+
+                this.writeToOutput(name.text());
+            }
+
+            this.recordSourceMappingEnd(name);
+            this.emitComments(name, false);
+        };
+
+        Emitter.prototype.recordSourceMappingNameStart = function (name) {
+            if (this.sourceMapper) {
+                var nameIndex = -1;
+                if (name) {
+                    if (this.sourceMapper.currentNameIndex.length > 0) {
+                        var parentNameIndex = this.sourceMapper.currentNameIndex[this.sourceMapper.currentNameIndex.length - 1];
+                        if (parentNameIndex !== -1) {
+                            name = this.sourceMapper.names[parentNameIndex] + "." + name;
+                        }
+                    }
+
+                    var nameIndex = this.sourceMapper.names.length - 1;
+                    for (nameIndex; nameIndex >= 0; nameIndex--) {
+                        if (this.sourceMapper.names[nameIndex] === name) {
+                            break;
+                        }
+                    }
+
+                    if (nameIndex === -1) {
+                        nameIndex = this.sourceMapper.names.length;
+                        this.sourceMapper.names.push(name);
+                    }
+                }
+                this.sourceMapper.currentNameIndex.push(nameIndex);
+            }
+        };
+
+        Emitter.prototype.recordSourceMappingNameEnd = function () {
+            if (this.sourceMapper) {
+                this.sourceMapper.currentNameIndex.pop();
+            }
+        };
+
+        Emitter.prototype.recordSourceMappingStart = function (ast) {
+            if (this.sourceMapper && TypeScript.ASTHelpers.isValidAstNode(ast)) {
+                var lineCol = { line: -1, character: -1 };
+                var sourceMapping = new TypeScript.SourceMapping();
+                sourceMapping.start.emittedColumn = this.emitState.column;
+                sourceMapping.start.emittedLine = this.emitState.line;
+
+                var lineMap = this.document.lineMap();
+                lineMap.fillLineAndCharacterFromPosition(ast.start(), lineCol);
+                sourceMapping.start.sourceColumn = lineCol.character;
+                sourceMapping.start.sourceLine = lineCol.line + 1;
+                lineMap.fillLineAndCharacterFromPosition(ast.end(), lineCol);
+                sourceMapping.end.sourceColumn = lineCol.character;
+                sourceMapping.end.sourceLine = lineCol.line + 1;
+
+                TypeScript.Debug.assert(!isNaN(sourceMapping.start.emittedColumn));
+                TypeScript.Debug.assert(!isNaN(sourceMapping.start.emittedLine));
+                TypeScript.Debug.assert(!isNaN(sourceMapping.start.sourceColumn));
+                TypeScript.Debug.assert(!isNaN(sourceMapping.start.sourceLine));
+                TypeScript.Debug.assert(!isNaN(sourceMapping.end.sourceColumn));
+                TypeScript.Debug.assert(!isNaN(sourceMapping.end.sourceLine));
+
+                if (this.sourceMapper.currentNameIndex.length > 0) {
+                    sourceMapping.nameIndex = this.sourceMapper.currentNameIndex[this.sourceMapper.currentNameIndex.length - 1];
+                }
+
+                var siblings = this.sourceMapper.currentMappings[this.sourceMapper.currentMappings.length - 1];
+                siblings.push(sourceMapping);
+                this.sourceMapper.currentMappings.push(sourceMapping.childMappings);
+                this.sourceMapper.increaseMappingLevel(ast);
+            }
+        };
+
+        Emitter.prototype.recordSourceMappingEnd = function (ast) {
+            if (this.sourceMapper && TypeScript.ASTHelpers.isValidAstNode(ast)) {
+                this.sourceMapper.currentMappings.pop();
+
+                var siblings = this.sourceMapper.currentMappings[this.sourceMapper.currentMappings.length - 1];
+                var sourceMapping = siblings[siblings.length - 1];
+
+                sourceMapping.end.emittedColumn = this.emitState.column;
+                sourceMapping.end.emittedLine = this.emitState.line;
+
+                TypeScript.Debug.assert(!isNaN(sourceMapping.end.emittedColumn));
+                TypeScript.Debug.assert(!isNaN(sourceMapping.end.emittedLine));
+
+                this.sourceMapper.decreaseMappingLevel(ast);
+            }
+        };
+
+        Emitter.prototype.getOutputFiles = function () {
+            var result = [];
+            if (this.sourceMapper !== null) {
+                this.sourceMapper.emitSourceMapping();
+                result.push(this.sourceMapper.getOutputFile());
+            }
+
+            result.push(this.outfile.getOutputFile());
+            return result;
+        };
+
+        Emitter.prototype.emitParameterPropertyAndMemberVariableAssignments = function () {
+            var constructorDecl = getLastConstructor(this.thisClassNode);
+
+            if (constructorDecl) {
+                for (var i = 0, n = constructorDecl.callSignature.parameterList.parameters.nonSeparatorCount(); i < n; i++) {
+                    var parameter = constructorDecl.callSignature.parameterList.parameters.nonSeparatorAt(i);
+                    var parameterDecl = this.semanticInfoChain.getDeclForAST(parameter);
+                    if (TypeScript.hasFlag(parameterDecl.flags, 8388608 /* PropertyParameter */)) {
+                        this.emitIndent();
+                        this.recordSourceMappingStart(parameter);
+                        this.writeToOutputWithSourceMapRecord("this." + parameter.identifier.text(), parameter.identifier);
+                        this.writeToOutput(" = ");
+                        this.writeToOutputWithSourceMapRecord(parameter.identifier.text(), parameter.identifier);
+                        this.writeLineToOutput(";");
+                        this.recordSourceMappingEnd(parameter);
+                    }
+                }
+            }
+
+            for (var i = 0, n = this.thisClassNode.classElements.childCount(); i < n; i++) {
+                if (this.thisClassNode.classElements.childAt(i).kind() === 136 /* MemberVariableDeclaration */) {
+                    var varDecl = this.thisClassNode.classElements.childAt(i);
+                    if (!TypeScript.hasModifier(varDecl.modifiers, 16 /* Static */) && varDecl.variableDeclarator.equalsValueClause) {
+                        this.emitIndent();
+                        this.emitMemberVariableDeclaration(varDecl);
+                        this.writeLineToOutput("");
+                    }
+                }
+            }
+        };
+
+        Emitter.prototype.isOnSameLine = function (pos1, pos2) {
+            var lineMap = this.document.lineMap();
+            return lineMap.getLineNumberFromPosition(pos1) === lineMap.getLineNumberFromPosition(pos2);
+        };
+
+        Emitter.prototype.emitCommaSeparatedList = function (parent, list, buffer, preserveNewLines) {
+            if (list === null || list.nonSeparatorCount() === 0) {
+                return;
+            }
+
+            var startLine = preserveNewLines && !this.isOnSameLine(parent.end(), list.nonSeparatorAt(0).end());
+
+            if (preserveNewLines) {
+                this.indenter.increaseIndent();
+            }
+
+            if (startLine) {
+                this.writeLineToOutput("");
+            } else {
+                this.writeToOutput(buffer);
+            }
+
+            for (var i = 0, n = list.nonSeparatorCount(); i < n; i++) {
+                var emitNode = list.nonSeparatorAt(i);
+
+                this.emitJavascript(emitNode, startLine);
+
+                if (i < (n - 1)) {
+                    startLine = preserveNewLines && !this.isOnSameLine(emitNode.end(), list.nonSeparatorAt(i + 1).start());
+                    if (startLine) {
+                        this.writeLineToOutput(",");
+                    } else {
+                        this.writeToOutput(", ");
+                    }
+                }
+            }
+
+            if (preserveNewLines) {
+                this.indenter.decreaseIndent();
+            }
+
+            if (preserveNewLines && !this.isOnSameLine(parent.end(), list.nonSeparatorAt(list.nonSeparatorCount() - 1).end())) {
+                this.writeLineToOutput("");
+                this.emitIndent();
+            } else {
+                this.writeToOutput(buffer);
+            }
+        };
+
+        Emitter.prototype.emitList = function (list, useNewLineSeparator, startInclusive, endExclusive) {
+            if (typeof useNewLineSeparator === "undefined") { useNewLineSeparator = true; }
+            if (typeof startInclusive === "undefined") { startInclusive = 0; }
+            if (typeof endExclusive === "undefined") { endExclusive = list.childCount(); }
+            if (list === null) {
+                return;
+            }
+
+            this.emitComments(list, true);
+            var lastEmittedNode = null;
+
+            for (var i = startInclusive; i < endExclusive; i++) {
+                var node = list.childAt(i);
+
+                if (this.shouldEmit(node)) {
+                    this.emitSpaceBetweenConstructs(lastEmittedNode, node);
+
+                    this.emitJavascript(node, true);
+                    if (useNewLineSeparator) {
+                        this.writeLineToOutput("");
+                    }
+
+                    lastEmittedNode = node;
+                }
+            }
+
+            this.emitComments(list, false);
+        };
+
+        Emitter.prototype.emitSeparatedList = function (list, useNewLineSeparator, startInclusive, endExclusive) {
+            if (typeof useNewLineSeparator === "undefined") { useNewLineSeparator = true; }
+            if (typeof startInclusive === "undefined") { startInclusive = 0; }
+            if (typeof endExclusive === "undefined") { endExclusive = list.nonSeparatorCount(); }
+            if (list === null) {
+                return;
+            }
+
+            this.emitComments(list, true);
+            var lastEmittedNode = null;
+
+            for (var i = startInclusive; i < endExclusive; i++) {
+                var node = list.nonSeparatorAt(i);
+
+                if (this.shouldEmit(node)) {
+                    this.emitSpaceBetweenConstructs(lastEmittedNode, node);
+
+                    this.emitJavascript(node, true);
+                    if (useNewLineSeparator) {
+                        this.writeLineToOutput("");
+                    }
+
+                    lastEmittedNode = node;
+                }
+            }
+
+            this.emitComments(list, false);
+        };
+
+        Emitter.prototype.isDirectivePrologueElement = function (node) {
+            if (node.kind() === 149 /* ExpressionStatement */) {
+                var exprStatement = node;
+                return exprStatement.expression.kind() === 14 /* StringLiteral */;
+            }
+
+            return false;
+        };
+
+        Emitter.prototype.emitSpaceBetweenConstructs = function (node1, node2) {
+            if (node1 === null || node2 === null) {
+                return;
+            }
+
+            if (node1.start() === -1 || node1.end() === -1 || node2.start() === -1 || node2.end() === -1) {
+                return;
+            }
+
+            var lineMap = this.document.lineMap();
+            var node1EndLine = lineMap.getLineNumberFromPosition(node1.end());
+            var node2StartLine = lineMap.getLineNumberFromPosition(node2.start());
+
+            if ((node2StartLine - node1EndLine) > 1) {
+                this.writeLineToOutput("", true);
+            }
+        };
+
+        Emitter.prototype.getDetachedComments = function (element) {
+            var preComments = element.preComments();
+            if (preComments) {
+                var lineMap = this.document.lineMap();
+
+                var detachedComments = [];
+                var lastComment = null;
+
+                for (var i = 0, n = preComments.length; i < n; i++) {
+                    var comment = preComments[i];
+
+                    if (lastComment) {
+                        var lastCommentLine = lineMap.getLineNumberFromPosition(lastComment.end());
+                        var commentLine = lineMap.getLineNumberFromPosition(comment.start());
+
+                        if (commentLine >= lastCommentLine + 2) {
+                            return detachedComments;
+                        }
+                    }
+
+                    detachedComments.push(comment);
+                    lastComment = comment;
+                }
+
+                var lastCommentLine = lineMap.getLineNumberFromPosition(TypeScript.ArrayUtilities.last(detachedComments).end());
+                var astLine = lineMap.getLineNumberFromPosition(element.start());
+                if (astLine >= lastCommentLine + 2) {
+                    return detachedComments;
+                }
+            }
+
+            return [];
+        };
+
+        Emitter.prototype.emitPossibleCopyrightHeaders = function (script) {
+            this.emitDetachedComments(script.moduleElements);
+        };
+
+        Emitter.prototype.emitDetachedComments = function (list) {
+            if (list.childCount() > 0) {
+                var firstElement = list.childAt(0);
+
+                this.detachedCommentsElement = firstElement;
+                this.emitCommentsArray(this.getDetachedComments(this.detachedCommentsElement), false);
+            }
+        };
+
+        Emitter.prototype.emitScriptElements = function (sourceUnit) {
+            var list = sourceUnit.moduleElements;
+
+            this.emitPossibleCopyrightHeaders(sourceUnit);
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var node = list.childAt(i);
+
+                if (!this.isDirectivePrologueElement(node)) {
+                    break;
+                }
+
+                this.emitJavascript(node, true);
+                this.writeLineToOutput("");
+            }
+
+            this.emitPrologue(sourceUnit);
+
+            var isExternalModule = this.document.isExternalModule();
+            var isNonElidedExternalModule = isExternalModule && !TypeScript.ASTHelpers.scriptIsElided(sourceUnit);
+            if (isNonElidedExternalModule) {
+                this.recordSourceMappingStart(sourceUnit);
+
+                if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) {
+                    var dependencyList = "[\"require\", \"exports\"";
+                    var importList = "require, exports";
+
+                    var importAndDependencyList = this.getModuleImportAndDependencyList(sourceUnit);
+                    importList += importAndDependencyList.importList;
+                    dependencyList += importAndDependencyList.dependencyList + "]";
+
+                    this.writeLineToOutput("define(" + dependencyList + "," + " function(" + importList + ") {");
+                }
+            }
+
+            if (isExternalModule) {
+                var temp = this.setContainer(2 /* DynamicModule */);
+
+                var svModuleName = this.moduleName;
+                this.moduleName = sourceUnit.fileName();
+                if (TypeScript.isTSFile(this.moduleName)) {
+                    this.moduleName = this.moduleName.substring(0, this.moduleName.length - ".ts".length);
+                }
+
+                this.setExportAssignment(null);
+
+                if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) {
+                    this.indenter.increaseIndent();
+                }
+
+                var externalModule = this.semanticInfoChain.getDeclForAST(this.document.sourceUnit());
+
+                if (TypeScript.hasFlag(externalModule.flags, 262144 /* MustCaptureThis */)) {
+                    this.writeCaptureThisStatement(sourceUnit);
+                }
+
+                this.pushDecl(externalModule);
+            }
+
+            this.emitList(list, true, i, n);
+
+            if (isExternalModule) {
+                if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) {
+                    this.indenter.decreaseIndent();
+                }
+
+                if (isNonElidedExternalModule) {
+                    var exportAssignment = this.getExportAssignment();
+                    var exportAssignmentIdentifierText = exportAssignment ? exportAssignment.identifier.text() : null;
+                    var exportAssignmentValueSymbol = externalModule.getSymbol().getExportAssignedValueSymbol();
+
+                    if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) {
+                        if (exportAssignmentIdentifierText && exportAssignmentValueSymbol && !(exportAssignmentValueSymbol.kind & 58720272 /* SomeTypeReference */)) {
+                            this.indenter.increaseIndent();
+                            this.emitIndent();
+                            this.writeToOutputWithSourceMapRecord("return " + exportAssignmentIdentifierText, exportAssignment);
+                            this.writeLineToOutput(";");
+                            this.indenter.decreaseIndent();
+                        }
+                        this.writeToOutput("});");
+                    } else if (exportAssignmentIdentifierText && exportAssignmentValueSymbol && !(exportAssignmentValueSymbol.kind & 58720272 /* SomeTypeReference */)) {
+                        this.emitIndent();
+                        this.writeToOutputWithSourceMapRecord("module.exports = " + exportAssignmentIdentifierText, exportAssignment);
+                        this.writeToOutput(";");
+                    }
+
+                    this.recordSourceMappingEnd(sourceUnit);
+                    this.writeLineToOutput("");
+                }
+
+                this.setContainer(temp);
+                this.moduleName = svModuleName;
+                this.popDecl(externalModule);
+            }
+        };
+
+        Emitter.prototype.emitConstructorStatements = function (funcDecl) {
+            var list = funcDecl.block.statements;
+
+            if (list === null) {
+                return;
+            }
+
+            this.emitComments(list, true);
+
+            var emitPropertyAssignmentsAfterSuperCall = TypeScript.ASTHelpers.getExtendsHeritageClause(this.thisClassNode.heritageClauses) !== null;
+            var propertyAssignmentIndex = emitPropertyAssignmentsAfterSuperCall ? 1 : 0;
+            var lastEmittedNode = null;
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                if (i === propertyAssignmentIndex) {
+                    this.emitParameterPropertyAndMemberVariableAssignments();
+                }
+
+                var node = list.childAt(i);
+
+                if (this.shouldEmit(node)) {
+                    this.emitSpaceBetweenConstructs(lastEmittedNode, node);
+
+                    this.emitJavascript(node, true);
+                    this.writeLineToOutput("");
+
+                    lastEmittedNode = node;
+                }
+            }
+
+            if (i === propertyAssignmentIndex) {
+                this.emitParameterPropertyAndMemberVariableAssignments();
+            }
+
+            this.emitComments(list, false);
+        };
+
+        Emitter.prototype.emitJavascript = function (ast, startLine) {
+            if (ast === null) {
+                return;
+            }
+
+            if (startLine && this.indenter.indentAmt > 0) {
+                this.emitIndent();
+            }
+
+            this.emit(ast);
+        };
+
+        Emitter.prototype.emitAccessorMemberDeclaration = function (funcDecl, name, className, isProto) {
+            if (funcDecl.kind() !== 139 /* GetAccessor */) {
+                var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(funcDecl, this.semanticInfoChain);
+                if (accessorSymbol.getGetter()) {
+                    return;
+                }
+            }
+
+            this.emitIndent();
+            this.recordSourceMappingStart(funcDecl);
+
+            this.writeToOutput("Object.defineProperty(" + className);
+            if (isProto) {
+                this.writeToOutput(".prototype, ");
+            } else {
+                this.writeToOutput(", ");
+            }
+
+            var functionName = name.text();
+            if (TypeScript.isQuoted(functionName)) {
+                this.writeToOutput(functionName);
+            } else {
+                this.writeToOutput('"' + functionName + '"');
+            }
+
+            this.writeLineToOutput(", {");
+
+            this.indenter.increaseIndent();
+
+            var accessors = TypeScript.PullHelpers.getGetterAndSetterFunction(funcDecl, this.semanticInfoChain);
+            if (accessors.getter) {
+                this.emitIndent();
+                this.recordSourceMappingStart(accessors.getter);
+                this.emitComments(accessors.getter, true);
+                this.writeToOutput("get: ");
+                this.emitAccessorBody(accessors.getter, accessors.getter.parameterList, accessors.getter.block);
+                this.writeLineToOutput(",");
+            }
+
+            if (accessors.setter) {
+                this.emitIndent();
+                this.recordSourceMappingStart(accessors.setter);
+                this.emitComments(accessors.setter, true);
+                this.writeToOutput("set: ");
+                this.emitAccessorBody(accessors.setter, accessors.setter.parameterList, accessors.setter.block);
+                this.writeLineToOutput(",");
+            }
+
+            this.emitIndent();
+            this.writeLineToOutput("enumerable: true,");
+            this.emitIndent();
+            this.writeLineToOutput("configurable: true");
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+            this.writeLineToOutput("});");
+            this.recordSourceMappingEnd(funcDecl);
+        };
+
+        Emitter.prototype.emitAccessorBody = function (funcDecl, parameterList, block) {
+            var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            this.pushDecl(pullDecl);
+
+            this.recordSourceMappingStart(funcDecl);
+            this.writeToOutput("function ");
+
+            this.writeToOutput("(");
+
+            var parameters = TypeScript.ASTHelpers.parametersFromParameterList(parameterList);
+            this.emitFunctionParameters(parameters);
+            this.writeToOutput(")");
+
+            this.emitFunctionBodyStatements(null, funcDecl, parameters, block, null);
+
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.recordSourceMappingEnd(funcDecl);
+            this.popDecl(pullDecl);
+        };
+
+        Emitter.prototype.emitClass = function (classDecl) {
+            var pullDecl = this.semanticInfoChain.getDeclForAST(classDecl);
+            this.pushDecl(pullDecl);
+
+            var svClassNode = this.thisClassNode;
+            this.thisClassNode = classDecl;
+            var className = classDecl.identifier.text();
+            this.emitComments(classDecl, true);
+            var temp = this.setContainer(3 /* Class */);
+
+            this.recordSourceMappingStart(classDecl);
+            this.writeToOutput("var " + className);
+
+            var hasBaseClass = TypeScript.ASTHelpers.getExtendsHeritageClause(classDecl.heritageClauses) !== null;
+            var baseTypeReference = null;
+            var varDecl = null;
+
+            if (hasBaseClass) {
+                this.writeLineToOutput(" = (function (_super) {");
+            } else {
+                this.writeLineToOutput(" = (function () {");
+            }
+
+            this.recordSourceMappingNameStart(className);
+            this.indenter.increaseIndent();
+
+            if (hasBaseClass) {
+                baseTypeReference = TypeScript.ASTHelpers.getExtendsHeritageClause(classDecl.heritageClauses).typeNames.nonSeparatorAt(0);
+                this.emitIndent();
+                this.writeToOutputWithSourceMapRecord("__extends(" + className + ", _super)", baseTypeReference);
+                this.writeLineToOutput(";");
+            }
+
+            this.emitIndent();
+
+            var constrDecl = getLastConstructor(classDecl);
+
+            if (constrDecl) {
+                this.emit(constrDecl);
+                this.writeLineToOutput("");
+            } else {
+                this.recordSourceMappingStart(classDecl);
+
+                this.indenter.increaseIndent();
+                this.writeLineToOutput("function " + classDecl.identifier.text() + "() {");
+                this.recordSourceMappingNameStart("constructor");
+                if (hasBaseClass) {
+                    this.emitIndent();
+                    this.writeToOutputWithSourceMapRecord("_super.apply(this, arguments)", baseTypeReference);
+                    this.writeLineToOutput(";");
+                }
+
+                if (this.shouldCaptureThis(classDecl)) {
+                    this.writeCaptureThisStatement(classDecl);
+                }
+
+                this.emitParameterPropertyAndMemberVariableAssignments();
+
+                this.indenter.decreaseIndent();
+                this.emitIndent();
+                this.writeToOutputWithSourceMapRecord("}", classDecl.closeBraceToken);
+                this.writeLineToOutput("");
+
+                this.recordSourceMappingNameEnd();
+                this.recordSourceMappingEnd(classDecl);
+            }
+
+            this.emitClassMembers(classDecl);
+
+            this.emitIndent();
+            this.writeToOutputWithSourceMapRecord("return " + className + ";", classDecl.closeBraceToken);
+            this.writeLineToOutput("");
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+            this.writeToOutputWithSourceMapRecord("}", classDecl.closeBraceToken);
+            this.recordSourceMappingNameEnd();
+            this.recordSourceMappingStart(classDecl);
+            this.writeToOutput(")(");
+            if (hasBaseClass) {
+                this.emitJavascript(baseTypeReference, false);
+            }
+            this.writeToOutput(");");
+            this.recordSourceMappingEnd(classDecl);
+
+            if ((temp === 1 /* Module */ || temp === 2 /* DynamicModule */) && TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */)) {
+                this.writeLineToOutput("");
+                this.emitIndent();
+                var modName = temp === 1 /* Module */ ? this.moduleName : "exports";
+                this.writeToOutputWithSourceMapRecord(modName + "." + className + " = " + className + ";", classDecl);
+            }
+
+            this.recordSourceMappingEnd(classDecl);
+            this.emitComments(classDecl, false);
+            this.setContainer(temp);
+            this.thisClassNode = svClassNode;
+
+            this.popDecl(pullDecl);
+        };
+
+        Emitter.prototype.emitClassMembers = function (classDecl) {
+            var lastEmittedMember = null;
+
+            for (var i = 0, n = classDecl.classElements.childCount(); i < n; i++) {
+                var memberDecl = classDecl.classElements.childAt(i);
+
+                if (memberDecl.kind() === 139 /* GetAccessor */) {
+                    this.emitSpaceBetweenConstructs(lastEmittedMember, memberDecl);
+                    var getter = memberDecl;
+                    this.emitAccessorMemberDeclaration(getter, getter.propertyName, classDecl.identifier.text(), !TypeScript.hasModifier(getter.modifiers, 16 /* Static */));
+                    lastEmittedMember = memberDecl;
+                } else if (memberDecl.kind() === 140 /* SetAccessor */) {
+                    this.emitSpaceBetweenConstructs(lastEmittedMember, memberDecl);
+                    var setter = memberDecl;
+                    this.emitAccessorMemberDeclaration(setter, setter.propertyName, classDecl.identifier.text(), !TypeScript.hasModifier(setter.modifiers, 16 /* Static */));
+                    lastEmittedMember = memberDecl;
+                } else if (memberDecl.kind() === 135 /* MemberFunctionDeclaration */) {
+                    var memberFunction = memberDecl;
+
+                    if (memberFunction.block) {
+                        this.emitSpaceBetweenConstructs(lastEmittedMember, memberDecl);
+
+                        this.emitClassMemberFunctionDeclaration(classDecl, memberFunction);
+                        lastEmittedMember = memberDecl;
+                    }
+                }
+            }
+
+            for (var i = 0, n = classDecl.classElements.childCount(); i < n; i++) {
+                var memberDecl = classDecl.classElements.childAt(i);
+
+                if (memberDecl.kind() === 136 /* MemberVariableDeclaration */) {
+                    var varDecl = memberDecl;
+
+                    if (TypeScript.hasModifier(varDecl.modifiers, 16 /* Static */) && varDecl.variableDeclarator.equalsValueClause) {
+                        this.emitSpaceBetweenConstructs(lastEmittedMember, varDecl);
+
+                        this.emitIndent();
+                        this.recordSourceMappingStart(varDecl);
+
+                        var varDeclName = varDecl.variableDeclarator.propertyName.text();
+                        if (TypeScript.isQuoted(varDeclName) || varDecl.variableDeclarator.propertyName.kind() !== 11 /* IdentifierName */) {
+                            this.writeToOutput(classDecl.identifier.text() + "[" + varDeclName + "]");
+                        } else {
+                            this.writeToOutput(classDecl.identifier.text() + "." + varDeclName);
+                        }
+
+                        this.emit(varDecl.variableDeclarator.equalsValueClause);
+
+                        this.recordSourceMappingEnd(varDecl);
+                        this.writeLineToOutput(";");
+
+                        lastEmittedMember = varDecl;
+                    }
+                }
+            }
+        };
+
+        Emitter.prototype.emitClassMemberFunctionDeclaration = function (classDecl, funcDecl) {
+            this.emitIndent();
+            this.recordSourceMappingStart(funcDecl);
+            this.emitComments(funcDecl, true);
+            var functionName = funcDecl.propertyName.text();
+
+            this.writeToOutput(classDecl.identifier.text());
+
+            if (!TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */)) {
+                this.writeToOutput(".prototype");
+            }
+
+            if (TypeScript.isQuoted(functionName) || funcDecl.propertyName.kind() !== 11 /* IdentifierName */) {
+                this.writeToOutput("[" + functionName + "] = ");
+            } else {
+                this.writeToOutput("." + functionName + " = ");
+            }
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            this.pushDecl(pullDecl);
+
+            this.recordSourceMappingStart(funcDecl);
+            this.writeToOutput("function ");
+
+            this.emitParameterList(funcDecl.callSignature.parameterList);
+
+            var parameters = TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList);
+            this.emitFunctionBodyStatements(funcDecl.propertyName.text(), funcDecl, parameters, funcDecl.block, null);
+
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.emitComments(funcDecl, false);
+
+            this.recordSourceMappingEnd(funcDecl);
+            this.popDecl(pullDecl);
+
+            this.writeLineToOutput(";");
+        };
+
+        Emitter.prototype.requiresExtendsBlock = function (moduleElements) {
+            for (var i = 0, n = moduleElements.childCount(); i < n; i++) {
+                var moduleElement = moduleElements.childAt(i);
+
+                if (moduleElement.kind() === 130 /* ModuleDeclaration */) {
+                    var moduleAST = moduleElement;
+
+                    if (!TypeScript.hasModifier(moduleAST.modifiers, 8 /* Ambient */) && this.requiresExtendsBlock(moduleAST.moduleElements)) {
+                        return true;
+                    }
+                } else if (moduleElement.kind() === 131 /* ClassDeclaration */) {
+                    var classDeclaration = moduleElement;
+
+                    if (!TypeScript.hasModifier(classDeclaration.modifiers, 8 /* Ambient */) && TypeScript.ASTHelpers.getExtendsHeritageClause(classDeclaration.heritageClauses) !== null) {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        Emitter.prototype.emitPrologue = function (sourceUnit) {
+            if (!this.extendsPrologueEmitted) {
+                if (this.requiresExtendsBlock(sourceUnit.moduleElements)) {
+                    this.extendsPrologueEmitted = true;
+                    this.writeLineToOutput("var __extends = this.__extends || function (d, b) {");
+                    this.writeLineToOutput("    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];");
+                    this.writeLineToOutput("    function __() { this.constructor = d; }");
+                    this.writeLineToOutput("    __.prototype = b.prototype;");
+                    this.writeLineToOutput("    d.prototype = new __();");
+                    this.writeLineToOutput("};");
+                }
+            }
+
+            if (!this.globalThisCapturePrologueEmitted) {
+                if (this.shouldCaptureThis(sourceUnit)) {
+                    this.globalThisCapturePrologueEmitted = true;
+                    this.writeLineToOutput(this.captureThisStmtString);
+                }
+            }
+        };
+
+        Emitter.prototype.emitThis = function () {
+            if (!this.inWithBlock && this.inArrowFunction) {
+                this.writeToOutput("_this");
+            } else {
+                this.writeToOutput("this");
+            }
+        };
+
+        Emitter.prototype.emitBlockOrStatement = function (node) {
+            if (node.kind() === 146 /* Block */) {
+                this.emit(node);
+            } else {
+                this.writeLineToOutput("");
+                this.indenter.increaseIndent();
+                this.emitJavascript(node, true);
+                this.indenter.decreaseIndent();
+            }
+        };
+
+        Emitter.prototype.emitLiteralExpression = function (expression) {
+            switch (expression.kind()) {
+                case 32 /* NullKeyword */:
+                    this.writeToOutputWithSourceMapRecord("null", expression);
+                    break;
+                case 24 /* FalseKeyword */:
+                    this.writeToOutputWithSourceMapRecord("false", expression);
+                    break;
+                case 37 /* TrueKeyword */:
+                    this.writeToOutputWithSourceMapRecord("true", expression);
+                    break;
+                default:
+                    throw TypeScript.Errors.abstract();
+            }
+        };
+
+        Emitter.prototype.emitThisExpression = function (expression) {
+            if (!this.inWithBlock && this.inArrowFunction) {
+                this.writeToOutputWithSourceMapRecord("_this", expression);
+            } else {
+                this.writeToOutputWithSourceMapRecord("this", expression);
+            }
+        };
+
+        Emitter.prototype.emitSuperExpression = function (expression) {
+            this.writeToOutputWithSourceMapRecord("_super.prototype", expression);
+        };
+
+        Emitter.prototype.emitParenthesizedExpression = function (parenthesizedExpression) {
+            if (parenthesizedExpression.expression.kind() === 220 /* CastExpression */ && parenthesizedExpression.openParenTrailingComments === null) {
+                this.emit(parenthesizedExpression.expression);
+            } else {
+                this.recordSourceMappingStart(parenthesizedExpression);
+                this.writeToOutput("(");
+                this.emitCommentsArray(parenthesizedExpression.openParenTrailingComments, false);
+                this.emit(parenthesizedExpression.expression);
+                this.writeToOutput(")");
+                this.recordSourceMappingEnd(parenthesizedExpression);
+            }
+        };
+
+        Emitter.prototype.emitCastExpression = function (expression) {
+            this.emit(expression.expression);
+        };
+
+        Emitter.prototype.emitPrefixUnaryExpression = function (expression) {
+            var nodeType = expression.kind();
+
+            this.recordSourceMappingStart(expression);
+            switch (nodeType) {
+                case 167 /* LogicalNotExpression */:
+                    this.writeToOutput("!");
+                    this.emit(expression.operand);
+                    break;
+                case 166 /* BitwiseNotExpression */:
+                    this.writeToOutput("~");
+                    this.emit(expression.operand);
+                    break;
+                case 165 /* NegateExpression */:
+                    this.writeToOutput("-");
+                    if (expression.operand.kind() === 165 /* NegateExpression */ || expression.operand.kind() === 169 /* PreDecrementExpression */) {
+                        this.writeToOutput(" ");
+                    }
+                    this.emit(expression.operand);
+                    break;
+                case 164 /* PlusExpression */:
+                    this.writeToOutput("+");
+                    if (expression.operand.kind() === 164 /* PlusExpression */ || expression.operand.kind() === 168 /* PreIncrementExpression */) {
+                        this.writeToOutput(" ");
+                    }
+                    this.emit(expression.operand);
+                    break;
+                case 168 /* PreIncrementExpression */:
+                    this.writeToOutput("++");
+                    this.emit(expression.operand);
+                    break;
+                case 169 /* PreDecrementExpression */:
+                    this.writeToOutput("--");
+                    this.emit(expression.operand);
+                    break;
+                default:
+                    throw TypeScript.Errors.abstract();
+            }
+
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.emitPostfixUnaryExpression = function (expression) {
+            var nodeType = expression.kind();
+
+            this.recordSourceMappingStart(expression);
+            switch (nodeType) {
+                case 210 /* PostIncrementExpression */:
+                    this.emit(expression.operand);
+                    this.writeToOutput("++");
+                    break;
+                case 211 /* PostDecrementExpression */:
+                    this.emit(expression.operand);
+                    this.writeToOutput("--");
+                    break;
+                default:
+                    throw TypeScript.Errors.abstract();
+            }
+
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.emitTypeOfExpression = function (expression) {
+            this.recordSourceMappingStart(expression);
+            this.writeToOutput("typeof ");
+            this.emit(expression.expression);
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.emitDeleteExpression = function (expression) {
+            this.recordSourceMappingStart(expression);
+            this.writeToOutput("delete ");
+            this.emit(expression.expression);
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.emitVoidExpression = function (expression) {
+            this.recordSourceMappingStart(expression);
+            this.writeToOutput("void ");
+            this.emit(expression.expression);
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.canEmitDottedNameMemberAccessExpression = function (expression) {
+            var memberExpressionNodeType = expression.expression.kind();
+
+            if (memberExpressionNodeType === 11 /* IdentifierName */ || memberExpressionNodeType == 212 /* MemberAccessExpression */) {
+                var memberAccessSymbol = this.getSymbolForEmit(expression).symbol;
+                var memberAccessExpressionSymbol = this.getSymbolForEmit(expression.expression).symbol;
+                if (memberAccessSymbol && memberAccessExpressionSymbol && !this.semanticInfoChain.getAliasSymbolForAST(expression.expression) && (TypeScript.PullHelpers.symbolIsModule(memberAccessExpressionSymbol) || memberAccessExpressionSymbol.kind === 64 /* Enum */ || memberAccessExpressionSymbol.anyDeclHasFlag(32768 /* InitializedModule */ | 4096 /* Enum */))) {
+                    var memberAccessSymbolKind = memberAccessSymbol.kind;
+                    if (memberAccessSymbolKind === 4096 /* Property */ || memberAccessSymbolKind === 67108864 /* EnumMember */ || (memberAccessSymbol.anyDeclHasFlag(1 /* Exported */) && memberAccessSymbolKind === 512 /* Variable */ && !memberAccessSymbol.anyDeclHasFlag(32768 /* InitializedModule */ | 4096 /* Enum */)) || ((memberAccessSymbol.anyDeclHasFlag(1 /* Exported */) && !this.symbolIsUsedInItsEnclosingContainer(memberAccessSymbol)))) {
+                        if (memberExpressionNodeType === 212 /* MemberAccessExpression */) {
+                            return this.canEmitDottedNameMemberAccessExpression(expression.expression);
+                        }
+
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        Emitter.prototype.emitDottedNameMemberAccessExpression = function (expression) {
+            this.recordSourceMappingStart(expression);
+            if (expression.expression.kind() === 212 /* MemberAccessExpression */) {
+                this.emitDottedNameMemberAccessExpressionRecurse(expression.expression);
+            } else {
+                this.emitName(expression.expression, true);
+            }
+
+            this.writeToOutput(".");
+            this.emitName(expression.name, false);
+
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.emitDottedNameMemberAccessExpressionRecurse = function (expression) {
+            this.emitComments(expression, true);
+            this.emitDottedNameMemberAccessExpression(expression);
+            this.emitComments(expression, false);
+        };
+
+        Emitter.prototype.emitMemberAccessExpression = function (expression) {
+            if (!this.tryEmitConstant(expression)) {
+                if (this.canEmitDottedNameMemberAccessExpression(expression)) {
+                    this.emitDottedNameMemberAccessExpression(expression);
+                } else {
+                    this.recordSourceMappingStart(expression);
+                    this.emit(expression.expression);
+                    this.writeToOutput(".");
+                    this.emitName(expression.name, false);
+                    this.recordSourceMappingEnd(expression);
+                }
+            }
+        };
+
+        Emitter.prototype.emitQualifiedName = function (name) {
+            this.recordSourceMappingStart(name);
+
+            this.emit(name.left);
+            this.writeToOutput(".");
+            this.emitName(name.right, false);
+
+            this.recordSourceMappingEnd(name);
+        };
+
+        Emitter.prototype.emitBinaryExpression = function (expression) {
+            this.recordSourceMappingStart(expression);
+            switch (expression.kind()) {
+                case 173 /* CommaExpression */:
+                    this.emit(expression.left);
+                    this.writeToOutput(", ");
+                    this.emit(expression.right);
+                    break;
+                default: {
+                    this.emit(expression.left);
+                    var binOp = TypeScript.SyntaxFacts.getText(TypeScript.SyntaxFacts.getOperatorTokenFromBinaryExpression(expression.kind()));
+                    if (binOp === "instanceof") {
+                        this.writeToOutput(" instanceof ");
+                    } else if (binOp === "in") {
+                        this.writeToOutput(" in ");
+                    } else {
+                        this.writeToOutput(" " + binOp + " ");
+                    }
+                    this.emit(expression.right);
+                }
+            }
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.emitSimplePropertyAssignment = function (property) {
+            this.recordSourceMappingStart(property);
+            this.emit(property.propertyName);
+            this.writeToOutput(": ");
+            this.emit(property.expression);
+            this.recordSourceMappingEnd(property);
+        };
+
+        Emitter.prototype.emitFunctionPropertyAssignment = function (funcProp) {
+            this.recordSourceMappingStart(funcProp);
+
+            this.emit(funcProp.propertyName);
+            this.writeToOutput(": ");
+
+            var pullFunctionDecl = this.semanticInfoChain.getDeclForAST(funcProp);
+
+            var savedInArrowFunction = this.inArrowFunction;
+            this.inArrowFunction = false;
+
+            var temp = this.setContainer(5 /* Function */);
+            var funcName = funcProp.propertyName;
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(funcProp);
+            this.pushDecl(pullDecl);
+
+            this.recordSourceMappingStart(funcProp);
+            this.writeToOutput("function ");
+
+            this.writeToOutput("(");
+
+            var parameters = TypeScript.ASTHelpers.parametersFromParameterList(funcProp.callSignature.parameterList);
+            this.emitFunctionParameters(parameters);
+            this.writeToOutput(")");
+
+            this.emitFunctionBodyStatements(funcProp.propertyName.text(), funcProp, parameters, funcProp.block, null);
+
+            this.recordSourceMappingEnd(funcProp);
+
+            this.recordSourceMappingEnd(funcProp);
+
+            this.emitComments(funcProp, false);
+
+            this.popDecl(pullDecl);
+
+            this.setContainer(temp);
+            this.inArrowFunction = savedInArrowFunction;
+        };
+
+        Emitter.prototype.emitConditionalExpression = function (expression) {
+            this.emit(expression.condition);
+            this.writeToOutput(" ? ");
+            this.emit(expression.whenTrue);
+            this.writeToOutput(" : ");
+            this.emit(expression.whenFalse);
+        };
+
+        Emitter.prototype.emitThrowStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("throw ");
+            this.emit(statement.expression);
+            this.recordSourceMappingEnd(statement);
+            this.writeToOutput(";");
+        };
+
+        Emitter.prototype.emitExpressionStatement = function (statement) {
+            var isArrowExpression = statement.expression.kind() === 219 /* SimpleArrowFunctionExpression */ || statement.expression.kind() === 218 /* ParenthesizedArrowFunctionExpression */;
+
+            this.recordSourceMappingStart(statement);
+            if (isArrowExpression) {
+                this.writeToOutput("(");
+            }
+
+            this.emit(statement.expression);
+
+            if (isArrowExpression) {
+                this.writeToOutput(")");
+            }
+
+            this.recordSourceMappingEnd(statement);
+            this.writeToOutput(";");
+        };
+
+        Emitter.prototype.emitLabeledStatement = function (statement) {
+            this.writeToOutputWithSourceMapRecord(statement.identifier.text(), statement.identifier);
+            this.writeLineToOutput(":");
+            this.emitJavascript(statement.statement, true);
+        };
+
+        Emitter.prototype.emitBlock = function (block) {
+            this.recordSourceMappingStart(block);
+            this.writeLineToOutput(" {");
+            this.indenter.increaseIndent();
+            if (block.statements) {
+                this.emitList(block.statements);
+            }
+            this.emitCommentsArray(block.closeBraceLeadingComments, false);
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+            this.writeToOutput("}");
+            this.recordSourceMappingEnd(block);
+        };
+
+        Emitter.prototype.emitBreakStatement = function (jump) {
+            this.recordSourceMappingStart(jump);
+            this.writeToOutput("break");
+
+            if (jump.identifier) {
+                this.writeToOutput(" " + jump.identifier.text());
+            }
+
+            this.recordSourceMappingEnd(jump);
+            this.writeToOutput(";");
+        };
+
+        Emitter.prototype.emitContinueStatement = function (jump) {
+            this.recordSourceMappingStart(jump);
+            this.writeToOutput("continue");
+
+            if (jump.identifier) {
+                this.writeToOutput(" " + jump.identifier.text());
+            }
+
+            this.recordSourceMappingEnd(jump);
+            this.writeToOutput(";");
+        };
+
+        Emitter.prototype.emitWhileStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("while (");
+            this.emit(statement.condition);
+            this.writeToOutput(")");
+            this.emitBlockOrStatement(statement.statement);
+            this.recordSourceMappingEnd(statement);
+        };
+
+        Emitter.prototype.emitDoStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("do");
+            this.emitBlockOrStatement(statement.statement);
+            this.writeToOutputWithSourceMapRecord(" while", statement.whileKeyword);
+            this.writeToOutput('(');
+            this.emit(statement.condition);
+            this.writeToOutput(")");
+            this.recordSourceMappingEnd(statement);
+            this.writeToOutput(";");
+        };
+
+        Emitter.prototype.emitIfStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("if (");
+            this.emit(statement.condition);
+            this.writeToOutput(")");
+
+            this.emitBlockOrStatement(statement.statement);
+
+            if (statement.elseClause) {
+                if (statement.statement.kind() !== 146 /* Block */) {
+                    this.writeLineToOutput("");
+                    this.emitIndent();
+                } else {
+                    this.writeToOutput(" ");
+                }
+
+                this.emit(statement.elseClause);
+            }
+            this.recordSourceMappingEnd(statement);
+        };
+
+        Emitter.prototype.emitElseClause = function (elseClause) {
+            if (elseClause.statement.kind() === 147 /* IfStatement */) {
+                this.writeToOutput("else ");
+                this.emit(elseClause.statement);
+            } else {
+                this.writeToOutput("else");
+                this.emitBlockOrStatement(elseClause.statement);
+            }
+        };
+
+        Emitter.prototype.emitReturnStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            if (statement.expression) {
+                this.writeToOutput("return ");
+                this.emit(statement.expression);
+            } else {
+                this.writeToOutput("return");
+            }
+            this.recordSourceMappingEnd(statement);
+            this.writeToOutput(";");
+        };
+
+        Emitter.prototype.emitForInStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("for (");
+            if (statement.left) {
+                this.emit(statement.left);
+            } else {
+                this.emit(statement.variableDeclaration);
+            }
+            this.writeToOutput(" in ");
+            this.emit(statement.expression);
+            this.writeToOutput(")");
+            this.emitBlockOrStatement(statement.statement);
+            this.recordSourceMappingEnd(statement);
+        };
+
+        Emitter.prototype.emitForStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("for (");
+            if (statement.variableDeclaration) {
+                this.emit(statement.variableDeclaration);
+            } else if (statement.initializer) {
+                this.emit(statement.initializer);
+            }
+
+            this.writeToOutput("; ");
+            this.emitJavascript(statement.condition, false);
+            this.writeToOutput(";");
+            if (statement.incrementor) {
+                this.writeToOutput(" ");
+                this.emitJavascript(statement.incrementor, false);
+            }
+            this.writeToOutput(")");
+            this.emitBlockOrStatement(statement.statement);
+            this.recordSourceMappingEnd(statement);
+        };
+
+        Emitter.prototype.emitWithStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("with (");
+            if (statement.condition) {
+                this.emit(statement.condition);
+            }
+
+            this.writeToOutput(")");
+            var prevInWithBlock = this.inWithBlock;
+            this.inWithBlock = true;
+            this.emitBlockOrStatement(statement.statement);
+            this.inWithBlock = prevInWithBlock;
+            this.recordSourceMappingEnd(statement);
+        };
+
+        Emitter.prototype.emitSwitchStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("switch (");
+            this.emit(statement.expression);
+            this.recordSourceMappingStart(statement.closeParenToken);
+            this.writeToOutput(")");
+            this.recordSourceMappingEnd(statement.closeParenToken);
+            this.writeLineToOutput(" {");
+            this.indenter.increaseIndent();
+            this.emitList(statement.switchClauses, false);
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+            this.writeToOutput("}");
+            this.recordSourceMappingEnd(statement);
+        };
+
+        Emitter.prototype.emitCaseSwitchClause = function (clause) {
+            this.recordSourceMappingStart(clause);
+            this.writeToOutput("case ");
+            this.emit(clause.expression);
+            this.writeToOutput(":");
+
+            this.emitSwitchClauseBody(clause.statements);
+            this.recordSourceMappingEnd(clause);
+        };
+
+        Emitter.prototype.emitSwitchClauseBody = function (body) {
+            if (body.childCount() === 1 && body.childAt(0).kind() === 146 /* Block */) {
+                this.emit(body.childAt(0));
+                this.writeLineToOutput("");
+            } else {
+                this.writeLineToOutput("");
+                this.indenter.increaseIndent();
+                this.emit(body);
+                this.indenter.decreaseIndent();
+            }
+        };
+
+        Emitter.prototype.emitDefaultSwitchClause = function (clause) {
+            this.recordSourceMappingStart(clause);
+            this.writeToOutput("default:");
+
+            this.emitSwitchClauseBody(clause.statements);
+            this.recordSourceMappingEnd(clause);
+        };
+
+        Emitter.prototype.emitTryStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("try ");
+            this.emit(statement.block);
+            this.emitJavascript(statement.catchClause, false);
+
+            if (statement.finallyClause) {
+                this.emit(statement.finallyClause);
+            }
+            this.recordSourceMappingEnd(statement);
+        };
+
+        Emitter.prototype.emitCatchClause = function (clause) {
+            this.writeToOutput(" ");
+            this.recordSourceMappingStart(clause);
+            this.writeToOutput("catch (");
+            this.emit(clause.identifier);
+            this.writeToOutput(")");
+            this.emit(clause.block);
+            this.recordSourceMappingEnd(clause);
+        };
+
+        Emitter.prototype.emitFinallyClause = function (clause) {
+            this.writeToOutput(" finally");
+            this.emit(clause.block);
+        };
+
+        Emitter.prototype.emitDebuggerStatement = function (statement) {
+            this.writeToOutputWithSourceMapRecord("debugger", statement);
+            this.writeToOutput(";");
+        };
+
+        Emitter.prototype.emitNumericLiteral = function (literal) {
+            this.writeToOutputWithSourceMapRecord(literal.text(), literal);
+        };
+
+        Emitter.prototype.emitRegularExpressionLiteral = function (literal) {
+            this.writeToOutputWithSourceMapRecord(literal.text(), literal);
+        };
+
+        Emitter.prototype.emitStringLiteral = function (literal) {
+            this.writeToOutputWithSourceMapRecord(literal.text(), literal);
+        };
+
+        Emitter.prototype.emitEqualsValueClause = function (clause) {
+            this.writeToOutput(" = ");
+            this.emit(clause.value);
+        };
+
+        Emitter.prototype.emitParameter = function (parameter) {
+            this.writeToOutputWithSourceMapRecord(parameter.identifier.text(), parameter);
+        };
+
+        Emitter.prototype.emitConstructorDeclaration = function (declaration) {
+            if (declaration.block) {
+                this.emitConstructor(declaration);
+            } else {
+                this.emitComments(declaration, true, true);
+            }
+        };
+
+        Emitter.prototype.shouldEmitFunctionDeclaration = function (declaration) {
+            return declaration.preComments() !== null || (!TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */) && declaration.block !== null);
+        };
+
+        Emitter.prototype.emitFunctionDeclaration = function (declaration) {
+            if (!TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */) && declaration.block !== null) {
+                this.emitFunction(declaration);
+            } else {
+                this.emitComments(declaration, true, true);
+            }
+        };
+
+        Emitter.prototype.emitSourceUnit = function (sourceUnit) {
+            if (!this.document.isDeclareFile()) {
+                var pullDecl = this.semanticInfoChain.getDeclForAST(sourceUnit);
+                this.pushDecl(pullDecl);
+                this.emitScriptElements(sourceUnit);
+                this.popDecl(pullDecl);
+
+                this.emitCommentsArray(sourceUnit.endOfFileTokenLeadingComments, false);
+            }
+        };
+
+        Emitter.prototype.shouldEmitEnumDeclaration = function (declaration) {
+            return declaration.preComments() !== null || !TypeScript.ASTHelpers.enumIsElided(declaration);
+        };
+
+        Emitter.prototype.emitEnumDeclaration = function (declaration) {
+            if (!TypeScript.ASTHelpers.enumIsElided(declaration)) {
+                this.emitComments(declaration, true);
+                this.emitEnum(declaration);
+                this.emitComments(declaration, false);
+            } else {
+                this.emitComments(declaration, true, true);
+            }
+        };
+
+        Emitter.prototype.shouldEmitModuleDeclaration = function (declaration) {
+            return declaration.preComments() !== null || !TypeScript.ASTHelpers.moduleIsElided(declaration);
+        };
+
+        Emitter.prototype.emitModuleDeclaration = function (declaration) {
+            if (!TypeScript.ASTHelpers.moduleIsElided(declaration)) {
+                this.emitModuleDeclarationWorker(declaration);
+            } else {
+                this.emitComments(declaration, true, true);
+            }
+        };
+
+        Emitter.prototype.shouldEmitClassDeclaration = function (declaration) {
+            return declaration.preComments() !== null || !TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */);
+        };
+
+        Emitter.prototype.emitClassDeclaration = function (declaration) {
+            if (!TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */)) {
+                this.emitClass(declaration);
+            } else {
+                this.emitComments(declaration, true, true);
+            }
+        };
+
+        Emitter.prototype.shouldEmitInterfaceDeclaration = function (declaration) {
+            return declaration.preComments() !== null;
+        };
+
+        Emitter.prototype.emitInterfaceDeclaration = function (declaration) {
+            this.emitComments(declaration, true, true);
+        };
+
+        Emitter.prototype.firstVariableDeclarator = function (statement) {
+            return statement.declaration.declarators.nonSeparatorAt(0);
+        };
+
+        Emitter.prototype.isNotAmbientOrHasInitializer = function (variableStatement) {
+            return !TypeScript.hasModifier(variableStatement.modifiers, 8 /* Ambient */) || this.firstVariableDeclarator(variableStatement).equalsValueClause !== null;
+        };
+
+        Emitter.prototype.shouldEmitVariableStatement = function (statement) {
+            return statement.preComments() !== null || this.isNotAmbientOrHasInitializer(statement);
+        };
+
+        Emitter.prototype.emitVariableStatement = function (statement) {
+            if (this.isNotAmbientOrHasInitializer(statement)) {
+                this.emitComments(statement, true);
+                this.emit(statement.declaration);
+                this.writeToOutput(";");
+                this.emitComments(statement, false);
+            } else {
+                this.emitComments(statement, true, true);
+            }
+        };
+
+        Emitter.prototype.emitGenericType = function (type) {
+            this.emit(type.name);
+        };
+
+        Emitter.prototype.shouldEmit = function (ast) {
+            if (!ast) {
+                return false;
+            }
+
+            switch (ast.kind()) {
+                case 133 /* ImportDeclaration */:
+                    return this.shouldEmitImportDeclaration(ast);
+                case 131 /* ClassDeclaration */:
+                    return this.shouldEmitClassDeclaration(ast);
+                case 128 /* InterfaceDeclaration */:
+                    return this.shouldEmitInterfaceDeclaration(ast);
+                case 129 /* FunctionDeclaration */:
+                    return this.shouldEmitFunctionDeclaration(ast);
+                case 130 /* ModuleDeclaration */:
+                    return this.shouldEmitModuleDeclaration(ast);
+                case 148 /* VariableStatement */:
+                    return this.shouldEmitVariableStatement(ast);
+                case 223 /* OmittedExpression */:
+                    return false;
+                case 132 /* EnumDeclaration */:
+                    return this.shouldEmitEnumDeclaration(ast);
+            }
+
+            return true;
+        };
+
+        Emitter.prototype.emit = function (ast) {
+            if (!ast) {
+                return;
+            }
+
+            switch (ast.kind()) {
+                case 2 /* SeparatedList */:
+                    return this.emitSeparatedList(ast);
+                case 1 /* List */:
+                    return this.emitList(ast);
+                case 120 /* SourceUnit */:
+                    return this.emitSourceUnit(ast);
+                case 133 /* ImportDeclaration */:
+                    return this.emitImportDeclaration(ast);
+                case 134 /* ExportAssignment */:
+                    return this.setExportAssignment(ast);
+                case 131 /* ClassDeclaration */:
+                    return this.emitClassDeclaration(ast);
+                case 128 /* InterfaceDeclaration */:
+                    return this.emitInterfaceDeclaration(ast);
+                case 11 /* IdentifierName */:
+                    return this.emitName(ast, true);
+                case 225 /* VariableDeclarator */:
+                    return this.emitVariableDeclarator(ast);
+                case 219 /* SimpleArrowFunctionExpression */:
+                    return this.emitSimpleArrowFunctionExpression(ast);
+                case 218 /* ParenthesizedArrowFunctionExpression */:
+                    return this.emitParenthesizedArrowFunctionExpression(ast);
+                case 129 /* FunctionDeclaration */:
+                    return this.emitFunctionDeclaration(ast);
+                case 130 /* ModuleDeclaration */:
+                    return this.emitModuleDeclaration(ast);
+                case 224 /* VariableDeclaration */:
+                    return this.emitVariableDeclaration(ast);
+                case 126 /* GenericType */:
+                    return this.emitGenericType(ast);
+                case 137 /* ConstructorDeclaration */:
+                    return this.emitConstructorDeclaration(ast);
+                case 132 /* EnumDeclaration */:
+                    return this.emitEnumDeclaration(ast);
+                case 243 /* EnumElement */:
+                    return this.emitEnumElement(ast);
+                case 222 /* FunctionExpression */:
+                    return this.emitFunctionExpression(ast);
+                case 148 /* VariableStatement */:
+                    return this.emitVariableStatement(ast);
+            }
+
+            this.emitComments(ast, true);
+            this.emitWorker(ast);
+            this.emitComments(ast, false);
+        };
+
+        Emitter.prototype.emitWorker = function (ast) {
+            if (!ast) {
+                return;
+            }
+
+            switch (ast.kind()) {
+                case 13 /* NumericLiteral */:
+                    return this.emitNumericLiteral(ast);
+                case 12 /* RegularExpressionLiteral */:
+                    return this.emitRegularExpressionLiteral(ast);
+                case 14 /* StringLiteral */:
+                    return this.emitStringLiteral(ast);
+                case 24 /* FalseKeyword */:
+                case 32 /* NullKeyword */:
+                case 37 /* TrueKeyword */:
+                    return this.emitLiteralExpression(ast);
+                case 35 /* ThisKeyword */:
+                    return this.emitThisExpression(ast);
+                case 50 /* SuperKeyword */:
+                    return this.emitSuperExpression(ast);
+                case 217 /* ParenthesizedExpression */:
+                    return this.emitParenthesizedExpression(ast);
+                case 214 /* ArrayLiteralExpression */:
+                    return this.emitArrayLiteralExpression(ast);
+                case 211 /* PostDecrementExpression */:
+                case 210 /* PostIncrementExpression */:
+                    return this.emitPostfixUnaryExpression(ast);
+                case 167 /* LogicalNotExpression */:
+                case 166 /* BitwiseNotExpression */:
+                case 165 /* NegateExpression */:
+                case 164 /* PlusExpression */:
+                case 168 /* PreIncrementExpression */:
+                case 169 /* PreDecrementExpression */:
+                    return this.emitPrefixUnaryExpression(ast);
+                case 213 /* InvocationExpression */:
+                    return this.emitInvocationExpression(ast);
+                case 221 /* ElementAccessExpression */:
+                    return this.emitElementAccessExpression(ast);
+                case 212 /* MemberAccessExpression */:
+                    return this.emitMemberAccessExpression(ast);
+                case 121 /* QualifiedName */:
+                    return this.emitQualifiedName(ast);
+                case 173 /* CommaExpression */:
+                case 174 /* AssignmentExpression */:
+                case 175 /* AddAssignmentExpression */:
+                case 176 /* SubtractAssignmentExpression */:
+                case 177 /* MultiplyAssignmentExpression */:
+                case 178 /* DivideAssignmentExpression */:
+                case 179 /* ModuloAssignmentExpression */:
+                case 180 /* AndAssignmentExpression */:
+                case 181 /* ExclusiveOrAssignmentExpression */:
+                case 182 /* OrAssignmentExpression */:
+                case 183 /* LeftShiftAssignmentExpression */:
+                case 184 /* SignedRightShiftAssignmentExpression */:
+                case 185 /* UnsignedRightShiftAssignmentExpression */:
+                case 187 /* LogicalOrExpression */:
+                case 188 /* LogicalAndExpression */:
+                case 189 /* BitwiseOrExpression */:
+                case 190 /* BitwiseExclusiveOrExpression */:
+                case 191 /* BitwiseAndExpression */:
+                case 192 /* EqualsWithTypeConversionExpression */:
+                case 193 /* NotEqualsWithTypeConversionExpression */:
+                case 194 /* EqualsExpression */:
+                case 195 /* NotEqualsExpression */:
+                case 196 /* LessThanExpression */:
+                case 197 /* GreaterThanExpression */:
+                case 198 /* LessThanOrEqualExpression */:
+                case 199 /* GreaterThanOrEqualExpression */:
+                case 200 /* InstanceOfExpression */:
+                case 201 /* InExpression */:
+                case 202 /* LeftShiftExpression */:
+                case 203 /* SignedRightShiftExpression */:
+                case 204 /* UnsignedRightShiftExpression */:
+                case 205 /* MultiplyExpression */:
+                case 206 /* DivideExpression */:
+                case 207 /* ModuloExpression */:
+                case 208 /* AddExpression */:
+                case 209 /* SubtractExpression */:
+                    return this.emitBinaryExpression(ast);
+                case 186 /* ConditionalExpression */:
+                    return this.emitConditionalExpression(ast);
+                case 232 /* EqualsValueClause */:
+                    return this.emitEqualsValueClause(ast);
+                case 242 /* Parameter */:
+                    return this.emitParameter(ast);
+                case 146 /* Block */:
+                    return this.emitBlock(ast);
+                case 235 /* ElseClause */:
+                    return this.emitElseClause(ast);
+                case 147 /* IfStatement */:
+                    return this.emitIfStatement(ast);
+                case 149 /* ExpressionStatement */:
+                    return this.emitExpressionStatement(ast);
+                case 139 /* GetAccessor */:
+                    return this.emitGetAccessor(ast);
+                case 140 /* SetAccessor */:
+                    return this.emitSetAccessor(ast);
+                case 157 /* ThrowStatement */:
+                    return this.emitThrowStatement(ast);
+                case 150 /* ReturnStatement */:
+                    return this.emitReturnStatement(ast);
+                case 216 /* ObjectCreationExpression */:
+                    return this.emitObjectCreationExpression(ast);
+                case 151 /* SwitchStatement */:
+                    return this.emitSwitchStatement(ast);
+                case 233 /* CaseSwitchClause */:
+                    return this.emitCaseSwitchClause(ast);
+                case 234 /* DefaultSwitchClause */:
+                    return this.emitDefaultSwitchClause(ast);
+                case 152 /* BreakStatement */:
+                    return this.emitBreakStatement(ast);
+                case 153 /* ContinueStatement */:
+                    return this.emitContinueStatement(ast);
+                case 154 /* ForStatement */:
+                    return this.emitForStatement(ast);
+                case 155 /* ForInStatement */:
+                    return this.emitForInStatement(ast);
+                case 158 /* WhileStatement */:
+                    return this.emitWhileStatement(ast);
+                case 163 /* WithStatement */:
+                    return this.emitWithStatement(ast);
+                case 220 /* CastExpression */:
+                    return this.emitCastExpression(ast);
+                case 215 /* ObjectLiteralExpression */:
+                    return this.emitObjectLiteralExpression(ast);
+                case 240 /* SimplePropertyAssignment */:
+                    return this.emitSimplePropertyAssignment(ast);
+                case 241 /* FunctionPropertyAssignment */:
+                    return this.emitFunctionPropertyAssignment(ast);
+                case 156 /* EmptyStatement */:
+                    return this.writeToOutputWithSourceMapRecord(";", ast);
+                case 159 /* TryStatement */:
+                    return this.emitTryStatement(ast);
+                case 236 /* CatchClause */:
+                    return this.emitCatchClause(ast);
+                case 237 /* FinallyClause */:
+                    return this.emitFinallyClause(ast);
+                case 160 /* LabeledStatement */:
+                    return this.emitLabeledStatement(ast);
+                case 161 /* DoStatement */:
+                    return this.emitDoStatement(ast);
+                case 171 /* TypeOfExpression */:
+                    return this.emitTypeOfExpression(ast);
+                case 170 /* DeleteExpression */:
+                    return this.emitDeleteExpression(ast);
+                case 172 /* VoidExpression */:
+                    return this.emitVoidExpression(ast);
+                case 162 /* DebuggerStatement */:
+                    return this.emitDebuggerStatement(ast);
+            }
+        };
+        return Emitter;
+    })();
+    TypeScript.Emitter = Emitter;
+
+    function getLastConstructor(classDecl) {
+        return classDecl.classElements.lastOrDefault(function (e) {
+            return e.kind() === 137 /* ConstructorDeclaration */;
+        });
+    }
+    TypeScript.getLastConstructor = getLastConstructor;
+
+    function getTrimmedTextLines(comment) {
+        if (comment.kind() === 6 /* MultiLineCommentTrivia */) {
+            return comment.fullText().split("\n").map(function (s) {
+                return s.trim();
+            });
+        } else {
+            return [comment.fullText().trim()];
+        }
+    }
+    TypeScript.getTrimmedTextLines = getTrimmedTextLines;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var MemberName = (function () {
+        function MemberName() {
+            this.prefix = "";
+            this.suffix = "";
+        }
+        MemberName.prototype.isString = function () {
+            return false;
+        };
+        MemberName.prototype.isArray = function () {
+            return false;
+        };
+        MemberName.prototype.isMarker = function () {
+            return !this.isString() && !this.isArray();
+        };
+
+        MemberName.prototype.toString = function () {
+            return MemberName.memberNameToString(this);
+        };
+
+        MemberName.memberNameToString = function (memberName, markerInfo, markerBaseLength) {
+            if (typeof markerBaseLength === "undefined") { markerBaseLength = 0; }
+            var result = memberName.prefix;
+
+            if (memberName.isString()) {
+                result += memberName.text;
+            } else if (memberName.isArray()) {
+                var ar = memberName;
+                for (var index = 0; index < ar.entries.length; index++) {
+                    if (ar.entries[index].isMarker()) {
+                        if (markerInfo) {
+                            markerInfo.push(markerBaseLength + result.length);
+                        }
+                        continue;
+                    }
+
+                    result += MemberName.memberNameToString(ar.entries[index], markerInfo, markerBaseLength + result.length);
+                    result += ar.delim;
+                }
+            }
+
+            result += memberName.suffix;
+            return result;
+        };
+
+        MemberName.create = function (arg1, arg2, arg3) {
+            if (typeof arg1 === "string") {
+                return new MemberNameString(arg1);
+            } else {
+                var result = new MemberNameArray();
+                if (arg2)
+                    result.prefix = arg2;
+                if (arg3)
+                    result.suffix = arg3;
+                result.entries.push(arg1);
+                return result;
+            }
+        };
+        return MemberName;
+    })();
+    TypeScript.MemberName = MemberName;
+
+    var MemberNameString = (function (_super) {
+        __extends(MemberNameString, _super);
+        function MemberNameString(text) {
+            _super.call(this);
+            this.text = text;
+        }
+        MemberNameString.prototype.isString = function () {
+            return true;
+        };
+        return MemberNameString;
+    })(MemberName);
+    TypeScript.MemberNameString = MemberNameString;
+
+    var MemberNameArray = (function (_super) {
+        __extends(MemberNameArray, _super);
+        function MemberNameArray() {
+            _super.call(this);
+            this.delim = "";
+            this.entries = [];
+        }
+        MemberNameArray.prototype.isArray = function () {
+            return true;
+        };
+
+        MemberNameArray.prototype.add = function (entry) {
+            this.entries.push(entry);
+        };
+
+        MemberNameArray.prototype.addAll = function (entries) {
+            for (var i = 0; i < entries.length; i++) {
+                this.entries.push(entries[i]);
+            }
+        };
+        return MemberNameArray;
+    })(MemberName);
+    TypeScript.MemberNameArray = MemberNameArray;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    function stripStartAndEndQuotes(str) {
+        var firstCharCode = str && str.charCodeAt(0);
+        if (str && str.length >= 2 && firstCharCode === str.charCodeAt(str.length - 1) && (firstCharCode === 39 /* singleQuote */ || firstCharCode === 34 /* doubleQuote */)) {
+            return str.substring(1, str.length - 1);
+        }
+
+        return str;
+    }
+    TypeScript.stripStartAndEndQuotes = stripStartAndEndQuotes;
+
+    function isSingleQuoted(str) {
+        return str && str.length >= 2 && str.charCodeAt(0) === str.charCodeAt(str.length - 1) && str.charCodeAt(0) === 39 /* singleQuote */;
+    }
+    TypeScript.isSingleQuoted = isSingleQuoted;
+
+    function isDoubleQuoted(str) {
+        return str && str.length >= 2 && str.charCodeAt(0) === str.charCodeAt(str.length - 1) && str.charCodeAt(0) === 34 /* doubleQuote */;
+    }
+    TypeScript.isDoubleQuoted = isDoubleQuoted;
+
+    function isQuoted(str) {
+        return isDoubleQuoted(str) || isSingleQuoted(str);
+    }
+    TypeScript.isQuoted = isQuoted;
+
+    function quoteStr(str) {
+        return "\"" + str + "\"";
+    }
+    TypeScript.quoteStr = quoteStr;
+
+    var switchToForwardSlashesRegEx = /\\/g;
+    function switchToForwardSlashes(path) {
+        return path.replace(switchToForwardSlashesRegEx, "/");
+    }
+    TypeScript.switchToForwardSlashes = switchToForwardSlashes;
+
+    function trimModName(modName) {
+        if (modName.length > 5 && modName.substring(modName.length - 5, modName.length) === ".d.ts") {
+            return modName.substring(0, modName.length - 5);
+        }
+        if (modName.length > 3 && modName.substring(modName.length - 3, modName.length) === ".ts") {
+            return modName.substring(0, modName.length - 3);
+        }
+
+        if (modName.length > 3 && modName.substring(modName.length - 3, modName.length) === ".js") {
+            return modName.substring(0, modName.length - 3);
+        }
+
+        return modName;
+    }
+    TypeScript.trimModName = trimModName;
+
+    function getDeclareFilePath(fname) {
+        return isTSFile(fname) ? changePathToDTS(fname) : changePathToDTS(fname);
+    }
+    TypeScript.getDeclareFilePath = getDeclareFilePath;
+
+    function isFileOfExtension(fname, ext) {
+        var invariantFname = fname.toLocaleUpperCase();
+        var invariantExt = ext.toLocaleUpperCase();
+        var extLength = invariantExt.length;
+        return invariantFname.length > extLength && invariantFname.substring(invariantFname.length - extLength, invariantFname.length) === invariantExt;
+    }
+
+    function isTSFile(fname) {
+        return isFileOfExtension(fname, ".ts");
+    }
+    TypeScript.isTSFile = isTSFile;
+
+    function isDTSFile(fname) {
+        return isFileOfExtension(fname, ".d.ts");
+    }
+    TypeScript.isDTSFile = isDTSFile;
+
+    function getPrettyName(modPath, quote, treatAsFileName) {
+        if (typeof quote === "undefined") { quote = true; }
+        if (typeof treatAsFileName === "undefined") { treatAsFileName = false; }
+        var modName = treatAsFileName ? switchToForwardSlashes(modPath) : trimModName(stripStartAndEndQuotes(modPath));
+        var components = this.getPathComponents(modName);
+        return components.length ? (quote ? quoteStr(components[components.length - 1]) : components[components.length - 1]) : modPath;
+    }
+    TypeScript.getPrettyName = getPrettyName;
+
+    function getPathComponents(path) {
+        return path.split("/");
+    }
+    TypeScript.getPathComponents = getPathComponents;
+
+    function getRelativePathToFixedPath(fixedModFilePath, absoluteModPath, isAbsoultePathURL) {
+        if (typeof isAbsoultePathURL === "undefined") { isAbsoultePathURL = true; }
+        absoluteModPath = switchToForwardSlashes(absoluteModPath);
+
+        var modComponents = this.getPathComponents(absoluteModPath);
+        var fixedModComponents = this.getPathComponents(fixedModFilePath);
+
+        var joinStartIndex = 0;
+        for (; joinStartIndex < modComponents.length && joinStartIndex < fixedModComponents.length; joinStartIndex++) {
+            if (fixedModComponents[joinStartIndex] !== modComponents[joinStartIndex]) {
+                break;
+            }
+        }
+
+        if (joinStartIndex !== 0) {
+            var relativePath = "";
+            var relativePathComponents = modComponents.slice(joinStartIndex, modComponents.length);
+            for (; joinStartIndex < fixedModComponents.length; joinStartIndex++) {
+                if (fixedModComponents[joinStartIndex] !== "") {
+                    relativePath = relativePath + "../";
+                }
+            }
+
+            return relativePath + relativePathComponents.join("/");
+        }
+
+        if (isAbsoultePathURL && absoluteModPath.indexOf("://") === -1) {
+            absoluteModPath = "file:///" + absoluteModPath;
+        }
+
+        return absoluteModPath;
+    }
+    TypeScript.getRelativePathToFixedPath = getRelativePathToFixedPath;
+
+    function changePathToDTS(modPath) {
+        return trimModName(stripStartAndEndQuotes(modPath)) + ".d.ts";
+    }
+    TypeScript.changePathToDTS = changePathToDTS;
+
+    function isRelative(path) {
+        return path.length > 0 && path.charAt(0) === ".";
+    }
+    TypeScript.isRelative = isRelative;
+    function isRooted(path) {
+        return path.length > 0 && (path.charAt(0) === "\\" || path.charAt(0) === "/" || (path.indexOf(":\\") !== -1) || (path.indexOf(":/") !== -1));
+    }
+    TypeScript.isRooted = isRooted;
+
+    function getRootFilePath(outFname) {
+        if (outFname === "") {
+            return outFname;
+        } else {
+            var isPath = outFname.indexOf("/") !== -1;
+            return isPath ? filePath(outFname) : "";
+        }
+    }
+    TypeScript.getRootFilePath = getRootFilePath;
+
+    function filePathComponents(fullPath) {
+        fullPath = switchToForwardSlashes(fullPath);
+        var components = getPathComponents(fullPath);
+        return components.slice(0, components.length - 1);
+    }
+    TypeScript.filePathComponents = filePathComponents;
+
+    function filePath(fullPath) {
+        var path = filePathComponents(fullPath);
+        return path.join("/") + "/";
+    }
+    TypeScript.filePath = filePath;
+
+    function convertToDirectoryPath(dirPath) {
+        if (dirPath && dirPath.charAt(dirPath.length - 1) !== "/") {
+            dirPath += "/";
+        }
+
+        return dirPath;
+    }
+    TypeScript.convertToDirectoryPath = convertToDirectoryPath;
+
+    var normalizePathRegEx = /^\\\\[^\\]/;
+    function normalizePath(path) {
+        if (normalizePathRegEx.test(path)) {
+            path = "file:" + path;
+        }
+        var parts = this.getPathComponents(switchToForwardSlashes(path));
+        var normalizedParts = [];
+
+        for (var i = 0; i < parts.length; i++) {
+            var part = parts[i];
+            if (part === ".") {
+                continue;
+            }
+
+            if (normalizedParts.length > 0 && TypeScript.ArrayUtilities.last(normalizedParts) !== ".." && part === "..") {
+                normalizedParts.pop();
+                continue;
+            }
+
+            normalizedParts.push(part);
+        }
+
+        return normalizedParts.join("/");
+    }
+    TypeScript.normalizePath = normalizePath;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    
+
+    function isNoDefaultLibMatch(comment) {
+        var isNoDefaultLibRegex = /^(\/\/\/\s*<reference\s+no-default-lib=)('|")(.+?)\2\s*\/>/gim;
+        return isNoDefaultLibRegex.exec(comment);
+    }
+
+    TypeScript.tripleSlashReferenceRegExp = /^(\/\/\/\s*<reference\s+path=)('|")(.+?)\2\s*(static=('|")(.+?)\2\s*)*\/>/;
+
+    function getFileReferenceFromReferencePath(fileName, lineMap, position, comment, diagnostics) {
+        var simpleReferenceRegEx = /^\/\/\/\s*<reference\s+/gim;
+        if (simpleReferenceRegEx.exec(comment)) {
+            var isNoDefaultLib = isNoDefaultLibMatch(comment);
+
+            if (!isNoDefaultLib) {
+                var fullReferenceRegEx = TypeScript.tripleSlashReferenceRegExp;
+                var fullReference = fullReferenceRegEx.exec(comment);
+
+                if (!fullReference) {
+                    diagnostics.push(new TypeScript.Diagnostic(fileName, lineMap, position, comment.length, TypeScript.DiagnosticCode.Invalid_reference_directive_syntax));
+                } else {
+                    var path = TypeScript.normalizePath(fullReference[3]);
+                    var adjustedPath = TypeScript.normalizePath(path);
+
+                    var isResident = fullReference.length >= 7 && fullReference[6] === "true";
+                    if (isResident) {
+                        TypeScript.CompilerDiagnostics.debugPrint(path + " is resident");
+                    }
+                    return {
+                        line: 0,
+                        character: 0,
+                        position: 0,
+                        length: 0,
+                        path: TypeScript.switchToForwardSlashes(adjustedPath),
+                        isResident: isResident
+                    };
+                }
+            }
+        }
+
+        return null;
+    }
+
+    var scannerWindow = TypeScript.ArrayUtilities.createArray(2048, 0);
+    var scannerDiagnostics = [];
+
+    function processImports(lineMap, scanner, token, importedFiles) {
+        var position = 0;
+        var lineChar = { line: -1, character: -1 };
+
+        var start = new Date().getTime();
+
+        while (token.tokenKind !== 10 /* EndOfFileToken */) {
+            if (token.tokenKind === 49 /* ImportKeyword */) {
+                var importStart = position + token.leadingTriviaWidth();
+                token = scanner.scan(scannerDiagnostics, false);
+
+                if (TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token)) {
+                    token = scanner.scan(scannerDiagnostics, false);
+
+                    if (token.tokenKind === 107 /* EqualsToken */) {
+                        token = scanner.scan(scannerDiagnostics, false);
+
+                        if (token.tokenKind === 65 /* ModuleKeyword */ || token.tokenKind === 66 /* RequireKeyword */) {
+                            token = scanner.scan(scannerDiagnostics, false);
+
+                            if (token.tokenKind === 72 /* OpenParenToken */) {
+                                var afterOpenParenPosition = scanner.absoluteIndex();
+                                token = scanner.scan(scannerDiagnostics, false);
+
+                                lineMap.fillLineAndCharacterFromPosition(importStart, lineChar);
+
+                                if (token.tokenKind === 14 /* StringLiteral */) {
+                                    var ref = {
+                                        line: lineChar.line,
+                                        character: lineChar.character,
+                                        position: afterOpenParenPosition + token.leadingTriviaWidth(),
+                                        length: token.width(),
+                                        path: TypeScript.stripStartAndEndQuotes(TypeScript.switchToForwardSlashes(token.text())),
+                                        isResident: false
+                                    };
+                                    importedFiles.push(ref);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            position = scanner.absoluteIndex();
+            token = scanner.scan(scannerDiagnostics, false);
+        }
+
+        var totalTime = new Date().getTime() - start;
+        TypeScript.fileResolutionScanImportsTime += totalTime;
+    }
+
+    function processTripleSlashDirectives(fileName, lineMap, firstToken) {
+        var leadingTrivia = firstToken.leadingTrivia();
+
+        var position = 0;
+        var lineChar = { line: -1, character: -1 };
+        var noDefaultLib = false;
+        var diagnostics = [];
+        var referencedFiles = [];
+
+        for (var i = 0, n = leadingTrivia.count(); i < n; i++) {
+            var trivia = leadingTrivia.syntaxTriviaAt(i);
+
+            if (trivia.kind() === 7 /* SingleLineCommentTrivia */) {
+                var triviaText = trivia.fullText();
+                var referencedCode = getFileReferenceFromReferencePath(fileName, lineMap, position, triviaText, diagnostics);
+
+                if (referencedCode) {
+                    lineMap.fillLineAndCharacterFromPosition(position, lineChar);
+                    referencedCode.position = position;
+                    referencedCode.length = trivia.fullWidth();
+                    referencedCode.line = lineChar.line;
+                    referencedCode.character = lineChar.character;
+
+                    referencedFiles.push(referencedCode);
+                }
+
+                var isNoDefaultLib = isNoDefaultLibMatch(triviaText);
+                if (isNoDefaultLib) {
+                    noDefaultLib = isNoDefaultLib[3] === "true";
+                }
+            }
+
+            position += trivia.fullWidth();
+        }
+
+        return { noDefaultLib: noDefaultLib, diagnostics: diagnostics, referencedFiles: referencedFiles };
+    }
+
+    function preProcessFile(fileName, sourceText, readImportFiles) {
+        if (typeof readImportFiles === "undefined") { readImportFiles = true; }
+        var text = TypeScript.SimpleText.fromScriptSnapshot(sourceText);
+        var scanner = new TypeScript.Scanner(fileName, text, 1 /* EcmaScript5 */, scannerWindow);
+
+        var firstToken = scanner.scan(scannerDiagnostics, false);
+
+        var importedFiles = [];
+        if (readImportFiles) {
+            processImports(text.lineMap(), scanner, firstToken, importedFiles);
+        }
+
+        var properties = processTripleSlashDirectives(fileName, text.lineMap(), firstToken);
+
+        scannerDiagnostics.length = 0;
+        return { referencedFiles: properties.referencedFiles, importedFiles: importedFiles, isLibFile: properties.noDefaultLib, diagnostics: properties.diagnostics };
+    }
+    TypeScript.preProcessFile = preProcessFile;
+
+    function getParseOptions(settings) {
+        return new TypeScript.ParseOptions(settings.codeGenTarget(), settings.allowAutomaticSemicolonInsertion());
+    }
+    TypeScript.getParseOptions = getParseOptions;
+
+    function getReferencedFiles(fileName, sourceText) {
+        return preProcessFile(fileName, sourceText, false).referencedFiles;
+    }
+    TypeScript.getReferencedFiles = getReferencedFiles;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var ReferenceResolutionResult = (function () {
+        function ReferenceResolutionResult() {
+            this.resolvedFiles = [];
+            this.diagnostics = [];
+            this.seenNoDefaultLibTag = false;
+        }
+        return ReferenceResolutionResult;
+    })();
+    TypeScript.ReferenceResolutionResult = ReferenceResolutionResult;
+
+    var ReferenceLocation = (function () {
+        function ReferenceLocation(filePath, lineMap, position, length, isImported) {
+            this.filePath = filePath;
+            this.lineMap = lineMap;
+            this.position = position;
+            this.length = length;
+            this.isImported = isImported;
+        }
+        return ReferenceLocation;
+    })();
+
+    var ReferenceResolver = (function () {
+        function ReferenceResolver(inputFileNames, host, useCaseSensitiveFileResolution) {
+            this.useCaseSensitiveFileResolution = useCaseSensitiveFileResolution;
+            this.inputFileNames = inputFileNames;
+            this.host = host;
+            this.visited = {};
+        }
+        ReferenceResolver.resolve = function (inputFileNames, host, useCaseSensitiveFileResolution) {
+            var resolver = new ReferenceResolver(inputFileNames, host, useCaseSensitiveFileResolution);
+            return resolver.resolveInputFiles();
+        };
+
+        ReferenceResolver.prototype.resolveInputFiles = function () {
+            var _this = this;
+            var result = new ReferenceResolutionResult();
+
+            if (!this.inputFileNames || this.inputFileNames.length <= 0) {
+                return result;
+            }
+
+            var referenceLocation = new ReferenceLocation(null, null, 0, 0, false);
+            this.inputFileNames.forEach(function (fileName) {
+                return _this.resolveIncludedFile(fileName, referenceLocation, result);
+            });
+
+            return result;
+        };
+
+        ReferenceResolver.prototype.resolveIncludedFile = function (path, referenceLocation, resolutionResult) {
+            var normalizedPath = this.getNormalizedFilePath(path, referenceLocation.filePath);
+
+            if (this.isSameFile(normalizedPath, referenceLocation.filePath)) {
+                if (!referenceLocation.isImported) {
+                    resolutionResult.diagnostics.push(new TypeScript.Diagnostic(referenceLocation.filePath, referenceLocation.lineMap, referenceLocation.position, referenceLocation.length, TypeScript.DiagnosticCode.A_file_cannot_have_a_reference_to_itself, null));
+                }
+
+                return normalizedPath;
+            }
+
+            if (!TypeScript.isTSFile(normalizedPath) && !TypeScript.isDTSFile(normalizedPath)) {
+                var dtsFile = normalizedPath + ".d.ts";
+                var tsFile = normalizedPath + ".ts";
+
+                if (this.host.fileExists(tsFile)) {
+                    normalizedPath = tsFile;
+                } else {
+                    normalizedPath = dtsFile;
+                }
+            }
+
+            if (!this.host.fileExists(normalizedPath)) {
+                if (!referenceLocation.isImported) {
+                    resolutionResult.diagnostics.push(new TypeScript.Diagnostic(referenceLocation.filePath, referenceLocation.lineMap, referenceLocation.position, referenceLocation.length, TypeScript.DiagnosticCode.Cannot_resolve_referenced_file_0, [path]));
+                }
+
+                return normalizedPath;
+            }
+
+            return this.resolveFile(normalizedPath, resolutionResult);
+        };
+
+        ReferenceResolver.prototype.resolveImportedFile = function (path, referenceLocation, resolutionResult) {
+            var isRelativePath = TypeScript.isRelative(path);
+            var isRootedPath = isRelativePath ? false : TypeScript.isRooted(path);
+
+            if (isRelativePath || isRootedPath) {
+                return this.resolveIncludedFile(path, referenceLocation, resolutionResult);
+            } else {
+                var parentDirectory = this.host.getParentDirectory(referenceLocation.filePath);
+                var searchFilePath = null;
+                var dtsFileName = path + ".d.ts";
+                var tsFilePath = path + ".ts";
+
+                var start = new Date().getTime();
+
+                do {
+                    currentFilePath = this.host.resolveRelativePath(tsFilePath, parentDirectory);
+                    if (this.host.fileExists(currentFilePath)) {
+                        searchFilePath = currentFilePath;
+                        break;
+                    }
+
+                    var currentFilePath = this.host.resolveRelativePath(dtsFileName, parentDirectory);
+                    if (this.host.fileExists(currentFilePath)) {
+                        searchFilePath = currentFilePath;
+                        break;
+                    }
+
+                    parentDirectory = this.host.getParentDirectory(parentDirectory);
+                } while(parentDirectory);
+
+                TypeScript.fileResolutionImportFileSearchTime += new Date().getTime() - start;
+
+                if (!searchFilePath) {
+                    return path;
+                }
+
+                return this.resolveFile(searchFilePath, resolutionResult);
+            }
+        };
+
+        ReferenceResolver.prototype.resolveFile = function (normalizedPath, resolutionResult) {
+            var _this = this;
+            var visitedPath = this.isVisited(normalizedPath);
+            if (!visitedPath) {
+                this.recordVisitedFile(normalizedPath);
+
+                var start = new Date().getTime();
+                var scriptSnapshot = this.host.getScriptSnapshot(normalizedPath);
+                var totalTime = new Date().getTime() - start;
+                TypeScript.fileResolutionIOTime += totalTime;
+
+                var lineMap = TypeScript.LineMap1.fromScriptSnapshot(scriptSnapshot);
+                var preprocessedFileInformation = TypeScript.preProcessFile(normalizedPath, scriptSnapshot);
+                resolutionResult.diagnostics.push.apply(resolutionResult.diagnostics, preprocessedFileInformation.diagnostics);
+
+                if (preprocessedFileInformation.isLibFile) {
+                    resolutionResult.seenNoDefaultLibTag = true;
+                }
+
+                var normalizedReferencePaths = [];
+                preprocessedFileInformation.referencedFiles.forEach(function (fileReference) {
+                    var currentReferenceLocation = new ReferenceLocation(normalizedPath, lineMap, fileReference.position, fileReference.length, false);
+                    var normalizedReferencePath = _this.resolveIncludedFile(fileReference.path, currentReferenceLocation, resolutionResult);
+                    normalizedReferencePaths.push(normalizedReferencePath);
+                });
+
+                var normalizedImportPaths = [];
+                for (var i = 0; i < preprocessedFileInformation.importedFiles.length; i++) {
+                    var fileImport = preprocessedFileInformation.importedFiles[i];
+                    var currentReferenceLocation = new ReferenceLocation(normalizedPath, lineMap, fileImport.position, fileImport.length, true);
+                    var normalizedImportPath = this.resolveImportedFile(fileImport.path, currentReferenceLocation, resolutionResult);
+                    normalizedImportPaths.push(normalizedImportPath);
+                }
+
+                resolutionResult.resolvedFiles.push({
+                    path: normalizedPath,
+                    referencedFiles: normalizedReferencePaths,
+                    importedFiles: normalizedImportPaths
+                });
+            } else {
+                normalizedPath = visitedPath;
+            }
+
+            return normalizedPath;
+        };
+
+        ReferenceResolver.prototype.getNormalizedFilePath = function (path, parentFilePath) {
+            var parentFileDirectory = parentFilePath ? this.host.getParentDirectory(parentFilePath) : "";
+            var normalizedPath = this.host.resolveRelativePath(path, parentFileDirectory);
+            return normalizedPath;
+        };
+
+        ReferenceResolver.prototype.getUniqueFileId = function (filePath) {
+            return this.useCaseSensitiveFileResolution ? filePath : filePath.toLocaleUpperCase();
+        };
+
+        ReferenceResolver.prototype.recordVisitedFile = function (filePath) {
+            this.visited[this.getUniqueFileId(filePath)] = filePath;
+        };
+
+        ReferenceResolver.prototype.isVisited = function (filePath) {
+            return this.visited[this.getUniqueFileId(filePath)];
+        };
+
+        ReferenceResolver.prototype.isSameFile = function (filePath1, filePath2) {
+            if (!filePath1 || !filePath2) {
+                return false;
+            }
+
+            if (this.useCaseSensitiveFileResolution) {
+                return filePath1 === filePath2;
+            } else {
+                return filePath1.toLocaleUpperCase() === filePath2.toLocaleUpperCase();
+            }
+        };
+        return ReferenceResolver;
+    })();
+    TypeScript.ReferenceResolver = ReferenceResolver;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var TextWriter = (function () {
+        function TextWriter(name, writeByteOrderMark, outputFileType) {
+            this.name = name;
+            this.writeByteOrderMark = writeByteOrderMark;
+            this.outputFileType = outputFileType;
+            this.contents = "";
+            this.onNewLine = true;
+        }
+        TextWriter.prototype.Write = function (s) {
+            this.contents += s;
+            this.onNewLine = false;
+        };
+
+        TextWriter.prototype.WriteLine = function (s) {
+            this.contents += s;
+            this.contents += TypeScript.newLine();
+            this.onNewLine = true;
+        };
+
+        TextWriter.prototype.Close = function () {
+        };
+
+        TextWriter.prototype.getOutputFile = function () {
+            return new TypeScript.OutputFile(this.name, this.writeByteOrderMark, this.contents, this.outputFileType);
+        };
+        return TextWriter;
+    })();
+    TypeScript.TextWriter = TextWriter;
+
+    var DeclarationEmitter = (function () {
+        function DeclarationEmitter(emittingFileName, document, compiler, emitOptions, semanticInfoChain) {
+            this.emittingFileName = emittingFileName;
+            this.document = document;
+            this.compiler = compiler;
+            this.emitOptions = emitOptions;
+            this.semanticInfoChain = semanticInfoChain;
+            this.declFile = null;
+            this.indenter = new TypeScript.Indenter();
+            this.emittedReferencePaths = false;
+            this.declFile = new TextWriter(emittingFileName, this.document.byteOrderMark !== 0 /* None */, 2 /* Declaration */);
+        }
+        DeclarationEmitter.prototype.getOutputFile = function () {
+            return this.declFile.getOutputFile();
+        };
+
+        DeclarationEmitter.prototype.emitDeclarations = function (sourceUnit) {
+            this.emitDeclarationsForSourceUnit(sourceUnit);
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForList = function (list) {
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                this.emitDeclarationsForAST(list.childAt(i));
+            }
+        };
+
+        DeclarationEmitter.prototype.emitSeparatedList = function (list) {
+            for (var i = 0, n = list.nonSeparatorCount(); i < n; i++) {
+                this.emitDeclarationsForAST(list.nonSeparatorAt(i));
+            }
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForAST = function (ast) {
+            switch (ast.kind()) {
+                case 148 /* VariableStatement */:
+                    return this.emitDeclarationsForVariableStatement(ast);
+                case 141 /* PropertySignature */:
+                    return this.emitPropertySignature(ast);
+                case 225 /* VariableDeclarator */:
+                    return this.emitVariableDeclarator(ast, true, true);
+                case 136 /* MemberVariableDeclaration */:
+                    return this.emitDeclarationsForMemberVariableDeclaration(ast);
+                case 137 /* ConstructorDeclaration */:
+                    return this.emitDeclarationsForConstructorDeclaration(ast);
+                case 139 /* GetAccessor */:
+                    return this.emitDeclarationsForGetAccessor(ast);
+                case 140 /* SetAccessor */:
+                    return this.emitDeclarationsForSetAccessor(ast);
+                case 138 /* IndexMemberDeclaration */:
+                    return this.emitIndexMemberDeclaration(ast);
+                case 144 /* IndexSignature */:
+                    return this.emitIndexSignature(ast);
+                case 142 /* CallSignature */:
+                    return this.emitCallSignature(ast);
+                case 143 /* ConstructSignature */:
+                    return this.emitConstructSignature(ast);
+                case 145 /* MethodSignature */:
+                    return this.emitMethodSignature(ast);
+                case 129 /* FunctionDeclaration */:
+                    return this.emitDeclarationsForFunctionDeclaration(ast);
+                case 135 /* MemberFunctionDeclaration */:
+                    return this.emitMemberFunctionDeclaration(ast);
+                case 131 /* ClassDeclaration */:
+                    return this.emitDeclarationsForClassDeclaration(ast);
+                case 128 /* InterfaceDeclaration */:
+                    return this.emitDeclarationsForInterfaceDeclaration(ast);
+                case 133 /* ImportDeclaration */:
+                    return this.emitDeclarationsForImportDeclaration(ast);
+                case 130 /* ModuleDeclaration */:
+                    return this.emitDeclarationsForModuleDeclaration(ast);
+                case 132 /* EnumDeclaration */:
+                    return this.emitDeclarationsForEnumDeclaration(ast);
+                case 134 /* ExportAssignment */:
+                    return this.emitDeclarationsForExportAssignment(ast);
+            }
+        };
+
+        DeclarationEmitter.prototype.getIndentString = function (declIndent) {
+            if (typeof declIndent === "undefined") { declIndent = false; }
+            return this.indenter.getIndent();
+        };
+
+        DeclarationEmitter.prototype.emitIndent = function () {
+            this.declFile.Write(this.getIndentString());
+        };
+
+        DeclarationEmitter.prototype.canEmitDeclarations = function (declAST) {
+            var container = DeclarationEmitter.getEnclosingContainer(declAST);
+            if (container.kind() === 130 /* ModuleDeclaration */ || container.kind() === 120 /* SourceUnit */) {
+                var pullDecl = this.semanticInfoChain.getDeclForAST(declAST);
+                if (!TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */)) {
+                    var start = new Date().getTime();
+                    var declSymbol = this.semanticInfoChain.getSymbolForAST(declAST);
+                    var result = declSymbol && declSymbol.isExternallyVisible();
+                    TypeScript.declarationEmitIsExternallyVisibleTime += new Date().getTime() - start;
+
+                    return result;
+                }
+            }
+
+            return true;
+        };
+
+        DeclarationEmitter.prototype.getDeclFlagsString = function (pullDecl, typeString) {
+            var result = this.getIndentString();
+            var pullFlags = pullDecl.flags;
+
+            if (TypeScript.hasFlag(pullFlags, 16 /* Static */)) {
+                if (TypeScript.hasFlag(pullFlags, 2 /* Private */)) {
+                    result += "private ";
+                }
+                result += "static ";
+            } else {
+                if (TypeScript.hasFlag(pullFlags, 2 /* Private */)) {
+                    result += "private ";
+                } else if (TypeScript.hasFlag(pullFlags, 4 /* Public */)) {
+                    result += "public ";
+                } else {
+                    var emitDeclare = !TypeScript.hasFlag(pullFlags, 1 /* Exported */);
+
+                    var declAST = this.semanticInfoChain.getASTForDecl(pullDecl);
+                    var container = DeclarationEmitter.getEnclosingContainer(declAST);
+
+                    var isExternalModule = container.kind() === 120 /* SourceUnit */ && this.document.isExternalModule();
+
+                    if (isExternalModule && TypeScript.hasFlag(pullFlags, 1 /* Exported */)) {
+                        result += "export ";
+                        emitDeclare = true;
+                    }
+
+                    if (isExternalModule || container.kind() === 120 /* SourceUnit */) {
+                        if (emitDeclare && typeString !== "interface" && typeString !== "import") {
+                            result += "declare ";
+                        }
+                    }
+
+                    result += typeString + " ";
+                }
+            }
+
+            return result;
+        };
+
+        DeclarationEmitter.prototype.emitDeclFlags = function (declarationAST, typeString) {
+            this.declFile.Write(this.getDeclFlagsString(this.semanticInfoChain.getDeclForAST(declarationAST), typeString));
+        };
+
+        DeclarationEmitter.prototype.emitTypeNamesMember = function (memberName, emitIndent) {
+            if (typeof emitIndent === "undefined") { emitIndent = false; }
+            if (memberName.prefix === "{ ") {
+                if (emitIndent) {
+                    this.emitIndent();
+                }
+
+                this.declFile.WriteLine("{");
+                this.indenter.increaseIndent();
+                emitIndent = true;
+            } else if (memberName.prefix !== "") {
+                if (emitIndent) {
+                    this.emitIndent();
+                }
+
+                this.declFile.Write(memberName.prefix);
+                emitIndent = false;
+            }
+
+            if (memberName.isString()) {
+                if (emitIndent) {
+                    this.emitIndent();
+                }
+
+                this.declFile.Write(memberName.text);
+            } else if (memberName.isArray()) {
+                var ar = memberName;
+                for (var index = 0; index < ar.entries.length; index++) {
+                    this.emitTypeNamesMember(ar.entries[index], emitIndent);
+                    if (ar.delim === "; ") {
+                        this.declFile.WriteLine(";");
+                    }
+                }
+            }
+
+            if (memberName.suffix === "}") {
+                this.indenter.decreaseIndent();
+                this.emitIndent();
+                this.declFile.Write(memberName.suffix);
+            } else {
+                this.declFile.Write(memberName.suffix);
+            }
+        };
+
+        DeclarationEmitter.prototype.emitTypeSignature = function (ast, type) {
+            var declarationContainerAst = DeclarationEmitter.getEnclosingContainer(ast);
+
+            var start = new Date().getTime();
+            var declarationContainerDecl = this.semanticInfoChain.getDeclForAST(declarationContainerAst);
+
+            var declarationPullSymbol = declarationContainerDecl.getSymbol();
+            TypeScript.declarationEmitTypeSignatureTime += new Date().getTime() - start;
+
+            var isNotAGenericType = ast.kind() !== 126 /* GenericType */;
+
+            var typeNameMembers = type.getScopedNameEx(declarationPullSymbol, false, false, false, false, false, isNotAGenericType);
+            this.emitTypeNamesMember(typeNameMembers);
+        };
+
+        DeclarationEmitter.prototype.emitComment = function (comment) {
+            var text = TypeScript.getTrimmedTextLines(comment);
+            if (this.declFile.onNewLine) {
+                this.emitIndent();
+            } else if (comment.kind() !== 6 /* MultiLineCommentTrivia */) {
+                this.declFile.WriteLine("");
+                this.emitIndent();
+            }
+
+            this.declFile.Write(text[0]);
+
+            for (var i = 1; i < text.length; i++) {
+                this.declFile.WriteLine("");
+                this.emitIndent();
+                this.declFile.Write(text[i]);
+            }
+
+            if (comment.endsLine || comment.kind() !== 6 /* MultiLineCommentTrivia */) {
+                this.declFile.WriteLine("");
+            } else {
+                this.declFile.Write(" ");
+            }
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationComments = function (astOrSymbol, endLine) {
+            if (typeof endLine === "undefined") { endLine = true; }
+            if (this.emitOptions.compilationSettings().removeComments()) {
+                return;
+            }
+
+            var declComments = astOrSymbol.docComments ? astOrSymbol.docComments() : TypeScript.ASTHelpers.docComments(astOrSymbol);
+            this.writeDeclarationComments(declComments, endLine);
+        };
+
+        DeclarationEmitter.prototype.writeDeclarationComments = function (declComments, endLine) {
+            if (typeof endLine === "undefined") { endLine = true; }
+            if (declComments.length > 0) {
+                for (var i = 0; i < declComments.length; i++) {
+                    this.emitComment(declComments[i]);
+                }
+
+                if (endLine) {
+                    if (!this.declFile.onNewLine) {
+                        this.declFile.WriteLine("");
+                    }
+                } else {
+                    if (this.declFile.onNewLine) {
+                        this.emitIndent();
+                    }
+                }
+            }
+        };
+
+        DeclarationEmitter.prototype.emitTypeOfVariableDeclaratorOrParameter = function (boundDecl) {
+            var start = new Date().getTime();
+            var decl = this.semanticInfoChain.getDeclForAST(boundDecl);
+            var pullSymbol = decl.getSymbol();
+            TypeScript.declarationEmitGetBoundDeclTypeTime += new Date().getTime() - start;
+
+            var type = pullSymbol.type;
+            TypeScript.Debug.assert(type);
+
+            this.declFile.Write(": ");
+            this.emitTypeSignature(boundDecl, type);
+        };
+
+        DeclarationEmitter.prototype.emitPropertySignature = function (varDecl) {
+            this.emitDeclarationComments(varDecl);
+            this.emitIndent();
+            this.declFile.Write(varDecl.propertyName.text());
+            if (varDecl.questionToken) {
+                this.declFile.Write("?");
+            }
+
+            this.emitTypeOfVariableDeclaratorOrParameter(varDecl);
+
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitVariableDeclarator = function (varDecl, isFirstVarInList, isLastVarInList) {
+            if (this.canEmitDeclarations(varDecl)) {
+                this.emitDeclarationComments(varDecl);
+
+                if (isFirstVarInList) {
+                    this.emitDeclFlags(varDecl, "var");
+                }
+
+                this.declFile.Write(varDecl.propertyName.text());
+
+                if (!TypeScript.hasModifier(TypeScript.ASTHelpers.getVariableDeclaratorModifiers(varDecl), 2 /* Private */)) {
+                    this.emitTypeOfVariableDeclaratorOrParameter(varDecl);
+                }
+
+                if (isLastVarInList) {
+                    this.declFile.WriteLine(";");
+                } else {
+                    this.declFile.Write(", ");
+                }
+            }
+        };
+
+        DeclarationEmitter.prototype.emitClassElementModifiers = function (modifiers) {
+            if (TypeScript.hasModifier(modifiers, 16 /* Static */)) {
+                if (TypeScript.hasModifier(modifiers, 2 /* Private */)) {
+                    this.declFile.Write("private ");
+                }
+                this.declFile.Write("static ");
+            } else {
+                if (TypeScript.hasModifier(modifiers, 2 /* Private */)) {
+                    this.declFile.Write("private ");
+                } else {
+                    this.declFile.Write("public ");
+                }
+            }
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForMemberVariableDeclaration = function (varDecl) {
+            if (this.canEmitDeclarations(varDecl)) {
+                this.emitDeclarationComments(varDecl);
+
+                this.declFile.Write(this.getIndentString());
+                this.emitClassElementModifiers(varDecl.modifiers);
+                ;
+
+                this.declFile.Write(varDecl.variableDeclarator.propertyName.text());
+
+                if (!TypeScript.hasModifier(varDecl.modifiers, 2 /* Private */)) {
+                    this.emitTypeOfVariableDeclaratorOrParameter(varDecl);
+                }
+
+                this.declFile.WriteLine(";");
+            }
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForVariableStatement = function (variableStatement) {
+            this.emitDeclarationsForVariableDeclaration(variableStatement.declaration);
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForVariableDeclaration = function (variableDeclaration) {
+            var varListCount = variableDeclaration.declarators.nonSeparatorCount();
+            for (var i = 0; i < varListCount; i++) {
+                this.emitVariableDeclarator(variableDeclaration.declarators.nonSeparatorAt(i), i === 0, i === varListCount - 1);
+            }
+        };
+
+        DeclarationEmitter.prototype.emitArgDecl = function (argDecl, id, isOptional, isPrivate) {
+            this.indenter.increaseIndent();
+
+            this.emitDeclarationComments(argDecl, false);
+            this.declFile.Write(id.text());
+            if (isOptional) {
+                this.declFile.Write("?");
+            }
+
+            this.indenter.decreaseIndent();
+
+            if (!isPrivate) {
+                this.emitTypeOfVariableDeclaratorOrParameter(argDecl);
+            }
+        };
+
+        DeclarationEmitter.prototype.isOverloadedCallSignature = function (funcDecl) {
+            var start = new Date().getTime();
+            var functionDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            var funcSymbol = functionDecl.getSymbol();
+            TypeScript.declarationEmitIsOverloadedCallSignatureTime += new Date().getTime() - start;
+
+            var funcTypeSymbol = funcSymbol.type;
+            var signatures = funcTypeSymbol.getCallSignatures();
+            var result = signatures && signatures.length > 1;
+
+            return result;
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForConstructorDeclaration = function (funcDecl) {
+            var start = new Date().getTime();
+            var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl);
+
+            TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start;
+
+            var funcTypeSymbol = funcSymbol.type;
+            if (funcDecl.block) {
+                var constructSignatures = funcTypeSymbol.getConstructSignatures();
+                if (constructSignatures && constructSignatures.length > 1) {
+                    return;
+                }
+            }
+
+            var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            var funcSignature = funcPullDecl.getSignatureSymbol();
+            this.emitDeclarationComments(funcDecl);
+
+            this.emitIndent();
+            this.declFile.Write("constructor");
+
+            this.declFile.Write("(");
+            this.emitParameters(false, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList));
+            this.declFile.Write(")");
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitParameterList = function (isPrivate, parameterList) {
+            this.declFile.Write("(");
+            this.emitParameters(isPrivate, TypeScript.ASTHelpers.parametersFromParameterList(parameterList));
+            this.declFile.Write(")");
+        };
+
+        DeclarationEmitter.prototype.emitParameters = function (isPrivate, parameterList) {
+            var hasLastParameterRestParameter = parameterList.lastParameterIsRest();
+            var argsLen = parameterList.length;
+            if (hasLastParameterRestParameter) {
+                argsLen--;
+            }
+
+            for (var i = 0; i < argsLen; i++) {
+                this.emitArgDecl(parameterList.astAt(i), parameterList.identifierAt(i), parameterList.isOptionalAt(i), isPrivate);
+                if (i < (argsLen - 1)) {
+                    this.declFile.Write(", ");
+                }
+            }
+
+            if (hasLastParameterRestParameter) {
+                if (parameterList.length > 1) {
+                    this.declFile.Write(", ...");
+                } else {
+                    this.declFile.Write("...");
+                }
+
+                var index = parameterList.length - 1;
+                this.emitArgDecl(parameterList.astAt(index), parameterList.identifierAt(index), parameterList.isOptionalAt(index), isPrivate);
+            }
+        };
+
+        DeclarationEmitter.prototype.emitMemberFunctionDeclaration = function (funcDecl) {
+            var start = new Date().getTime();
+            var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl);
+
+            TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start;
+
+            var funcTypeSymbol = funcSymbol.type;
+            if (funcDecl.block) {
+                var constructSignatures = funcTypeSymbol.getConstructSignatures();
+                if (constructSignatures && constructSignatures.length > 1) {
+                    return;
+                } else if (this.isOverloadedCallSignature(funcDecl)) {
+                    return;
+                }
+            } else if (TypeScript.hasModifier(funcDecl.modifiers, 2 /* Private */) && this.isOverloadedCallSignature(funcDecl)) {
+                var callSignatures = funcTypeSymbol.getCallSignatures();
+                TypeScript.Debug.assert(callSignatures && callSignatures.length > 1);
+                var firstSignature = callSignatures[0].isDefinition() ? callSignatures[1] : callSignatures[0];
+                var firstSignatureDecl = firstSignature.getDeclarations()[0];
+                var firstFuncDecl = this.semanticInfoChain.getASTForDecl(firstSignatureDecl);
+                if (firstFuncDecl !== funcDecl) {
+                    return;
+                }
+            }
+
+            if (!this.canEmitDeclarations(funcDecl)) {
+                return;
+            }
+
+            var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            var funcSignature = funcPullDecl.getSignatureSymbol();
+            this.emitDeclarationComments(funcDecl);
+
+            this.emitDeclFlags(funcDecl, "function");
+            var id = funcDecl.propertyName.text();
+            this.declFile.Write(id);
+            this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature);
+
+            var isPrivate = TypeScript.hasModifier(funcDecl.modifiers, 2 /* Private */);
+
+            this.emitParameterList(isPrivate, funcDecl.callSignature.parameterList);
+
+            if (!isPrivate) {
+                var returnType = funcSignature.returnType;
+                this.declFile.Write(": ");
+                this.emitTypeSignature(funcDecl, returnType);
+            }
+
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitCallSignature = function (funcDecl) {
+            var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+
+            this.emitDeclarationComments(funcDecl);
+
+            var funcSignature = funcPullDecl.getSignatureSymbol();
+            this.emitTypeParameters(funcDecl.typeParameterList, funcSignature);
+
+            this.emitIndent();
+            this.declFile.Write("(");
+            this.emitParameters(false, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.parameterList));
+            this.declFile.Write(")");
+
+            var returnType = funcSignature.returnType;
+            this.declFile.Write(": ");
+            if (returnType) {
+                this.emitTypeSignature(funcDecl, returnType);
+            } else {
+                this.declFile.Write("any");
+            }
+
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitConstructSignature = function (funcDecl) {
+            var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+
+            var start = new Date().getTime();
+            var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl);
+
+            TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start;
+
+            this.emitDeclarationComments(funcDecl);
+
+            this.emitIndent();
+            this.declFile.Write("new");
+
+            var funcSignature = funcPullDecl.getSignatureSymbol();
+            this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature);
+
+            this.declFile.Write("(");
+            this.emitParameters(false, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList));
+            this.declFile.Write(")");
+
+            var returnType = funcSignature.returnType;
+            this.declFile.Write(": ");
+            if (returnType) {
+                this.emitTypeSignature(funcDecl, returnType);
+            } else {
+                this.declFile.Write("any");
+            }
+
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitMethodSignature = function (funcDecl) {
+            var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+
+            var start = new Date().getTime();
+            var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl);
+
+            TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start;
+
+            this.emitDeclarationComments(funcDecl);
+
+            this.emitIndent();
+            this.declFile.Write(funcDecl.propertyName.text());
+            if (funcDecl.questionToken) {
+                this.declFile.Write("? ");
+            }
+
+            var funcSignature = funcPullDecl.getSignatureSymbol();
+            this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature);
+
+            this.declFile.Write("(");
+            this.emitParameters(false, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList));
+            this.declFile.Write(")");
+
+            var returnType = funcSignature.returnType;
+            this.declFile.Write(": ");
+            if (returnType) {
+                this.emitTypeSignature(funcDecl, returnType);
+            } else {
+                this.declFile.Write("any");
+            }
+
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForFunctionDeclaration = function (funcDecl) {
+            var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+
+            var start = new Date().getTime();
+            var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl);
+
+            TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start;
+
+            if (funcDecl.block) {
+                var funcTypeSymbol = funcSymbol.type;
+                var constructSignatures = funcTypeSymbol.getConstructSignatures();
+                if (constructSignatures && constructSignatures.length > 1) {
+                    return;
+                } else if (this.isOverloadedCallSignature(funcDecl)) {
+                    return;
+                }
+            }
+
+            if (!this.canEmitDeclarations(funcDecl)) {
+                return;
+            }
+
+            this.emitDeclarationComments(funcDecl);
+
+            var id = funcDecl.identifier.text();
+            this.emitDeclFlags(funcDecl, "function");
+            if (id !== "" || !funcDecl.identifier || funcDecl.identifier.text().length > 0) {
+                this.declFile.Write(id);
+            } else if (funcPullDecl.kind === 2097152 /* ConstructSignature */) {
+                this.declFile.Write("new");
+            }
+
+            var funcSignature = funcPullDecl.getSignatureSymbol();
+            this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature);
+
+            this.declFile.Write("(");
+            this.emitParameters(false, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList));
+            this.declFile.Write(")");
+
+            var returnType = funcSignature.returnType;
+            this.declFile.Write(": ");
+            if (returnType) {
+                this.emitTypeSignature(funcDecl, returnType);
+            } else {
+                this.declFile.Write("any");
+            }
+
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitIndexMemberDeclaration = function (funcDecl) {
+            this.emitDeclarationsForAST(funcDecl.indexSignature);
+        };
+
+        DeclarationEmitter.prototype.emitIndexSignature = function (funcDecl) {
+            if (!this.canEmitDeclarations(funcDecl)) {
+                return;
+            }
+
+            this.emitDeclarationComments(funcDecl);
+
+            this.emitIndent();
+            this.declFile.Write("[");
+            this.emitParameters(false, TypeScript.ASTHelpers.parametersFromParameter(funcDecl.parameter));
+            this.declFile.Write("]");
+
+            var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            var funcSignature = funcPullDecl.getSignatureSymbol();
+            var returnType = funcSignature.returnType;
+            this.declFile.Write(": ");
+            this.emitTypeSignature(funcDecl, returnType);
+
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitBaseList = function (bases, useExtendsList) {
+            if (bases && (bases.nonSeparatorCount() > 0)) {
+                var qual = useExtendsList ? "extends" : "implements";
+                this.declFile.Write(" " + qual + " ");
+                var basesLen = bases.nonSeparatorCount();
+                for (var i = 0; i < basesLen; i++) {
+                    if (i > 0) {
+                        this.declFile.Write(", ");
+                    }
+                    var base = bases.nonSeparatorAt(i);
+                    var baseType = this.semanticInfoChain.getSymbolForAST(base);
+                    this.emitTypeSignature(base, baseType);
+                }
+            }
+        };
+
+        DeclarationEmitter.prototype.emitAccessorDeclarationComments = function (funcDecl) {
+            if (this.emitOptions.compilationSettings().removeComments()) {
+                return;
+            }
+
+            var start = new Date().getTime();
+            var accessors = TypeScript.PullHelpers.getGetterAndSetterFunction(funcDecl, this.semanticInfoChain);
+            TypeScript.declarationEmitGetAccessorFunctionTime += new Date().getTime();
+
+            var comments = [];
+            if (accessors.getter) {
+                comments = comments.concat(TypeScript.ASTHelpers.docComments(accessors.getter));
+            }
+            if (accessors.setter) {
+                comments = comments.concat(TypeScript.ASTHelpers.docComments(accessors.setter));
+            }
+
+            this.writeDeclarationComments(comments);
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForGetAccessor = function (funcDecl) {
+            this.emitMemberAccessorDeclaration(funcDecl, funcDecl.modifiers, funcDecl.propertyName);
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForSetAccessor = function (funcDecl) {
+            this.emitMemberAccessorDeclaration(funcDecl, funcDecl.modifiers, funcDecl.propertyName);
+        };
+
+        DeclarationEmitter.prototype.emitMemberAccessorDeclaration = function (funcDecl, modifiers, name) {
+            var start = new Date().getTime();
+            var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(funcDecl, this.semanticInfoChain);
+            TypeScript.declarationEmitGetAccessorFunctionTime += new Date().getTime();
+
+            if (funcDecl.kind() === 140 /* SetAccessor */ && accessorSymbol.getGetter()) {
+                return;
+            }
+
+            var isPrivate = TypeScript.hasModifier(modifiers, 2 /* Private */);
+            this.emitAccessorDeclarationComments(funcDecl);
+            this.declFile.Write(this.getIndentString());
+            this.emitClassElementModifiers(modifiers);
+            this.declFile.Write(name.text());
+            if (!isPrivate) {
+                this.declFile.Write(" : ");
+                var type = accessorSymbol.type;
+                this.emitTypeSignature(funcDecl, type);
+            }
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitClassMembersFromConstructorDefinition = function (funcDecl) {
+            var argsLen = funcDecl.callSignature.parameterList.parameters.nonSeparatorCount();
+            if (TypeScript.lastParameterIsRest(funcDecl.callSignature.parameterList)) {
+                argsLen--;
+            }
+
+            for (var i = 0; i < argsLen; i++) {
+                var parameter = funcDecl.callSignature.parameterList.parameters.nonSeparatorAt(i);
+                var parameterDecl = this.semanticInfoChain.getDeclForAST(parameter);
+                if (TypeScript.hasFlag(parameterDecl.flags, 8388608 /* PropertyParameter */)) {
+                    var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+                    this.emitDeclarationComments(parameter);
+                    this.declFile.Write(this.getIndentString());
+                    this.emitClassElementModifiers(parameter.modifiers);
+                    this.declFile.Write(parameter.identifier.text());
+
+                    if (!TypeScript.hasModifier(parameter.modifiers, 2 /* Private */)) {
+                        this.emitTypeOfVariableDeclaratorOrParameter(parameter);
+                    }
+                    this.declFile.WriteLine(";");
+                }
+            }
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForClassDeclaration = function (classDecl) {
+            if (!this.canEmitDeclarations(classDecl)) {
+                return;
+            }
+
+            var className = classDecl.identifier.text();
+            this.emitDeclarationComments(classDecl);
+            var classPullDecl = this.semanticInfoChain.getDeclForAST(classDecl);
+            this.emitDeclFlags(classDecl, "class");
+            this.declFile.Write(className);
+
+            this.emitTypeParameters(classDecl.typeParameterList);
+            this.emitHeritageClauses(classDecl.heritageClauses);
+            this.declFile.WriteLine(" {");
+
+            this.indenter.increaseIndent();
+            var constructorDecl = TypeScript.getLastConstructor(classDecl);
+            if (constructorDecl) {
+                this.emitClassMembersFromConstructorDefinition(constructorDecl);
+            }
+
+            this.emitDeclarationsForList(classDecl.classElements);
+
+            this.indenter.decreaseIndent();
+
+            this.emitIndent();
+            this.declFile.WriteLine("}");
+        };
+
+        DeclarationEmitter.prototype.emitHeritageClauses = function (clauses) {
+            if (clauses) {
+                for (var i = 0, n = clauses.childCount(); i < n; i++) {
+                    this.emitHeritageClause(clauses.childAt(i));
+                }
+            }
+        };
+
+        DeclarationEmitter.prototype.emitHeritageClause = function (clause) {
+            this.emitBaseList(clause.typeNames, clause.kind() === 230 /* ExtendsHeritageClause */);
+        };
+
+        DeclarationEmitter.getEnclosingContainer = function (ast) {
+            var enclosingModule = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(ast);
+            if (TypeScript.ASTHelpers.isAnyNameOfModule(enclosingModule, ast)) {
+                ast = enclosingModule;
+            }
+
+            ast = ast.parent;
+            while (ast) {
+                if (ast.kind() === 131 /* ClassDeclaration */ || ast.kind() === 128 /* InterfaceDeclaration */ || ast.kind() === 130 /* ModuleDeclaration */ || ast.kind() === 120 /* SourceUnit */) {
+                    return ast;
+                }
+
+                ast = ast.parent;
+            }
+
+            return null;
+        };
+
+        DeclarationEmitter.prototype.emitTypeParameters = function (typeParams, funcSignature) {
+            if (!typeParams || !typeParams.typeParameters.nonSeparatorCount()) {
+                return;
+            }
+
+            this.declFile.Write("<");
+            var containerAst = DeclarationEmitter.getEnclosingContainer(typeParams);
+
+            var start = new Date().getTime();
+            var containerDecl = this.semanticInfoChain.getDeclForAST(containerAst);
+            var containerSymbol = containerDecl.getSymbol();
+            TypeScript.declarationEmitGetTypeParameterSymbolTime += new Date().getTime() - start;
+
+            var typars;
+            if (funcSignature) {
+                typars = funcSignature.getTypeParameters();
+            } else {
+                typars = containerSymbol.getTypeArgumentsOrTypeParameters();
+            }
+
+            for (var i = 0; i < typars.length; i++) {
+                if (i) {
+                    this.declFile.Write(", ");
+                }
+
+                var memberName = typars[i].getScopedNameEx(containerSymbol, false, true);
+                this.emitTypeNamesMember(memberName);
+            }
+
+            this.declFile.Write(">");
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForInterfaceDeclaration = function (interfaceDecl) {
+            if (!this.canEmitDeclarations(interfaceDecl)) {
+                return;
+            }
+
+            var interfaceName = interfaceDecl.identifier.text();
+            this.emitDeclarationComments(interfaceDecl);
+            var interfacePullDecl = this.semanticInfoChain.getDeclForAST(interfaceDecl);
+            this.emitDeclFlags(interfaceDecl, "interface");
+            this.declFile.Write(interfaceName);
+
+            this.emitTypeParameters(interfaceDecl.typeParameterList);
+            this.emitHeritageClauses(interfaceDecl.heritageClauses);
+            this.declFile.WriteLine(" {");
+
+            this.indenter.increaseIndent();
+
+            this.emitSeparatedList(interfaceDecl.body.typeMembers);
+
+            this.indenter.decreaseIndent();
+
+            this.emitIndent();
+            this.declFile.WriteLine("}");
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForImportDeclaration = function (importDeclAST) {
+            var importDecl = this.semanticInfoChain.getDeclForAST(importDeclAST);
+            var importSymbol = importDecl.getSymbol();
+            var isExportedImportDecl = TypeScript.hasModifier(importDeclAST.modifiers, 1 /* Exported */);
+
+            if (isExportedImportDecl || importSymbol.typeUsedExternally() || TypeScript.PullContainerSymbol.usedAsSymbol(importSymbol.getContainer(), importSymbol)) {
+                this.emitDeclarationComments(importDeclAST);
+                this.emitIndent();
+                if (isExportedImportDecl) {
+                    this.declFile.Write("export ");
+                }
+                this.declFile.Write("import ");
+                this.declFile.Write(importDeclAST.identifier.text() + " = ");
+                if (importDeclAST.moduleReference.kind() === 245 /* ExternalModuleReference */) {
+                    this.declFile.WriteLine("require(" + importDeclAST.moduleReference.stringLiteral.text() + ");");
+                } else {
+                    this.declFile.WriteLine(TypeScript.ASTHelpers.getNameOfIdenfierOrQualifiedName(importDeclAST.moduleReference.moduleName) + ";");
+                }
+            }
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForEnumDeclaration = function (moduleDecl) {
+            if (!this.canEmitDeclarations(moduleDecl)) {
+                return;
+            }
+
+            this.emitDeclarationComments(moduleDecl);
+            var modulePullDecl = this.semanticInfoChain.getDeclForAST(moduleDecl);
+            this.emitDeclFlags(moduleDecl, "enum");
+            this.declFile.WriteLine(moduleDecl.identifier.text() + " {");
+
+            this.indenter.increaseIndent();
+            var membersLen = moduleDecl.enumElements.nonSeparatorCount();
+            for (var j = 0; j < membersLen; j++) {
+                var memberDecl = moduleDecl.enumElements.nonSeparatorAt(j);
+                var enumElement = memberDecl;
+                var enumElementDecl = this.semanticInfoChain.getDeclForAST(enumElement);
+                this.emitDeclarationComments(enumElement);
+                this.emitIndent();
+                this.declFile.Write(enumElement.propertyName.text());
+                if (enumElementDecl.constantValue !== null) {
+                    this.declFile.Write(" = " + enumElementDecl.constantValue);
+                }
+                this.declFile.WriteLine(",");
+            }
+            this.indenter.decreaseIndent();
+
+            this.emitIndent();
+            this.declFile.WriteLine("}");
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForModuleDeclaration = function (moduleDecl) {
+            var name = moduleDecl.stringLiteral || TypeScript.ArrayUtilities.first(TypeScript.ASTHelpers.getModuleNames(moduleDecl.name));
+            if (!this.canEmitDeclarations(name)) {
+                return;
+            }
+
+            this.emitDeclarationComments(moduleDecl);
+            this.emitDeclFlags(name, "module");
+
+            if (moduleDecl.stringLiteral) {
+                this.declFile.Write(moduleDecl.stringLiteral.text());
+            } else {
+                this.declFile.Write(TypeScript.ASTHelpers.getNameOfIdenfierOrQualifiedName(moduleDecl.name));
+            }
+
+            this.declFile.WriteLine(" {");
+            this.indenter.increaseIndent();
+
+            this.emitDeclarationsForList(moduleDecl.moduleElements);
+
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+            this.declFile.WriteLine("}");
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForExportAssignment = function (ast) {
+            this.emitIndent();
+            this.declFile.Write("export = ");
+            this.declFile.Write(ast.identifier.text());
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.resolveScriptReference = function (document, reference) {
+            if (!this.emitOptions.compilationSettings().noResolve() || TypeScript.isRooted(reference)) {
+                return reference;
+            }
+
+            var documentDir = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(TypeScript.getRootFilePath(document.fileName)));
+            var resolvedReferencePath = this.emitOptions.resolvePath(documentDir + reference);
+            return resolvedReferencePath;
+        };
+
+        DeclarationEmitter.prototype.emitReferencePaths = function (sourceUnit) {
+            if (this.emittedReferencePaths) {
+                return;
+            }
+
+            var documents = [];
+            if (this.document.emitToOwnOutputFile()) {
+                var scriptReferences = this.document.referencedFiles;
+                var addedGlobalDocument = false;
+                for (var j = 0; j < scriptReferences.length; j++) {
+                    var currentReference = this.resolveScriptReference(this.document, scriptReferences[j]);
+                    var document = this.compiler.getDocument(currentReference);
+
+                    if (document && (document.emitToOwnOutputFile() || document.isDeclareFile() || !addedGlobalDocument)) {
+                        documents = documents.concat(document);
+
+                        if (!document.isDeclareFile() && document.isExternalModule()) {
+                            addedGlobalDocument = true;
+                        }
+                    }
+                }
+            } else {
+                var fileNames = this.compiler.fileNames();
+                for (var i = 0; i < fileNames.length; i++) {
+                    var doc = this.compiler.getDocument(fileNames[i]);
+                    if (!doc.isDeclareFile() && !doc.isExternalModule()) {
+                        var scriptReferences = doc.referencedFiles;
+                        for (var j = 0; j < scriptReferences.length; j++) {
+                            var currentReference = this.resolveScriptReference(doc, scriptReferences[j]);
+                            var document = this.compiler.getDocument(currentReference);
+
+                            if (document && (document.isDeclareFile() || document.isExternalModule())) {
+                                for (var k = 0; k < documents.length; k++) {
+                                    if (documents[k] === document) {
+                                        break;
+                                    }
+                                }
+
+                                if (k === documents.length) {
+                                    documents = documents.concat(document);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            var emittingFilePath = documents.length ? TypeScript.getRootFilePath(this.emittingFileName) : null;
+            for (var i = 0; i < documents.length; i++) {
+                var document = documents[i];
+                var declFileName;
+                if (document.isDeclareFile()) {
+                    declFileName = document.fileName;
+                } else {
+                    declFileName = this.compiler.mapOutputFileName(document, this.emitOptions, TypeScript.TypeScriptCompiler.mapToDTSFileName);
+                }
+
+                declFileName = TypeScript.getRelativePathToFixedPath(emittingFilePath, declFileName, false);
+                this.declFile.WriteLine('/// <reference path="' + declFileName + '" />');
+            }
+
+            this.emittedReferencePaths = true;
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForSourceUnit = function (sourceUnit) {
+            this.emitReferencePaths(sourceUnit);
+            this.emitDeclarationsForList(sourceUnit.moduleElements);
+        };
+        return DeclarationEmitter;
+    })();
+    TypeScript.DeclarationEmitter = DeclarationEmitter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var BloomFilter = (function () {
+        function BloomFilter(expectedCount) {
+            var m = Math.max(1, BloomFilter.computeM(expectedCount));
+            var k = Math.max(1, BloomFilter.computeK(expectedCount));
+            ;
+
+            var sizeInEvenBytes = (m + 7) & ~7;
+
+            this.bitArray = [];
+            for (var i = 0, len = sizeInEvenBytes; i < len; i++) {
+                this.bitArray[i] = false;
+            }
+            this.hashFunctionCount = k;
+        }
+        BloomFilter.computeM = function (expectedCount) {
+            var p = BloomFilter.falsePositiveProbability;
+            var n = expectedCount;
+
+            var numerator = n * Math.log(p);
+            var denominator = Math.log(1.0 / Math.pow(2.0, Math.log(2.0)));
+            return Math.ceil(numerator / denominator);
+        };
+
+        BloomFilter.computeK = function (expectedCount) {
+            var n = expectedCount;
+            var m = BloomFilter.computeM(expectedCount);
+
+            var temp = Math.log(2.0) * m / n;
+            return Math.round(temp);
+        };
+
+        BloomFilter.prototype.computeHash = function (key, seed) {
+            return TypeScript.Hash.computeMurmur2StringHashCode(key, seed);
+        };
+
+        BloomFilter.prototype.addKeys = function (keys) {
+            for (var name in keys) {
+                if (keys[name]) {
+                    this.add(name);
+                }
+            }
+        };
+
+        BloomFilter.prototype.add = function (value) {
+            for (var i = 0; i < this.hashFunctionCount; i++) {
+                var hash = this.computeHash(value, i);
+                hash = hash % this.bitArray.length;
+                this.bitArray[Math.abs(hash)] = true;
+            }
+        };
+
+        BloomFilter.prototype.probablyContains = function (value) {
+            for (var i = 0; i < this.hashFunctionCount; i++) {
+                var hash = this.computeHash(value, i);
+                hash = hash % this.bitArray.length;
+                if (!this.bitArray[Math.abs(hash)]) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        BloomFilter.prototype.isEquivalent = function (filter) {
+            return BloomFilter.isEquivalent(this.bitArray, filter.bitArray) && this.hashFunctionCount === filter.hashFunctionCount;
+        };
+
+        BloomFilter.isEquivalent = function (array1, array2) {
+            if (array1.length !== array2.length) {
+                return false;
+            }
+
+            for (var i = 0; i < array1.length; i++) {
+                if (array1[i] !== array2[i]) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+        BloomFilter.falsePositiveProbability = 0.0001;
+        return BloomFilter;
+    })();
+    TypeScript.BloomFilter = BloomFilter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var IdentifierWalker = (function (_super) {
+        __extends(IdentifierWalker, _super);
+        function IdentifierWalker(list) {
+            _super.call(this);
+            this.list = list;
+        }
+        IdentifierWalker.prototype.visitToken = function (token) {
+            this.list[token.text()] = true;
+        };
+        return IdentifierWalker;
+    })(TypeScript.SyntaxWalker);
+    TypeScript.IdentifierWalker = IdentifierWalker;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var CompilationSettings = (function () {
+        function CompilationSettings() {
+            this.propagateEnumConstants = false;
+            this.removeComments = false;
+            this.watch = false;
+            this.noResolve = false;
+            this.allowAutomaticSemicolonInsertion = true;
+            this.noImplicitAny = false;
+            this.noLib = false;
+            this.codeGenTarget = 0 /* EcmaScript3 */;
+            this.moduleGenTarget = 0 /* Unspecified */;
+            this.outFileOption = "";
+            this.outDirOption = "";
+            this.mapSourceFiles = false;
+            this.mapRoot = "";
+            this.sourceRoot = "";
+            this.generateDeclarationFiles = false;
+            this.useCaseSensitiveFileResolution = false;
+            this.gatherDiagnostics = false;
+            this.codepage = null;
+            this.createFileLog = false;
+        }
+        return CompilationSettings;
+    })();
+    TypeScript.CompilationSettings = CompilationSettings;
+
+    var ImmutableCompilationSettings = (function () {
+        function ImmutableCompilationSettings(propagateEnumConstants, removeComments, watch, noResolve, allowAutomaticSemicolonInsertion, noImplicitAny, noLib, codeGenTarget, moduleGenTarget, outFileOption, outDirOption, mapSourceFiles, mapRoot, sourceRoot, generateDeclarationFiles, useCaseSensitiveFileResolution, gatherDiagnostics, codepage, createFileLog) {
+            this._propagateEnumConstants = propagateEnumConstants;
+            this._removeComments = removeComments;
+            this._watch = watch;
+            this._noResolve = noResolve;
+            this._allowAutomaticSemicolonInsertion = allowAutomaticSemicolonInsertion;
+            this._noImplicitAny = noImplicitAny;
+            this._noLib = noLib;
+            this._codeGenTarget = codeGenTarget;
+            this._moduleGenTarget = moduleGenTarget;
+            this._outFileOption = outFileOption;
+            this._outDirOption = outDirOption;
+            this._mapSourceFiles = mapSourceFiles;
+            this._mapRoot = mapRoot;
+            this._sourceRoot = sourceRoot;
+            this._generateDeclarationFiles = generateDeclarationFiles;
+            this._useCaseSensitiveFileResolution = useCaseSensitiveFileResolution;
+            this._gatherDiagnostics = gatherDiagnostics;
+            this._codepage = codepage;
+            this._createFileLog = createFileLog;
+        }
+        ImmutableCompilationSettings.prototype.propagateEnumConstants = function () {
+            return this._propagateEnumConstants;
+        };
+        ImmutableCompilationSettings.prototype.removeComments = function () {
+            return this._removeComments;
+        };
+        ImmutableCompilationSettings.prototype.watch = function () {
+            return this._watch;
+        };
+        ImmutableCompilationSettings.prototype.noResolve = function () {
+            return this._noResolve;
+        };
+        ImmutableCompilationSettings.prototype.allowAutomaticSemicolonInsertion = function () {
+            return this._allowAutomaticSemicolonInsertion;
+        };
+        ImmutableCompilationSettings.prototype.noImplicitAny = function () {
+            return this._noImplicitAny;
+        };
+        ImmutableCompilationSettings.prototype.noLib = function () {
+            return this._noLib;
+        };
+        ImmutableCompilationSettings.prototype.codeGenTarget = function () {
+            return this._codeGenTarget;
+        };
+        ImmutableCompilationSettings.prototype.moduleGenTarget = function () {
+            return this._moduleGenTarget;
+        };
+        ImmutableCompilationSettings.prototype.outFileOption = function () {
+            return this._outFileOption;
+        };
+        ImmutableCompilationSettings.prototype.outDirOption = function () {
+            return this._outDirOption;
+        };
+        ImmutableCompilationSettings.prototype.mapSourceFiles = function () {
+            return this._mapSourceFiles;
+        };
+        ImmutableCompilationSettings.prototype.mapRoot = function () {
+            return this._mapRoot;
+        };
+        ImmutableCompilationSettings.prototype.sourceRoot = function () {
+            return this._sourceRoot;
+        };
+        ImmutableCompilationSettings.prototype.generateDeclarationFiles = function () {
+            return this._generateDeclarationFiles;
+        };
+        ImmutableCompilationSettings.prototype.useCaseSensitiveFileResolution = function () {
+            return this._useCaseSensitiveFileResolution;
+        };
+        ImmutableCompilationSettings.prototype.gatherDiagnostics = function () {
+            return this._gatherDiagnostics;
+        };
+        ImmutableCompilationSettings.prototype.codepage = function () {
+            return this._codepage;
+        };
+        ImmutableCompilationSettings.prototype.createFileLog = function () {
+            return this._createFileLog;
+        };
+
+        ImmutableCompilationSettings.defaultSettings = function () {
+            if (!ImmutableCompilationSettings._defaultSettings) {
+                ImmutableCompilationSettings._defaultSettings = ImmutableCompilationSettings.fromCompilationSettings(new CompilationSettings());
+            }
+
+            return ImmutableCompilationSettings._defaultSettings;
+        };
+
+        ImmutableCompilationSettings.fromCompilationSettings = function (settings) {
+            return new ImmutableCompilationSettings(settings.propagateEnumConstants, settings.removeComments, settings.watch, settings.noResolve, settings.allowAutomaticSemicolonInsertion, settings.noImplicitAny, settings.noLib, settings.codeGenTarget, settings.moduleGenTarget, settings.outFileOption, settings.outDirOption, settings.mapSourceFiles, settings.mapRoot, settings.sourceRoot, settings.generateDeclarationFiles, settings.useCaseSensitiveFileResolution, settings.gatherDiagnostics, settings.codepage, settings.createFileLog);
+        };
+
+        ImmutableCompilationSettings.prototype.toCompilationSettings = function () {
+            var result = new CompilationSettings();
+
+            var thisAsIndexable = this;
+            var resultAsIndexable = result;
+            for (var name in this) {
+                if (this.hasOwnProperty(name) && TypeScript.StringUtilities.startsWith(name, "_")) {
+                    resultAsIndexable[name.substr(1)] = thisAsIndexable[name];
+                }
+            }
+
+            return result;
+        };
+        return ImmutableCompilationSettings;
+    })();
+    TypeScript.ImmutableCompilationSettings = ImmutableCompilationSettings;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (PullElementFlags) {
+        PullElementFlags[PullElementFlags["None"] = 0] = "None";
+        PullElementFlags[PullElementFlags["Exported"] = 1] = "Exported";
+        PullElementFlags[PullElementFlags["Private"] = 1 << 1] = "Private";
+        PullElementFlags[PullElementFlags["Public"] = 1 << 2] = "Public";
+        PullElementFlags[PullElementFlags["Ambient"] = 1 << 3] = "Ambient";
+        PullElementFlags[PullElementFlags["Static"] = 1 << 4] = "Static";
+        PullElementFlags[PullElementFlags["Optional"] = 1 << 7] = "Optional";
+        PullElementFlags[PullElementFlags["Signature"] = 1 << 11] = "Signature";
+        PullElementFlags[PullElementFlags["Enum"] = 1 << 12] = "Enum";
+        PullElementFlags[PullElementFlags["ArrowFunction"] = 1 << 13] = "ArrowFunction";
+
+        PullElementFlags[PullElementFlags["ClassConstructorVariable"] = 1 << 14] = "ClassConstructorVariable";
+        PullElementFlags[PullElementFlags["InitializedModule"] = 1 << 15] = "InitializedModule";
+        PullElementFlags[PullElementFlags["InitializedDynamicModule"] = 1 << 16] = "InitializedDynamicModule";
+
+        PullElementFlags[PullElementFlags["MustCaptureThis"] = 1 << 18] = "MustCaptureThis";
+
+        PullElementFlags[PullElementFlags["DeclaredInAWithBlock"] = 1 << 21] = "DeclaredInAWithBlock";
+
+        PullElementFlags[PullElementFlags["HasReturnStatement"] = 1 << 22] = "HasReturnStatement";
+
+        PullElementFlags[PullElementFlags["PropertyParameter"] = 1 << 23] = "PropertyParameter";
+
+        PullElementFlags[PullElementFlags["IsAnnotatedWithAny"] = 1 << 24] = "IsAnnotatedWithAny";
+
+        PullElementFlags[PullElementFlags["HasDefaultArgs"] = 1 << 25] = "HasDefaultArgs";
+
+        PullElementFlags[PullElementFlags["ConstructorParameter"] = 1 << 26] = "ConstructorParameter";
+
+        PullElementFlags[PullElementFlags["ImplicitVariable"] = PullElementFlags.ClassConstructorVariable | PullElementFlags.InitializedModule | PullElementFlags.InitializedDynamicModule | PullElementFlags.Enum] = "ImplicitVariable";
+        PullElementFlags[PullElementFlags["SomeInitializedModule"] = PullElementFlags.InitializedModule | PullElementFlags.InitializedDynamicModule | PullElementFlags.Enum] = "SomeInitializedModule";
+    })(TypeScript.PullElementFlags || (TypeScript.PullElementFlags = {}));
+    var PullElementFlags = TypeScript.PullElementFlags;
+
+    function hasModifier(modifiers, flag) {
+        for (var i = 0, n = modifiers.length; i < n; i++) {
+            if (TypeScript.hasFlag(modifiers[i], flag)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+    TypeScript.hasModifier = hasModifier;
+
+    (function (PullElementKind) {
+        PullElementKind[PullElementKind["None"] = 0] = "None";
+        PullElementKind[PullElementKind["Global"] = 0] = "Global";
+
+        PullElementKind[PullElementKind["Script"] = 1 << 0] = "Script";
+        PullElementKind[PullElementKind["Primitive"] = 1 << 1] = "Primitive";
+
+        PullElementKind[PullElementKind["Container"] = 1 << 2] = "Container";
+        PullElementKind[PullElementKind["Class"] = 1 << 3] = "Class";
+        PullElementKind[PullElementKind["Interface"] = 1 << 4] = "Interface";
+        PullElementKind[PullElementKind["DynamicModule"] = 1 << 5] = "DynamicModule";
+        PullElementKind[PullElementKind["Enum"] = 1 << 6] = "Enum";
+        PullElementKind[PullElementKind["TypeAlias"] = 1 << 7] = "TypeAlias";
+        PullElementKind[PullElementKind["ObjectLiteral"] = 1 << 8] = "ObjectLiteral";
+
+        PullElementKind[PullElementKind["Variable"] = 1 << 9] = "Variable";
+        PullElementKind[PullElementKind["CatchVariable"] = 1 << 10] = "CatchVariable";
+        PullElementKind[PullElementKind["Parameter"] = 1 << 11] = "Parameter";
+        PullElementKind[PullElementKind["Property"] = 1 << 12] = "Property";
+        PullElementKind[PullElementKind["TypeParameter"] = 1 << 13] = "TypeParameter";
+
+        PullElementKind[PullElementKind["Function"] = 1 << 14] = "Function";
+        PullElementKind[PullElementKind["ConstructorMethod"] = 1 << 15] = "ConstructorMethod";
+        PullElementKind[PullElementKind["Method"] = 1 << 16] = "Method";
+        PullElementKind[PullElementKind["FunctionExpression"] = 1 << 17] = "FunctionExpression";
+
+        PullElementKind[PullElementKind["GetAccessor"] = 1 << 18] = "GetAccessor";
+        PullElementKind[PullElementKind["SetAccessor"] = 1 << 19] = "SetAccessor";
+
+        PullElementKind[PullElementKind["CallSignature"] = 1 << 20] = "CallSignature";
+        PullElementKind[PullElementKind["ConstructSignature"] = 1 << 21] = "ConstructSignature";
+        PullElementKind[PullElementKind["IndexSignature"] = 1 << 22] = "IndexSignature";
+
+        PullElementKind[PullElementKind["ObjectType"] = 1 << 23] = "ObjectType";
+        PullElementKind[PullElementKind["FunctionType"] = 1 << 24] = "FunctionType";
+        PullElementKind[PullElementKind["ConstructorType"] = 1 << 25] = "ConstructorType";
+
+        PullElementKind[PullElementKind["EnumMember"] = 1 << 26] = "EnumMember";
+
+        PullElementKind[PullElementKind["WithBlock"] = 1 << 27] = "WithBlock";
+        PullElementKind[PullElementKind["CatchBlock"] = 1 << 28] = "CatchBlock";
+
+        PullElementKind[PullElementKind["All"] = PullElementKind.Script | PullElementKind.Global | PullElementKind.Primitive | PullElementKind.Container | PullElementKind.Class | PullElementKind.Interface | PullElementKind.DynamicModule | PullElementKind.Enum | PullElementKind.TypeAlias | PullElementKind.ObjectLiteral | PullElementKind.Variable | PullElementKind.Parameter | PullElementKind.Property | PullElementKind.TypeParameter | PullElementKind.Function | PullElementKind.ConstructorMethod | PullElementKind.Method | PullElementKind.FunctionExpression | PullElementKind.GetAccessor | PullElementKind.SetAccessor | PullElementKind.CallSignature | PullElementKind.ConstructSignature | PullElementKind.IndexSignature | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType | PullElementKind.EnumMember | PullElementKind.WithBlock | PullElementKind.CatchBlock] = "All";
+
+        PullElementKind[PullElementKind["SomeFunction"] = PullElementKind.Function | PullElementKind.ConstructorMethod | PullElementKind.Method | PullElementKind.FunctionExpression | PullElementKind.GetAccessor | PullElementKind.SetAccessor] = "SomeFunction";
+
+        PullElementKind[PullElementKind["SomeValue"] = PullElementKind.Variable | PullElementKind.Parameter | PullElementKind.Property | PullElementKind.EnumMember | PullElementKind.SomeFunction] = "SomeValue";
+
+        PullElementKind[PullElementKind["SomeType"] = PullElementKind.Script | PullElementKind.Global | PullElementKind.Primitive | PullElementKind.Class | PullElementKind.Interface | PullElementKind.Enum | PullElementKind.ObjectLiteral | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType | PullElementKind.TypeParameter] = "SomeType";
+
+        PullElementKind[PullElementKind["AcceptableAlias"] = PullElementKind.Variable | PullElementKind.SomeFunction | PullElementKind.Class | PullElementKind.Interface | PullElementKind.Enum | PullElementKind.Container | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType] = "AcceptableAlias";
+
+        PullElementKind[PullElementKind["SomeContainer"] = PullElementKind.Container | PullElementKind.DynamicModule | PullElementKind.TypeAlias] = "SomeContainer";
+
+        PullElementKind[PullElementKind["SomeSignature"] = PullElementKind.CallSignature | PullElementKind.ConstructSignature | PullElementKind.IndexSignature] = "SomeSignature";
+
+        PullElementKind[PullElementKind["SomeTypeReference"] = PullElementKind.Interface | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType] = "SomeTypeReference";
+
+        PullElementKind[PullElementKind["SomeInstantiatableType"] = PullElementKind.Class | PullElementKind.Interface | PullElementKind.TypeParameter] = "SomeInstantiatableType";
+    })(TypeScript.PullElementKind || (TypeScript.PullElementKind = {}));
+    var PullElementKind = TypeScript.PullElementKind;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var pullDeclID = 0;
+    var sentinelEmptyPullDeclArray = [];
+
+    var PullDecl = (function () {
+        function PullDecl(declName, displayName, kind, declFlags, semanticInfoChain) {
+            this.declID = pullDeclID++;
+            this.flags = 0 /* None */;
+            this.declGroups = null;
+            this.childDecls = null;
+            this.typeParameters = null;
+            this.synthesizedValDecl = null;
+            this.containerDecl = null;
+            this.childDeclTypeCache = null;
+            this.childDeclValueCache = null;
+            this.childDeclNamespaceCache = null;
+            this.childDeclTypeParameterCache = null;
+            this.name = declName;
+            this.kind = kind;
+            this.flags = declFlags;
+            this.semanticInfoChain = semanticInfoChain;
+
+            if (displayName !== this.name) {
+                this.declDisplayName = displayName;
+            }
+        }
+        PullDecl.prototype.fileName = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        PullDecl.prototype.getParentPath = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        PullDecl.prototype.getParentDecl = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        PullDecl.prototype.isExternalModule = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        PullDecl.prototype.getEnclosingDecl = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        PullDecl.prototype._getEnclosingDeclFromParentDecl = function () {
+            var decl = this;
+            while (decl) {
+                switch (decl.kind) {
+                    default:
+                        return decl;
+                    case 512 /* Variable */:
+                    case 8192 /* TypeParameter */:
+                    case 2048 /* Parameter */:
+                    case 128 /* TypeAlias */:
+                    case 67108864 /* EnumMember */:
+                }
+
+                decl = decl.getParentDecl();
+            }
+
+            TypeScript.Debug.fail();
+        };
+
+        PullDecl.prototype.getDisplayName = function () {
+            return this.declDisplayName === undefined ? this.name : this.declDisplayName;
+        };
+
+        PullDecl.prototype.setSymbol = function (symbol) {
+            this.semanticInfoChain.setSymbolForDecl(this, symbol);
+        };
+
+        PullDecl.prototype.ensureSymbolIsBound = function () {
+            if (!this.hasBeenBound() && this.kind !== 1 /* Script */) {
+                var binder = this.semanticInfoChain.getBinder();
+                binder.bindDeclToPullSymbol(this);
+            }
+        };
+
+        PullDecl.prototype.getSymbol = function () {
+            if (this.kind === 1 /* Script */) {
+                return null;
+            }
+
+            this.ensureSymbolIsBound();
+
+            return this.semanticInfoChain.getSymbolForDecl(this);
+        };
+
+        PullDecl.prototype.hasSymbol = function () {
+            var symbol = this.semanticInfoChain.getSymbolForDecl(this);
+            return !!symbol;
+        };
+
+        PullDecl.prototype.setSignatureSymbol = function (signatureSymbol) {
+            this.semanticInfoChain.setSignatureSymbolForDecl(this, signatureSymbol);
+        };
+
+        PullDecl.prototype.getSignatureSymbol = function () {
+            this.ensureSymbolIsBound();
+            return this.semanticInfoChain.getSignatureSymbolForDecl(this);
+        };
+
+        PullDecl.prototype.hasSignatureSymbol = function () {
+            var signatureSymbol = this.semanticInfoChain.getSignatureSymbolForDecl(this);
+            return !!signatureSymbol;
+        };
+
+        PullDecl.prototype.setFlags = function (flags) {
+            this.flags = flags;
+        };
+
+        PullDecl.prototype.setFlag = function (flags) {
+            this.flags |= flags;
+        };
+
+        PullDecl.prototype.setValueDecl = function (valDecl) {
+            this.synthesizedValDecl = valDecl;
+            valDecl.containerDecl = this;
+        };
+
+        PullDecl.prototype.getValueDecl = function () {
+            return this.synthesizedValDecl;
+        };
+
+        PullDecl.prototype.getContainerDecl = function () {
+            return this.containerDecl;
+        };
+
+        PullDecl.prototype.getChildDeclCache = function (declKind) {
+            if (declKind === 8192 /* TypeParameter */) {
+                if (!this.childDeclTypeParameterCache) {
+                    this.childDeclTypeParameterCache = TypeScript.createIntrinsicsObject();
+                }
+
+                return this.childDeclTypeParameterCache;
+            } else if (TypeScript.hasFlag(declKind, 164 /* SomeContainer */)) {
+                if (!this.childDeclNamespaceCache) {
+                    this.childDeclNamespaceCache = TypeScript.createIntrinsicsObject();
+                }
+
+                return this.childDeclNamespaceCache;
+            } else if (TypeScript.hasFlag(declKind, 58728795 /* SomeType */)) {
+                if (!this.childDeclTypeCache) {
+                    this.childDeclTypeCache = TypeScript.createIntrinsicsObject();
+                }
+
+                return this.childDeclTypeCache;
+            } else {
+                if (!this.childDeclValueCache) {
+                    this.childDeclValueCache = TypeScript.createIntrinsicsObject();
+                }
+
+                return this.childDeclValueCache;
+            }
+        };
+
+        PullDecl.prototype.addChildDecl = function (childDecl) {
+            if (childDecl.kind === 8192 /* TypeParameter */) {
+                if (!this.typeParameters) {
+                    this.typeParameters = [];
+                }
+                this.typeParameters[this.typeParameters.length] = childDecl;
+            } else {
+                if (!this.childDecls) {
+                    this.childDecls = [];
+                }
+                this.childDecls[this.childDecls.length] = childDecl;
+            }
+
+            var declName = childDecl.name;
+
+            if (!(childDecl.kind & 7340032 /* SomeSignature */)) {
+                var cache = this.getChildDeclCache(childDecl.kind);
+                var childrenOfName = cache[declName];
+                if (!childrenOfName) {
+                    childrenOfName = [];
+                }
+
+                childrenOfName.push(childDecl);
+                cache[declName] = childrenOfName;
+            }
+        };
+
+        PullDecl.prototype.searchChildDecls = function (declName, searchKind) {
+            var cacheVal = null;
+
+            if (searchKind & 58728795 /* SomeType */) {
+                cacheVal = this.childDeclTypeCache ? this.childDeclTypeCache[declName] : null;
+            } else if (searchKind & 164 /* SomeContainer */) {
+                cacheVal = this.childDeclNamespaceCache ? this.childDeclNamespaceCache[declName] : null;
+            } else {
+                cacheVal = this.childDeclValueCache ? this.childDeclValueCache[declName] : null;
+            }
+
+            if (cacheVal) {
+                return cacheVal;
+            } else {
+                if (searchKind & 58728795 /* SomeType */) {
+                    cacheVal = this.childDeclTypeParameterCache ? this.childDeclTypeParameterCache[declName] : null;
+
+                    if (cacheVal) {
+                        return cacheVal;
+                    }
+                }
+
+                return sentinelEmptyPullDeclArray;
+            }
+        };
+
+        PullDecl.prototype.getChildDecls = function () {
+            return this.childDecls || sentinelEmptyPullDeclArray;
+        };
+
+        PullDecl.prototype.getTypeParameters = function () {
+            return this.typeParameters || sentinelEmptyPullDeclArray;
+        };
+
+        PullDecl.prototype.addVariableDeclToGroup = function (decl) {
+            if (!this.declGroups) {
+                this.declGroups = TypeScript.createIntrinsicsObject();
+            }
+
+            var declGroup = this.declGroups[decl.name];
+            if (declGroup) {
+                declGroup.addDecl(decl);
+            } else {
+                declGroup = new PullDeclGroup(decl.name);
+                declGroup.addDecl(decl);
+                this.declGroups[decl.name] = declGroup;
+            }
+        };
+
+        PullDecl.prototype.getVariableDeclGroups = function () {
+            var declGroups = null;
+
+            if (this.declGroups) {
+                for (var declName in this.declGroups) {
+                    if (this.declGroups[declName]) {
+                        if (declGroups === null) {
+                            declGroups = [];
+                        }
+
+                        declGroups.push(this.declGroups[declName].getDecls());
+                    }
+                }
+            }
+
+            return declGroups || sentinelEmptyPullDeclArray;
+        };
+
+        PullDecl.prototype.hasBeenBound = function () {
+            return this.hasSymbol() || this.hasSignatureSymbol();
+        };
+
+        PullDecl.prototype.isSynthesized = function () {
+            return false;
+        };
+
+        PullDecl.prototype.ast = function () {
+            return this.semanticInfoChain.getASTForDecl(this);
+        };
+
+        PullDecl.prototype.isRootDecl = function () {
+            throw TypeScript.Errors.abstract();
+        };
+        return PullDecl;
+    })();
+    TypeScript.PullDecl = PullDecl;
+
+    var RootPullDecl = (function (_super) {
+        __extends(RootPullDecl, _super);
+        function RootPullDecl(name, fileName, kind, declFlags, semanticInfoChain, isExternalModule) {
+            _super.call(this, name, name, kind, declFlags, semanticInfoChain);
+            this.semanticInfoChain = semanticInfoChain;
+            this._isExternalModule = isExternalModule;
+            this._fileName = fileName;
+        }
+        RootPullDecl.prototype.fileName = function () {
+            return this._fileName;
+        };
+
+        RootPullDecl.prototype.getParentPath = function () {
+            return [this];
+        };
+
+        RootPullDecl.prototype.getParentDecl = function () {
+            return null;
+        };
+
+        RootPullDecl.prototype.isExternalModule = function () {
+            return this._isExternalModule;
+        };
+
+        RootPullDecl.prototype.getEnclosingDecl = function () {
+            return this;
+        };
+
+        RootPullDecl.prototype.isRootDecl = function () {
+            return true;
+        };
+        return RootPullDecl;
+    })(PullDecl);
+    TypeScript.RootPullDecl = RootPullDecl;
+
+    var NormalPullDecl = (function (_super) {
+        __extends(NormalPullDecl, _super);
+        function NormalPullDecl(declName, displayName, kind, declFlags, parentDecl, addToParent) {
+            if (typeof addToParent === "undefined") { addToParent = true; }
+            _super.call(this, declName, displayName, kind, declFlags, parentDecl ? parentDecl.semanticInfoChain : null);
+            this.parentDecl = null;
+            this.parentPath = null;
+
+            this.parentDecl = parentDecl;
+            if (addToParent) {
+                parentDecl.addChildDecl(this);
+            }
+
+            if (this.parentDecl) {
+                if (this.parentDecl.isRootDecl()) {
+                    this._rootDecl = this.parentDecl;
+                } else {
+                    this._rootDecl = this.parentDecl._rootDecl;
+                }
+            } else {
+                TypeScript.Debug.assert(this.isSynthesized());
+                this._rootDecl = null;
+            }
+        }
+        NormalPullDecl.prototype.fileName = function () {
+            return this._rootDecl.fileName();
+        };
+
+        NormalPullDecl.prototype.getParentDecl = function () {
+            return this.parentDecl;
+        };
+
+        NormalPullDecl.prototype.getParentPath = function () {
+            if (!this.parentPath) {
+                var path = [this];
+                var parentDecl = this.parentDecl;
+
+                while (parentDecl) {
+                    if (parentDecl && path[path.length - 1] !== parentDecl && !(parentDecl.kind & (256 /* ObjectLiteral */ | 8388608 /* ObjectType */))) {
+                        path.unshift(parentDecl);
+                    }
+
+                    parentDecl = parentDecl.getParentDecl();
+                }
+
+                this.parentPath = path;
+            }
+
+            return this.parentPath;
+        };
+
+        NormalPullDecl.prototype.isExternalModule = function () {
+            return false;
+        };
+
+        NormalPullDecl.prototype.getEnclosingDecl = function () {
+            return this.parentDecl && this.parentDecl._getEnclosingDeclFromParentDecl();
+        };
+
+        NormalPullDecl.prototype.isRootDecl = function () {
+            return false;
+        };
+        return NormalPullDecl;
+    })(PullDecl);
+    TypeScript.NormalPullDecl = NormalPullDecl;
+
+    var PullEnumElementDecl = (function (_super) {
+        __extends(PullEnumElementDecl, _super);
+        function PullEnumElementDecl(declName, displayName, parentDecl) {
+            _super.call(this, declName, displayName, 67108864 /* EnumMember */, 4 /* Public */, parentDecl);
+            this.constantValue = null;
+        }
+        return PullEnumElementDecl;
+    })(NormalPullDecl);
+    TypeScript.PullEnumElementDecl = PullEnumElementDecl;
+
+    var PullFunctionExpressionDecl = (function (_super) {
+        __extends(PullFunctionExpressionDecl, _super);
+        function PullFunctionExpressionDecl(expressionName, declFlags, parentDecl, displayName) {
+            if (typeof displayName === "undefined") { displayName = ""; }
+            _super.call(this, "", displayName, 131072 /* FunctionExpression */, declFlags, parentDecl);
+            this.functionExpressionName = expressionName;
+        }
+        PullFunctionExpressionDecl.prototype.getFunctionExpressionName = function () {
+            return this.functionExpressionName;
+        };
+        return PullFunctionExpressionDecl;
+    })(NormalPullDecl);
+    TypeScript.PullFunctionExpressionDecl = PullFunctionExpressionDecl;
+
+    var PullSynthesizedDecl = (function (_super) {
+        __extends(PullSynthesizedDecl, _super);
+        function PullSynthesizedDecl(declName, displayName, kind, declFlags, parentDecl, semanticInfoChain) {
+            _super.call(this, declName, displayName, kind, declFlags, parentDecl, false);
+            this.semanticInfoChain = semanticInfoChain;
+        }
+        PullSynthesizedDecl.prototype.isSynthesized = function () {
+            return true;
+        };
+
+        PullSynthesizedDecl.prototype.fileName = function () {
+            return this._rootDecl ? this._rootDecl.fileName() : "";
+        };
+        return PullSynthesizedDecl;
+    })(NormalPullDecl);
+    TypeScript.PullSynthesizedDecl = PullSynthesizedDecl;
+
+    var PullDeclGroup = (function () {
+        function PullDeclGroup(name) {
+            this.name = name;
+            this._decls = [];
+        }
+        PullDeclGroup.prototype.addDecl = function (decl) {
+            if (decl.name === this.name) {
+                this._decls[this._decls.length] = decl;
+            }
+        };
+
+        PullDeclGroup.prototype.getDecls = function () {
+            return this._decls;
+        };
+        return PullDeclGroup;
+    })();
+    TypeScript.PullDeclGroup = PullDeclGroup;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    TypeScript.pullSymbolID = 0;
+    TypeScript.sentinelEmptyArray = [];
+
+    var PullSymbol = (function () {
+        function PullSymbol(name, declKind) {
+            this.pullSymbolID = ++TypeScript.pullSymbolID;
+            this._container = null;
+            this.type = null;
+            this._declarations = null;
+            this.isResolved = false;
+            this.isOptional = false;
+            this.inResolution = false;
+            this.isSynthesized = false;
+            this.isVarArg = false;
+            this.rootSymbol = null;
+            this._enclosingSignature = null;
+            this._docComments = null;
+            this.isPrinting = false;
+            this.name = name;
+            this.kind = declKind;
+        }
+        PullSymbol.prototype.isAny = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.isType = function () {
+            return (this.kind & 58728795 /* SomeType */) !== 0;
+        };
+
+        PullSymbol.prototype.isTypeReference = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.isSignature = function () {
+            return (this.kind & 7340032 /* SomeSignature */) !== 0;
+        };
+
+        PullSymbol.prototype.isArrayNamedTypeReference = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.isPrimitive = function () {
+            return this.kind === 2 /* Primitive */;
+        };
+
+        PullSymbol.prototype.isAccessor = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.isError = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.isInterface = function () {
+            return this.kind === 16 /* Interface */;
+        };
+
+        PullSymbol.prototype.isMethod = function () {
+            return this.kind === 65536 /* Method */;
+        };
+
+        PullSymbol.prototype.isProperty = function () {
+            return this.kind === 4096 /* Property */;
+        };
+
+        PullSymbol.prototype.isAlias = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.isContainer = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.findAliasedType = function (scopeSymbol, skipScopeSymbolAliasesLookIn, lookIntoOnlyExportedAlias, aliasSymbols, visitedScopeDeclarations) {
+            if (typeof aliasSymbols === "undefined") { aliasSymbols = []; }
+            if (typeof visitedScopeDeclarations === "undefined") { visitedScopeDeclarations = []; }
+            var scopeDeclarations = scopeSymbol.getDeclarations();
+            var scopeSymbolAliasesToLookIn = [];
+
+            for (var i = 0; i < scopeDeclarations.length; i++) {
+                var scopeDecl = scopeDeclarations[i];
+                if (!TypeScript.ArrayUtilities.contains(visitedScopeDeclarations, scopeDecl)) {
+                    visitedScopeDeclarations.push(scopeDecl);
+
+                    var childDecls = scopeDecl.getChildDecls();
+                    for (var j = 0; j < childDecls.length; j++) {
+                        var childDecl = childDecls[j];
+                        if (childDecl.kind === 128 /* TypeAlias */ && (!lookIntoOnlyExportedAlias || (childDecl.flags & 1 /* Exported */))) {
+                            var symbol = childDecl.getSymbol();
+
+                            if (PullContainerSymbol.usedAsSymbol(symbol, this) || (this.rootSymbol && PullContainerSymbol.usedAsSymbol(symbol, this.rootSymbol))) {
+                                aliasSymbols.push(symbol);
+                                return aliasSymbols;
+                            }
+
+                            if (!skipScopeSymbolAliasesLookIn && PullSymbol._isExternalModuleReferenceAlias(symbol) && (!symbol.assignedContainer().hasExportAssignment() || (symbol.assignedContainer().getExportAssignedContainerSymbol() && symbol.assignedContainer().getExportAssignedContainerSymbol().kind === 32 /* DynamicModule */))) {
+                                scopeSymbolAliasesToLookIn.push(symbol);
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (var i = 0; i < scopeSymbolAliasesToLookIn.length; i++) {
+                var scopeSymbolAlias = scopeSymbolAliasesToLookIn[i];
+
+                aliasSymbols.push(scopeSymbolAlias);
+                var result = this.findAliasedType(scopeSymbolAlias.assignedContainer().hasExportAssignment() ? scopeSymbolAlias.assignedContainer().getExportAssignedContainerSymbol() : scopeSymbolAlias.assignedContainer(), false, true, aliasSymbols, visitedScopeDeclarations);
+                if (result) {
+                    return result;
+                }
+
+                aliasSymbols.pop();
+            }
+
+            return null;
+        };
+
+        PullSymbol.prototype.getExternalAliasedSymbols = function (scopeSymbol) {
+            if (!scopeSymbol) {
+                return null;
+            }
+
+            var scopePath = scopeSymbol.pathToRoot();
+            if (scopePath.length && scopePath[scopePath.length - 1].kind === 32 /* DynamicModule */) {
+                var symbols = this.findAliasedType(scopePath[scopePath.length - 1]);
+                return symbols;
+            }
+
+            return null;
+        };
+
+        PullSymbol._isExternalModuleReferenceAlias = function (aliasSymbol) {
+            if (aliasSymbol) {
+                if (aliasSymbol.assignedValue()) {
+                    return false;
+                }
+
+                if (aliasSymbol.assignedType() && aliasSymbol.assignedType() !== aliasSymbol.assignedContainer()) {
+                    return false;
+                }
+
+                if (aliasSymbol.assignedContainer() && aliasSymbol.assignedContainer().kind !== 32 /* DynamicModule */) {
+                    return false;
+                }
+
+                return true;
+            }
+
+            return false;
+        };
+
+        PullSymbol.prototype.getExportedInternalAliasSymbol = function (scopeSymbol) {
+            if (scopeSymbol) {
+                if (this.kind !== 128 /* TypeAlias */) {
+                    var scopePath = scopeSymbol.pathToRoot();
+                    for (var i = 0; i < scopePath.length; i++) {
+                        var internalAliases = this.findAliasedType(scopeSymbol, true, true);
+                        if (internalAliases) {
+                            TypeScript.Debug.assert(internalAliases.length === 1);
+                            return internalAliases[0];
+                        }
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        PullSymbol.prototype.getAliasSymbolName = function (scopeSymbol, aliasNameGetter, aliasPartsNameGetter, skipInternalAlias) {
+            if (!skipInternalAlias) {
+                var internalAlias = this.getExportedInternalAliasSymbol(scopeSymbol);
+                if (internalAlias) {
+                    return aliasNameGetter(internalAlias);
+                }
+            }
+
+            var externalAliases = this.getExternalAliasedSymbols(scopeSymbol);
+
+            if (externalAliases && PullSymbol._isExternalModuleReferenceAlias(externalAliases[externalAliases.length - 1])) {
+                var aliasFullName = aliasNameGetter(externalAliases[0]);
+                if (!aliasFullName) {
+                    return null;
+                }
+                for (var i = 1, symbolsLen = externalAliases.length; i < symbolsLen; i++) {
+                    aliasFullName = aliasFullName + "." + aliasPartsNameGetter(externalAliases[i]);
+                }
+                return aliasFullName;
+            }
+
+            return null;
+        };
+
+        PullSymbol.prototype._getResolver = function () {
+            TypeScript.Debug.assert(this._declarations && this._declarations.length > 0);
+            return this._declarations[0].semanticInfoChain.getResolver();
+        };
+
+        PullSymbol.prototype._resolveDeclaredSymbol = function () {
+            return this._getResolver().resolveDeclaredSymbol(this);
+        };
+
+        PullSymbol.prototype.getName = function (scopeSymbol, useConstraintInName) {
+            var aliasName = this.getAliasSymbolName(scopeSymbol, function (symbol) {
+                return symbol.getName(scopeSymbol, useConstraintInName);
+            }, function (symbol) {
+                return symbol.getName();
+            });
+            return aliasName || this.name;
+        };
+
+        PullSymbol.prototype.getDisplayName = function (scopeSymbol, useConstraintInName, skipInternalAliasName) {
+            var aliasDisplayName = this.getAliasSymbolName(scopeSymbol, function (symbol) {
+                return symbol.getDisplayName(scopeSymbol, useConstraintInName);
+            }, function (symbol) {
+                return symbol.getDisplayName();
+            }, skipInternalAliasName);
+            if (aliasDisplayName) {
+                return aliasDisplayName;
+            }
+
+            var decls = this.getDeclarations();
+            var name = decls.length && decls[0].getDisplayName();
+
+            return (name && name.length) ? name : this.name;
+        };
+
+        PullSymbol.prototype.getIsSpecialized = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.getRootSymbol = function () {
+            if (!this.rootSymbol) {
+                return this;
+            }
+            return this.rootSymbol;
+        };
+        PullSymbol.prototype.setRootSymbol = function (symbol) {
+            this.rootSymbol = symbol;
+        };
+
+        PullSymbol.prototype.setIsSynthesized = function (value) {
+            if (typeof value === "undefined") { value = true; }
+            TypeScript.Debug.assert(this.rootSymbol == null);
+            this.isSynthesized = value;
+        };
+
+        PullSymbol.prototype.getIsSynthesized = function () {
+            if (this.rootSymbol) {
+                return this.rootSymbol.getIsSynthesized();
+            }
+            return this.isSynthesized;
+        };
+
+        PullSymbol.prototype.setEnclosingSignature = function (signature) {
+            this._enclosingSignature = signature;
+        };
+
+        PullSymbol.prototype.getEnclosingSignature = function () {
+            return this._enclosingSignature;
+        };
+
+        PullSymbol.prototype.addDeclaration = function (decl) {
+            TypeScript.Debug.assert(!!decl);
+
+            if (this.rootSymbol) {
+                return;
+            }
+
+            if (!this._declarations) {
+                this._declarations = [decl];
+            } else {
+                this._declarations[this._declarations.length] = decl;
+            }
+        };
+
+        PullSymbol.prototype.getDeclarations = function () {
+            if (this.rootSymbol) {
+                return this.rootSymbol.getDeclarations();
+            }
+
+            if (!this._declarations) {
+                this._declarations = [];
+            }
+
+            return this._declarations;
+        };
+
+        PullSymbol.prototype.hasDeclaration = function (decl) {
+            if (!this._declarations) {
+                return false;
+            }
+
+            return TypeScript.ArrayUtilities.any(this._declarations, function (eachDecl) {
+                return eachDecl === decl;
+            });
+        };
+
+        PullSymbol.prototype.setContainer = function (containerSymbol) {
+            if (this.rootSymbol) {
+                return;
+            }
+
+            this._container = containerSymbol;
+        };
+
+        PullSymbol.prototype.getContainer = function () {
+            if (this.rootSymbol) {
+                return this.rootSymbol.getContainer();
+            }
+
+            return this._container;
+        };
+
+        PullSymbol.prototype.setResolved = function () {
+            this.isResolved = true;
+            this.inResolution = false;
+        };
+
+        PullSymbol.prototype.startResolving = function () {
+            this.inResolution = true;
+        };
+
+        PullSymbol.prototype.setUnresolved = function () {
+            this.isResolved = false;
+            this.inResolution = false;
+        };
+
+        PullSymbol.prototype.anyDeclHasFlag = function (flag) {
+            var declarations = this.getDeclarations();
+            for (var i = 0, n = declarations.length; i < n; i++) {
+                if (TypeScript.hasFlag(declarations[i].flags, flag)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+
+        PullSymbol.prototype.allDeclsHaveFlag = function (flag) {
+            var declarations = this.getDeclarations();
+            for (var i = 0, n = declarations.length; i < n; i++) {
+                if (!TypeScript.hasFlag(declarations[i].flags, flag)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+
+        PullSymbol.prototype.pathToRoot = function () {
+            var path = [];
+            var node = this;
+            while (node) {
+                if (node.isType()) {
+                    var associatedContainerSymbol = node.getAssociatedContainerType();
+                    if (associatedContainerSymbol) {
+                        node = associatedContainerSymbol;
+                    }
+                }
+                path[path.length] = node;
+                var nodeKind = node.kind;
+                if (nodeKind === 2048 /* Parameter */) {
+                    break;
+                } else {
+                    node = node.getContainer();
+                }
+            }
+            return path;
+        };
+
+        PullSymbol.unqualifiedNameReferencesDifferentSymbolInScope = function (symbol, scopePath, endScopePathIndex) {
+            var declPath = scopePath[0].getDeclarations()[0].getParentPath();
+            for (var i = 0, declIndex = declPath.length - 1; i <= endScopePathIndex; i++, declIndex--) {
+                if (scopePath[i].isContainer()) {
+                    var scopeContainer = scopePath[i];
+                    if (symbol.isContainer()) {
+                        var memberSymbol = scopeContainer.findContainedNonMemberContainer(symbol.name, 164 /* SomeContainer */);
+                        if (memberSymbol && memberSymbol != symbol && memberSymbol.getDeclarations()[0].getParentDecl() == declPath[declIndex]) {
+                            return true;
+                        }
+
+                        var memberSymbol = scopeContainer.findNestedContainer(symbol.name, 164 /* SomeContainer */);
+                        if (memberSymbol && memberSymbol != symbol) {
+                            return true;
+                        }
+                    } else if (symbol.isType()) {
+                        var memberSymbol = scopeContainer.findContainedNonMemberType(symbol.name, 58728795 /* SomeType */);
+                        var symbolRootType = TypeScript.PullHelpers.getRootType(symbol);
+                        if (memberSymbol && TypeScript.PullHelpers.getRootType(memberSymbol) != symbolRootType && memberSymbol.getDeclarations()[0].getParentDecl() == declPath[declIndex]) {
+                            return true;
+                        }
+
+                        var memberSymbol = scopeContainer.findNestedType(symbol.name, 58728795 /* SomeType */);
+                        if (memberSymbol && TypeScript.PullHelpers.getRootType(memberSymbol) != symbolRootType) {
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        PullSymbol.prototype.findQualifyingSymbolPathInScopeSymbol = function (scopeSymbol) {
+            var thisPath = this.pathToRoot();
+            if (thisPath.length === 1) {
+                return thisPath;
+            }
+
+            var scopeSymbolPath;
+            if (scopeSymbol) {
+                scopeSymbolPath = scopeSymbol.pathToRoot();
+            } else {
+                return thisPath;
+            }
+
+            var thisCommonAncestorIndex = TypeScript.ArrayUtilities.indexOf(thisPath, function (thisNode) {
+                return TypeScript.ArrayUtilities.contains(scopeSymbolPath, thisNode);
+            });
+            if (thisCommonAncestorIndex > 0) {
+                var thisCommonAncestor = thisPath[thisCommonAncestorIndex];
+                var scopeCommonAncestorIndex = TypeScript.ArrayUtilities.indexOf(scopeSymbolPath, function (scopeNode) {
+                    return scopeNode === thisCommonAncestor;
+                });
+                TypeScript.Debug.assert(thisPath.length - thisCommonAncestorIndex === scopeSymbolPath.length - scopeCommonAncestorIndex);
+
+                for (; thisCommonAncestorIndex < thisPath.length; thisCommonAncestorIndex++, scopeCommonAncestorIndex++) {
+                    if (!PullSymbol.unqualifiedNameReferencesDifferentSymbolInScope(thisPath[thisCommonAncestorIndex - 1], scopeSymbolPath, scopeCommonAncestorIndex)) {
+                        break;
+                    }
+                }
+            }
+
+            if (thisCommonAncestorIndex >= 0 && thisCommonAncestorIndex < thisPath.length) {
+                return thisPath.slice(0, thisCommonAncestorIndex);
+            } else {
+                return thisPath;
+            }
+        };
+
+        PullSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) {
+            var str = this.getNameAndTypeName(scopeSymbol);
+            return str;
+        };
+
+        PullSymbol.prototype.getNamePartForFullName = function () {
+            return this.getDisplayName(null, true);
+        };
+
+        PullSymbol.prototype.fullName = function (scopeSymbol) {
+            var _this = this;
+            var path = this.pathToRoot();
+            var fullName = "";
+
+            var aliasFullName = this.getAliasSymbolName(scopeSymbol, function (symbol) {
+                return symbol.fullName(scopeSymbol);
+            }, function (symbol) {
+                return symbol.getNamePartForFullName();
+            });
+            if (aliasFullName) {
+                return aliasFullName;
+            }
+
+            for (var i = 1; i < path.length; i++) {
+                var aliasFullName = path[i].getAliasSymbolName(scopeSymbol, function (symbol) {
+                    return symbol === _this ? null : symbol.fullName(scopeSymbol);
+                }, function (symbol) {
+                    return symbol.getNamePartForFullName();
+                });
+                if (aliasFullName) {
+                    fullName = aliasFullName + "." + fullName;
+                    break;
+                }
+
+                var scopedName = path[i].getNamePartForFullName();
+                if (path[i].kind === 32 /* DynamicModule */ && !TypeScript.isQuoted(scopedName)) {
+                    break;
+                }
+
+                if (scopedName === "") {
+                    break;
+                }
+
+                fullName = scopedName + "." + fullName;
+            }
+
+            fullName = fullName + this.getNamePartForFullName();
+            return fullName;
+        };
+
+        PullSymbol.prototype.getScopedName = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName) {
+            var path = this.findQualifyingSymbolPathInScopeSymbol(scopeSymbol);
+            var fullName = "";
+
+            var aliasFullName = this.getAliasSymbolName(scopeSymbol, function (symbol) {
+                return symbol.getScopedName(scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName);
+            }, function (symbol) {
+                return symbol.getNamePartForFullName();
+            }, skipInternalAliasName);
+            if (aliasFullName) {
+                return aliasFullName;
+            }
+
+            for (var i = 1; i < path.length; i++) {
+                var kind = path[i].kind;
+                if (kind === 4 /* Container */ || kind === 32 /* DynamicModule */) {
+                    var aliasFullName = path[i].getAliasSymbolName(scopeSymbol, function (symbol) {
+                        return symbol.getScopedName(scopeSymbol, skipTypeParametersInName, false, skipInternalAliasName);
+                    }, function (symbol) {
+                        return symbol.getNamePartForFullName();
+                    }, skipInternalAliasName);
+                    if (aliasFullName) {
+                        fullName = aliasFullName + "." + fullName;
+                        break;
+                    }
+
+                    if (kind === 4 /* Container */) {
+                        fullName = path[i].getDisplayName() + "." + fullName;
+                    } else {
+                        var displayName = path[i].getDisplayName();
+                        if (TypeScript.isQuoted(displayName)) {
+                            fullName = displayName + "." + fullName;
+                        }
+                        break;
+                    }
+                } else {
+                    break;
+                }
+            }
+            fullName = fullName + this.getDisplayName(scopeSymbol, useConstraintInName, skipInternalAliasName);
+            return fullName;
+        };
+
+        PullSymbol.prototype.getScopedNameEx = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, getPrettyTypeName, getTypeParamMarkerInfo, skipInternalAliasName) {
+            var name = this.getScopedName(scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName);
+            return TypeScript.MemberName.create(name);
+        };
+
+        PullSymbol.prototype.getTypeName = function (scopeSymbol, getPrettyTypeName) {
+            var memberName = this.getTypeNameEx(scopeSymbol, getPrettyTypeName);
+            return memberName.toString();
+        };
+
+        PullSymbol.prototype.getTypeNameEx = function (scopeSymbol, getPrettyTypeName) {
+            var type = this.type;
+            if (type) {
+                var memberName = getPrettyTypeName ? this.getTypeNameForFunctionSignature("", scopeSymbol, getPrettyTypeName) : null;
+                if (!memberName) {
+                    memberName = type.getScopedNameEx(scopeSymbol, false, true, getPrettyTypeName);
+                }
+
+                return memberName;
+            }
+            return TypeScript.MemberName.create("");
+        };
+
+        PullSymbol.prototype.getTypeNameForFunctionSignature = function (prefix, scopeSymbol, getPrettyTypeName) {
+            var type = this.type;
+            if (type && !type.isNamedTypeSymbol() && this.kind !== 4096 /* Property */ && this.kind !== 512 /* Variable */ && this.kind !== 2048 /* Parameter */) {
+                var signatures = type.getCallSignatures();
+                if (signatures.length === 1 || (getPrettyTypeName && signatures.length)) {
+                    var typeName = new TypeScript.MemberNameArray();
+                    var signatureName = PullSignatureSymbol.getSignaturesTypeNameEx(signatures, prefix, false, false, scopeSymbol, getPrettyTypeName);
+                    typeName.addAll(signatureName);
+                    return typeName;
+                }
+            }
+
+            return null;
+        };
+
+        PullSymbol.prototype.getNameAndTypeName = function (scopeSymbol) {
+            var nameAndTypeName = this.getNameAndTypeNameEx(scopeSymbol);
+            return nameAndTypeName.toString();
+        };
+
+        PullSymbol.prototype.getNameAndTypeNameEx = function (scopeSymbol) {
+            var type = this.type;
+            var nameStr = this.getDisplayName(scopeSymbol);
+            if (type) {
+                nameStr = nameStr + (this.isOptional ? "?" : "");
+                var memberName = this.getTypeNameForFunctionSignature(nameStr, scopeSymbol);
+                if (!memberName) {
+                    var typeNameEx = type.getScopedNameEx(scopeSymbol);
+                    memberName = TypeScript.MemberName.create(typeNameEx, nameStr + ": ", "");
+                }
+                return memberName;
+            }
+            return TypeScript.MemberName.create(nameStr);
+        };
+
+        PullSymbol.getTypeParameterString = function (typars, scopeSymbol, useContraintInName) {
+            return PullSymbol.getTypeParameterStringEx(typars, scopeSymbol, undefined, useContraintInName).toString();
+        };
+
+        PullSymbol.getTypeParameterStringEx = function (typeParameters, scopeSymbol, getTypeParamMarkerInfo, useContraintInName) {
+            var builder = new TypeScript.MemberNameArray();
+            builder.prefix = "";
+
+            if (typeParameters && typeParameters.length) {
+                builder.add(TypeScript.MemberName.create("<"));
+
+                for (var i = 0; i < typeParameters.length; i++) {
+                    if (i) {
+                        builder.add(TypeScript.MemberName.create(", "));
+                    }
+
+                    if (getTypeParamMarkerInfo) {
+                        builder.add(new TypeScript.MemberName());
+                    }
+
+                    builder.add(typeParameters[i].getScopedNameEx(scopeSymbol, false, useContraintInName));
+
+                    if (getTypeParamMarkerInfo) {
+                        builder.add(new TypeScript.MemberName());
+                    }
+                }
+
+                builder.add(TypeScript.MemberName.create(">"));
+            }
+
+            return builder;
+        };
+
+        PullSymbol.getIsExternallyVisible = function (symbol, fromIsExternallyVisibleSymbol, inIsExternallyVisibleSymbols) {
+            if (inIsExternallyVisibleSymbols) {
+                for (var i = 0; i < inIsExternallyVisibleSymbols.length; i++) {
+                    if (inIsExternallyVisibleSymbols[i] === symbol) {
+                        return true;
+                    }
+                }
+            } else {
+                inIsExternallyVisibleSymbols = [];
+            }
+
+            if (fromIsExternallyVisibleSymbol === symbol) {
+                return true;
+            }
+
+            inIsExternallyVisibleSymbols.push(fromIsExternallyVisibleSymbol);
+
+            var result = symbol.isExternallyVisible(inIsExternallyVisibleSymbols);
+
+            TypeScript.Debug.assert(TypeScript.ArrayUtilities.last(inIsExternallyVisibleSymbols) === fromIsExternallyVisibleSymbol);
+            inIsExternallyVisibleSymbols.pop();
+
+            return result;
+        };
+
+        PullSymbol.prototype.isExternallyVisible = function (inIsExternallyVisibleSymbols) {
+            var kind = this.kind;
+            if (kind === 2 /* Primitive */) {
+                return true;
+            }
+
+            if (this.rootSymbol) {
+                return PullSymbol.getIsExternallyVisible(this.rootSymbol, this, inIsExternallyVisibleSymbols);
+            }
+
+            if (this.isType()) {
+                var associatedContainerSymbol = this.getAssociatedContainerType();
+                if (associatedContainerSymbol) {
+                    return PullSymbol.getIsExternallyVisible(associatedContainerSymbol, this, inIsExternallyVisibleSymbols);
+                }
+            }
+
+            if (this.anyDeclHasFlag(2 /* Private */)) {
+                return false;
+            }
+
+            var container = this.getContainer();
+            if (container === null) {
+                var decls = this.getDeclarations();
+                if (decls.length) {
+                    var parentDecl = decls[0].getParentDecl();
+                    if (parentDecl) {
+                        var parentSymbol = parentDecl.getSymbol();
+                        if (!parentSymbol || parentDecl.kind === 1 /* Script */) {
+                            return true;
+                        }
+
+                        return PullSymbol.getIsExternallyVisible(parentSymbol, this, inIsExternallyVisibleSymbols);
+                    }
+                }
+
+                return true;
+            }
+
+            if (container.kind === 32 /* DynamicModule */ || (container.getAssociatedContainerType() && container.getAssociatedContainerType().kind === 32 /* DynamicModule */)) {
+                var containerSymbol = container.kind === 32 /* DynamicModule */ ? container : container.getAssociatedContainerType();
+                if (PullContainerSymbol.usedAsSymbol(containerSymbol, this)) {
+                    return true;
+                }
+            }
+
+            if (!this.anyDeclHasFlag(1 /* Exported */) && kind !== 4096 /* Property */ && kind !== 65536 /* Method */) {
+                return false;
+            }
+
+            return PullSymbol.getIsExternallyVisible(container, this, inIsExternallyVisibleSymbols);
+        };
+
+        PullSymbol.prototype.getDocCommentsOfDecl = function (decl) {
+            var ast = decl.ast();
+
+            if (ast) {
+                var enclosingModuleDeclaration = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(ast);
+                if (TypeScript.ASTHelpers.isLastNameOfModule(enclosingModuleDeclaration, ast)) {
+                    return TypeScript.ASTHelpers.docComments(enclosingModuleDeclaration);
+                }
+
+                if (ast.kind() !== 130 /* ModuleDeclaration */ || decl.kind !== 512 /* Variable */) {
+                    return TypeScript.ASTHelpers.docComments(ast);
+                }
+            }
+
+            return [];
+        };
+
+        PullSymbol.prototype.getDocCommentArray = function (symbol) {
+            var docComments = [];
+            if (!symbol) {
+                return docComments;
+            }
+
+            var isParameter = symbol.kind === 2048 /* Parameter */;
+            var decls = symbol.getDeclarations();
+            for (var i = 0; i < decls.length; i++) {
+                if (isParameter && decls[i].kind === 4096 /* Property */) {
+                    continue;
+                }
+                docComments = docComments.concat(this.getDocCommentsOfDecl(decls[i]));
+            }
+            return docComments;
+        };
+
+        PullSymbol.getDefaultConstructorSymbolForDocComments = function (classSymbol) {
+            if (classSymbol.getHasDefaultConstructor()) {
+                var extendedTypes = classSymbol.getExtendedTypes();
+                if (extendedTypes.length) {
+                    return PullSymbol.getDefaultConstructorSymbolForDocComments(extendedTypes[0]);
+                }
+            }
+
+            return classSymbol.type.getConstructSignatures()[0];
+        };
+
+        PullSymbol.prototype.getDocCommentText = function (comments) {
+            var docCommentText = new Array();
+            for (var c = 0; c < comments.length; c++) {
+                var commentText = this.getDocCommentTextValue(comments[c]);
+                if (commentText !== "") {
+                    docCommentText.push(commentText);
+                }
+            }
+            return docCommentText.join("\n");
+        };
+
+        PullSymbol.prototype.getDocCommentTextValue = function (comment) {
+            return this.cleanJSDocComment(comment.fullText());
+        };
+
+        PullSymbol.prototype.docComments = function (useConstructorAsClass) {
+            var decls = this.getDeclarations();
+            if (useConstructorAsClass && decls.length && decls[0].kind === 32768 /* ConstructorMethod */) {
+                var classDecl = decls[0].getParentDecl();
+                return this.getDocCommentText(this.getDocCommentsOfDecl(classDecl));
+            }
+
+            if (this._docComments === null) {
+                var docComments = "";
+                if (!useConstructorAsClass && this.kind === 2097152 /* ConstructSignature */ && decls.length && decls[0].kind === 8 /* Class */) {
+                    var classSymbol = this.returnType;
+                    var extendedTypes = classSymbol.getExtendedTypes();
+                    if (extendedTypes.length) {
+                        docComments = extendedTypes[0].getConstructorMethod().docComments();
+                    } else {
+                        docComments = "";
+                    }
+                } else if (this.kind === 2048 /* Parameter */) {
+                    var parameterComments = [];
+
+                    var funcContainer = this.getEnclosingSignature();
+                    var funcDocComments = this.getDocCommentArray(funcContainer);
+                    var paramComment = this.getParameterDocCommentText(this.getDisplayName(), funcDocComments);
+                    if (paramComment != "") {
+                        parameterComments.push(paramComment);
+                    }
+
+                    var paramSelfComment = this.getDocCommentText(this.getDocCommentArray(this));
+                    if (paramSelfComment != "") {
+                        parameterComments.push(paramSelfComment);
+                    }
+                    docComments = parameterComments.join("\n");
+                } else {
+                    var getSymbolComments = true;
+                    if (this.kind === 16777216 /* FunctionType */) {
+                        var functionSymbol = this.getFunctionSymbol();
+
+                        if (functionSymbol) {
+                            docComments = functionSymbol._docComments || "";
+                            getSymbolComments = false;
+                        } else {
+                            var declarationList = this.getDeclarations();
+                            if (declarationList.length > 0) {
+                                docComments = declarationList[0].getSymbol()._docComments || "";
+                                getSymbolComments = false;
+                            }
+                        }
+                    }
+                    if (getSymbolComments) {
+                        docComments = this.getDocCommentText(this.getDocCommentArray(this));
+                        if (docComments === "") {
+                            if (this.kind === 1048576 /* CallSignature */) {
+                                var callTypeSymbol = this.functionType;
+                                if (callTypeSymbol && callTypeSymbol.getCallSignatures().length === 1) {
+                                    docComments = callTypeSymbol.docComments();
+                                }
+                            }
+                        }
+                    }
+                }
+
+                this._docComments = docComments;
+            }
+
+            return this._docComments;
+        };
+
+        PullSymbol.prototype.getParameterDocCommentText = function (param, fncDocComments) {
+            if (fncDocComments.length === 0 || fncDocComments[0].kind() !== 6 /* MultiLineCommentTrivia */) {
+                return "";
+            }
+
+            for (var i = 0; i < fncDocComments.length; i++) {
+                var commentContents = fncDocComments[i].fullText();
+                for (var j = commentContents.indexOf("@param", 0); 0 <= j; j = commentContents.indexOf("@param", j)) {
+                    j += 6;
+                    if (!this.isSpaceChar(commentContents, j)) {
+                        continue;
+                    }
+
+                    j = this.consumeLeadingSpace(commentContents, j);
+                    if (j === -1) {
+                        break;
+                    }
+
+                    if (commentContents.charCodeAt(j) === 123 /* openBrace */) {
+                        j++;
+
+                        var charCode = 0;
+                        for (var curlies = 1; j < commentContents.length; j++) {
+                            charCode = commentContents.charCodeAt(j);
+
+                            if (charCode === 123 /* openBrace */) {
+                                curlies++;
+                                continue;
+                            }
+
+                            if (charCode === 125 /* closeBrace */) {
+                                curlies--;
+                                if (curlies === 0) {
+                                    break;
+                                } else {
+                                    continue;
+                                }
+                            }
+
+                            if (charCode === 64 /* at */) {
+                                break;
+                            }
+                        }
+
+                        if (j === commentContents.length) {
+                            break;
+                        }
+
+                        if (charCode === 64 /* at */) {
+                            continue;
+                        }
+
+                        j = this.consumeLeadingSpace(commentContents, j + 1);
+                        if (j === -1) {
+                            break;
+                        }
+                    }
+
+                    if (param !== commentContents.substr(j, param.length) || !this.isSpaceChar(commentContents, j + param.length)) {
+                        continue;
+                    }
+
+                    j = this.consumeLeadingSpace(commentContents, j + param.length);
+                    if (j === -1) {
+                        return "";
+                    }
+
+                    var endOfParam = commentContents.indexOf("@", j);
+                    var paramHelpString = commentContents.substring(j, endOfParam < 0 ? commentContents.length : endOfParam);
+
+                    var paramSpacesToRemove = undefined;
+                    var paramLineIndex = commentContents.substring(0, j).lastIndexOf("\n") + 1;
+                    if (paramLineIndex !== 0) {
+                        if (paramLineIndex < j && commentContents.charAt(paramLineIndex + 1) === "\r") {
+                            paramLineIndex++;
+                        }
+                    }
+                    var startSpaceRemovalIndex = this.consumeLeadingSpace(commentContents, paramLineIndex);
+                    if (startSpaceRemovalIndex !== j && commentContents.charAt(startSpaceRemovalIndex) === "*") {
+                        paramSpacesToRemove = j - startSpaceRemovalIndex - 1;
+                    }
+
+                    return this.cleanJSDocComment(paramHelpString, paramSpacesToRemove);
+                }
+            }
+
+            return "";
+        };
+
+        PullSymbol.prototype.cleanJSDocComment = function (content, spacesToRemove) {
+            var docCommentLines = new Array();
+            content = content.replace("/**", "");
+            if (content.length >= 2 && content.charAt(content.length - 1) === "/" && content.charAt(content.length - 2) === "*") {
+                content = content.substring(0, content.length - 2);
+            }
+            var lines = content.split("\n");
+            var inParamTag = false;
+            for (var l = 0; l < lines.length; l++) {
+                var line = lines[l];
+                var cleanLinePos = this.cleanDocCommentLine(line, true, spacesToRemove);
+                if (!cleanLinePos) {
+                    continue;
+                }
+
+                var docCommentText = "";
+                var prevPos = cleanLinePos.start;
+                for (var i = line.indexOf("@", cleanLinePos.start); 0 <= i && i < cleanLinePos.end; i = line.indexOf("@", i + 1)) {
+                    var wasInParamtag = inParamTag;
+
+                    if (line.indexOf("param", i + 1) === i + 1 && this.isSpaceChar(line, i + 6)) {
+                        if (!wasInParamtag) {
+                            docCommentText += line.substring(prevPos, i);
+                        }
+
+                        prevPos = i;
+                        inParamTag = true;
+                    } else if (wasInParamtag) {
+                        prevPos = i;
+                        inParamTag = false;
+                    }
+                }
+
+                if (!inParamTag) {
+                    docCommentText += line.substring(prevPos, cleanLinePos.end);
+                }
+
+                var newCleanPos = this.cleanDocCommentLine(docCommentText, false);
+                if (newCleanPos) {
+                    if (spacesToRemove === undefined) {
+                        spacesToRemove = cleanLinePos.jsDocSpacesRemoved;
+                    }
+                    docCommentLines.push(docCommentText);
+                }
+            }
+
+            return docCommentLines.join("\n");
+        };
+
+        PullSymbol.prototype.consumeLeadingSpace = function (line, startIndex, maxSpacesToRemove) {
+            var endIndex = line.length;
+            if (maxSpacesToRemove !== undefined) {
+                endIndex = TypeScript.MathPrototype.min(startIndex + maxSpacesToRemove, endIndex);
+            }
+
+            for (; startIndex < endIndex; startIndex++) {
+                var charCode = line.charCodeAt(startIndex);
+                if (charCode !== 32 /* space */ && charCode !== 9 /* tab */) {
+                    return startIndex;
+                }
+            }
+
+            if (endIndex !== line.length) {
+                return endIndex;
+            }
+
+            return -1;
+        };
+
+        PullSymbol.prototype.isSpaceChar = function (line, index) {
+            var length = line.length;
+            if (index < length) {
+                var charCode = line.charCodeAt(index);
+
+                return charCode === 32 /* space */ || charCode === 9 /* tab */;
+            }
+
+            return index === length;
+        };
+
+        PullSymbol.prototype.cleanDocCommentLine = function (line, jsDocStyleComment, jsDocLineSpaceToRemove) {
+            var nonSpaceIndex = this.consumeLeadingSpace(line, 0);
+            if (nonSpaceIndex !== -1) {
+                var jsDocSpacesRemoved = nonSpaceIndex;
+                if (jsDocStyleComment && line.charAt(nonSpaceIndex) === '*') {
+                    var startIndex = nonSpaceIndex + 1;
+                    nonSpaceIndex = this.consumeLeadingSpace(line, startIndex, jsDocLineSpaceToRemove);
+
+                    if (nonSpaceIndex !== -1) {
+                        jsDocSpacesRemoved = nonSpaceIndex - startIndex;
+                    } else {
+                        return null;
+                    }
+                }
+
+                return {
+                    start: nonSpaceIndex,
+                    end: line.charAt(line.length - 1) === "\r" ? line.length - 1 : line.length,
+                    jsDocSpacesRemoved: jsDocSpacesRemoved
+                };
+            }
+
+            return null;
+        };
+        return PullSymbol;
+    })();
+    TypeScript.PullSymbol = PullSymbol;
+
+    
+
+    var PullSignatureSymbol = (function (_super) {
+        __extends(PullSignatureSymbol, _super);
+        function PullSignatureSymbol(kind, _isDefinition) {
+            if (typeof _isDefinition === "undefined") { _isDefinition = false; }
+            _super.call(this, "", kind);
+            this._isDefinition = _isDefinition;
+            this._memberTypeParameterNameCache = null;
+            this._stringConstantOverload = undefined;
+            this.parameters = TypeScript.sentinelEmptyArray;
+            this._typeParameters = null;
+            this.returnType = null;
+            this.functionType = null;
+            this.hasOptionalParam = false;
+            this.nonOptionalParamCount = 0;
+            this.hasVarArgs = false;
+            this._allowedToReferenceTypeParameters = null;
+            this._instantiationCache = null;
+            this.hasBeenChecked = false;
+            this.inWrapCheck = false;
+            this.inWrapInfiniteExpandingReferenceCheck = false;
+        }
+        PullSignatureSymbol.prototype.isDefinition = function () {
+            return this._isDefinition;
+        };
+
+        PullSignatureSymbol.prototype.isGeneric = function () {
+            var typeParameters = this.getTypeParameters();
+            return !!typeParameters && typeParameters.length !== 0;
+        };
+
+        PullSignatureSymbol.prototype.addParameter = function (parameter, isOptional) {
+            if (typeof isOptional === "undefined") { isOptional = false; }
+            if (this.parameters === TypeScript.sentinelEmptyArray) {
+                this.parameters = [];
+            }
+
+            this.parameters[this.parameters.length] = parameter;
+            this.hasOptionalParam = isOptional;
+
+            if (!parameter.getEnclosingSignature()) {
+                parameter.setEnclosingSignature(this);
+            }
+
+            if (!isOptional) {
+                this.nonOptionalParamCount++;
+            }
+        };
+
+        PullSignatureSymbol.prototype.addTypeParameter = function (typeParameter) {
+            if (!this._typeParameters) {
+                this._typeParameters = [];
+            }
+
+            if (!this._memberTypeParameterNameCache) {
+                this._memberTypeParameterNameCache = TypeScript.createIntrinsicsObject();
+            }
+
+            this._typeParameters[this._typeParameters.length] = typeParameter;
+
+            this._memberTypeParameterNameCache[typeParameter.getName()] = typeParameter;
+        };
+
+        PullSignatureSymbol.prototype.addTypeParametersFromReturnType = function () {
+            var typeParameters = this.returnType.getTypeParameters();
+            for (var i = 0; i < typeParameters.length; i++) {
+                this.addTypeParameter(typeParameters[i]);
+            }
+        };
+
+        PullSignatureSymbol.prototype.getTypeParameters = function () {
+            if (!this._typeParameters) {
+                this._typeParameters = [];
+            }
+
+            return this._typeParameters;
+        };
+
+        PullSignatureSymbol.prototype.findTypeParameter = function (name) {
+            var memberSymbol;
+
+            if (!this._memberTypeParameterNameCache) {
+                this._memberTypeParameterNameCache = TypeScript.createIntrinsicsObject();
+
+                for (var i = 0; i < this.getTypeParameters().length; i++) {
+                    this._memberTypeParameterNameCache[this._typeParameters[i].getName()] = this._typeParameters[i];
+                }
+            }
+
+            memberSymbol = this._memberTypeParameterNameCache[name];
+
+            return memberSymbol;
+        };
+
+        PullSignatureSymbol.prototype.getTypeParameterArgumentMap = function () {
+            return null;
+        };
+
+        PullSignatureSymbol.prototype.getAllowedToReferenceTypeParameters = function () {
+            TypeScript.Debug.assert(this.getRootSymbol() == this);
+            if (!this._allowedToReferenceTypeParameters) {
+                this._allowedToReferenceTypeParameters = TypeScript.PullInstantiationHelpers.getAllowedToReferenceTypeParametersFromDecl(this.getDeclarations()[0]);
+            }
+
+            return this._allowedToReferenceTypeParameters;
+        };
+
+        PullSignatureSymbol.prototype.addSpecialization = function (specializedVersionOfThisSignature, typeArgumentMap) {
+            TypeScript.Debug.assert(this.getRootSymbol() == this);
+            if (!this._instantiationCache) {
+                this._instantiationCache = TypeScript.createIntrinsicsObject();
+            }
+
+            this._instantiationCache[getIDForTypeSubstitutions(this, typeArgumentMap)] = specializedVersionOfThisSignature;
+        };
+
+        PullSignatureSymbol.prototype.getSpecialization = function (typeArgumentMap) {
+            TypeScript.Debug.assert(this.getRootSymbol() == this);
+            if (!this._instantiationCache) {
+                return null;
+            }
+
+            var result = this._instantiationCache[getIDForTypeSubstitutions(this, typeArgumentMap)];
+            return result || null;
+        };
+
+        PullSignatureSymbol.prototype.isStringConstantOverloadSignature = function () {
+            if (this._stringConstantOverload === undefined) {
+                var params = this.parameters;
+                this._stringConstantOverload = false;
+                for (var i = 0; i < params.length; i++) {
+                    var paramType = params[i].type;
+                    if (paramType && paramType.isPrimitive() && paramType.isStringConstant()) {
+                        this._stringConstantOverload = true;
+                    }
+                }
+            }
+
+            return this._stringConstantOverload;
+        };
+
+        PullSignatureSymbol.prototype.getParameterTypeAtIndex = function (iParam) {
+            if (iParam < this.parameters.length - 1 || (iParam < this.parameters.length && !this.hasVarArgs)) {
+                return this.parameters[iParam].type;
+            } else if (this.hasVarArgs) {
+                var paramType = this.parameters[this.parameters.length - 1].type;
+                if (paramType.isArrayNamedTypeReference()) {
+                    paramType = paramType.getElementType();
+                }
+                return paramType;
+            }
+
+            return null;
+        };
+
+        PullSignatureSymbol.getSignatureTypeMemberName = function (candidateSignature, signatures, scopeSymbol) {
+            var allMemberNames = new TypeScript.MemberNameArray();
+            var signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(signatures, "", false, false, scopeSymbol, true, candidateSignature);
+            allMemberNames.addAll(signatureMemberName);
+            return allMemberNames;
+        };
+
+        PullSignatureSymbol.getSignaturesTypeNameEx = function (signatures, prefix, shortform, brackets, scopeSymbol, getPrettyTypeName, candidateSignature) {
+            var result = [];
+            if (!signatures) {
+                return result;
+            }
+
+            var len = signatures.length;
+            if (!getPrettyTypeName && len > 1) {
+                shortform = false;
+            }
+
+            var foundDefinition = false;
+            if (candidateSignature && candidateSignature.isDefinition() && len > 1) {
+                candidateSignature = null;
+            }
+
+            for (var i = 0; i < len; i++) {
+                if (len > 1 && signatures[i].isDefinition()) {
+                    foundDefinition = true;
+                    continue;
+                }
+
+                var signature = signatures[i];
+                if (getPrettyTypeName && candidateSignature) {
+                    signature = candidateSignature;
+                }
+
+                result.push(signature.getSignatureTypeNameEx(prefix, shortform, brackets, scopeSymbol));
+                if (getPrettyTypeName) {
+                    break;
+                }
+            }
+
+            if (getPrettyTypeName && result.length && len > 1) {
+                var lastMemberName = result[result.length - 1];
+                for (var i = i + 1; i < len; i++) {
+                    if (signatures[i].isDefinition()) {
+                        foundDefinition = true;
+                        break;
+                    }
+                }
+                var overloadString = TypeScript.getLocalizedText(TypeScript.DiagnosticCode._0_overload_s, [foundDefinition ? len - 2 : len - 1]);
+                lastMemberName.add(TypeScript.MemberName.create(overloadString));
+            }
+
+            return result;
+        };
+
+        PullSignatureSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) {
+            var s = this.getSignatureTypeNameEx(this.getScopedNameEx().toString(), false, false, scopeSymbol, undefined, useConstraintInName).toString();
+            return s;
+        };
+
+        PullSignatureSymbol.prototype.getSignatureTypeNameEx = function (prefix, shortform, brackets, scopeSymbol, getParamMarkerInfo, getTypeParamMarkerInfo) {
+            var typeParamterBuilder = new TypeScript.MemberNameArray();
+
+            typeParamterBuilder.add(PullSymbol.getTypeParameterStringEx(this.getTypeParameters(), scopeSymbol, getTypeParamMarkerInfo, true));
+
+            if (brackets) {
+                typeParamterBuilder.add(TypeScript.MemberName.create("["));
+            } else {
+                typeParamterBuilder.add(TypeScript.MemberName.create("("));
+            }
+
+            var builder = new TypeScript.MemberNameArray();
+            builder.prefix = prefix;
+
+            if (getTypeParamMarkerInfo) {
+                builder.prefix = prefix;
+                builder.addAll(typeParamterBuilder.entries);
+            } else {
+                builder.prefix = prefix + typeParamterBuilder.toString();
+            }
+
+            var params = this.parameters;
+            var paramLen = params.length;
+            for (var i = 0; i < paramLen; i++) {
+                var paramType = params[i].type;
+                var typeString = paramType ? ": " : "";
+                var paramIsVarArg = params[i].isVarArg;
+                var varArgPrefix = paramIsVarArg ? "..." : "";
+                var optionalString = (!paramIsVarArg && params[i].isOptional) ? "?" : "";
+                if (getParamMarkerInfo) {
+                    builder.add(new TypeScript.MemberName());
+                }
+                builder.add(TypeScript.MemberName.create(varArgPrefix + params[i].getScopedNameEx(scopeSymbol).toString() + optionalString + typeString));
+                if (paramType) {
+                    builder.add(paramType.getScopedNameEx(scopeSymbol));
+                }
+                if (getParamMarkerInfo) {
+                    builder.add(new TypeScript.MemberName());
+                }
+                if (i < paramLen - 1) {
+                    builder.add(TypeScript.MemberName.create(", "));
+                }
+            }
+
+            if (shortform) {
+                if (brackets) {
+                    builder.add(TypeScript.MemberName.create("] => "));
+                } else {
+                    builder.add(TypeScript.MemberName.create(") => "));
+                }
+            } else {
+                if (brackets) {
+                    builder.add(TypeScript.MemberName.create("]: "));
+                } else {
+                    builder.add(TypeScript.MemberName.create("): "));
+                }
+            }
+
+            if (this.returnType) {
+                builder.add(this.returnType.getScopedNameEx(scopeSymbol));
+            } else {
+                builder.add(TypeScript.MemberName.create("any"));
+            }
+
+            return builder;
+        };
+
+        PullSignatureSymbol.prototype.forAllParameterTypes = function (length, predicate) {
+            if (this.parameters.length < length && !this.hasVarArgs) {
+                length = this.parameters.length;
+            }
+
+            for (var i = 0; i < length; i++) {
+                var paramType = this.getParameterTypeAtIndex(i);
+                if (!predicate(paramType, i)) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullSignatureSymbol.prototype.forAllCorrespondingParameterTypesInThisAndOtherSignature = function (otherSignature, predicate) {
+            var length;
+            if (this.hasVarArgs) {
+                length = otherSignature.hasVarArgs ? Math.max(this.parameters.length, otherSignature.parameters.length) : otherSignature.parameters.length;
+            } else {
+                length = otherSignature.hasVarArgs ? this.parameters.length : Math.min(this.parameters.length, otherSignature.parameters.length);
+            }
+
+            for (var i = 0; i < length; i++) {
+                var thisParamType = this.getParameterTypeAtIndex(i);
+                var otherParamType = otherSignature.getParameterTypeAtIndex(i);
+                if (!predicate(thisParamType, otherParamType, i)) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullSignatureSymbol.prototype.wrapsSomeTypeParameter = function (typeParameterArgumentMap) {
+            return this.getWrappingTypeParameterID(typeParameterArgumentMap) !== 0;
+        };
+
+        PullSignatureSymbol.prototype.getWrappingTypeParameterID = function (typeParameterArgumentMap) {
+            var signature = this;
+            if (signature.inWrapCheck) {
+                return 0;
+            }
+
+            this._wrapsTypeParameterCache = this._wrapsTypeParameterCache || new TypeScript.WrapsTypeParameterCache();
+
+            var wrappingTypeParameterID = this._wrapsTypeParameterCache.getWrapsTypeParameter(typeParameterArgumentMap);
+            if (wrappingTypeParameterID === undefined) {
+                wrappingTypeParameterID = this.getWrappingTypeParameterIDWorker(typeParameterArgumentMap);
+                this._wrapsTypeParameterCache.setWrapsTypeParameter(typeParameterArgumentMap, wrappingTypeParameterID);
+            }
+
+            return wrappingTypeParameterID;
+        };
+
+        PullSignatureSymbol.prototype.getWrappingTypeParameterIDWorker = function (typeParameterArgumentMap) {
+            var signature = this;
+            signature.inWrapCheck = true;
+            TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(signature);
+            var wrappingTypeParameterID = signature.returnType ? signature.returnType.getWrappingTypeParameterID(typeParameterArgumentMap) : 0;
+
+            var parameters = signature.parameters;
+            for (var i = 0; !wrappingTypeParameterID && i < parameters.length; i++) {
+                TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(parameters[i]);
+                wrappingTypeParameterID = parameters[i].type.getWrappingTypeParameterID(typeParameterArgumentMap);
+            }
+
+            signature.inWrapCheck = false;
+
+            return wrappingTypeParameterID;
+        };
+
+        PullSignatureSymbol.prototype._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReference = function (enclosingType, knownWrapMap) {
+            var wrapsIntoInfinitelyExpandingTypeReference = knownWrapMap.valueAt(this.pullSymbolID, enclosingType.pullSymbolID);
+            if (wrapsIntoInfinitelyExpandingTypeReference != undefined) {
+                return wrapsIntoInfinitelyExpandingTypeReference;
+            }
+
+            if (this.inWrapInfiniteExpandingReferenceCheck) {
+                return false;
+            }
+
+            this.inWrapInfiniteExpandingReferenceCheck = true;
+            wrapsIntoInfinitelyExpandingTypeReference = this._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceWorker(enclosingType, knownWrapMap);
+            knownWrapMap.setValueAt(this.pullSymbolID, enclosingType.pullSymbolID, wrapsIntoInfinitelyExpandingTypeReference);
+            this.inWrapInfiniteExpandingReferenceCheck = false;
+
+            return wrapsIntoInfinitelyExpandingTypeReference;
+        };
+
+        PullSignatureSymbol.prototype._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceWorker = function (enclosingType, knownWrapMap) {
+            if (this.returnType && this.returnType._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceRecurse(enclosingType, knownWrapMap)) {
+                return true;
+            }
+
+            var parameters = this.parameters;
+
+            for (var i = 0; i < parameters.length; i++) {
+                if (parameters[i].type && parameters[i].type._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceRecurse(enclosingType, knownWrapMap)) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+        return PullSignatureSymbol;
+    })(PullSymbol);
+    TypeScript.PullSignatureSymbol = PullSignatureSymbol;
+
+    var PullTypeSymbol = (function (_super) {
+        __extends(PullTypeSymbol, _super);
+        function PullTypeSymbol(name, kind) {
+            _super.call(this, name, kind);
+            this._members = TypeScript.sentinelEmptyArray;
+            this._enclosedMemberTypes = null;
+            this._enclosedMemberContainers = null;
+            this._typeParameters = null;
+            this._allowedToReferenceTypeParameters = null;
+            this._specializedVersionsOfThisType = null;
+            this._arrayVersionOfThisType = null;
+            this._implementedTypes = null;
+            this._extendedTypes = null;
+            this._typesThatExplicitlyImplementThisType = null;
+            this._typesThatExtendThisType = null;
+            this._callSignatures = null;
+            this._allCallSignatures = null;
+            this._constructSignatures = null;
+            this._allConstructSignatures = null;
+            this._indexSignatures = null;
+            this._allIndexSignatures = null;
+            this._allIndexSignaturesOfAugmentedType = null;
+            this._memberNameCache = null;
+            this._enclosedTypeNameCache = null;
+            this._enclosedContainerCache = null;
+            this._typeParameterNameCache = null;
+            this._containedNonMemberNameCache = null;
+            this._containedNonMemberTypeNameCache = null;
+            this._containedNonMemberContainerCache = null;
+            this._simpleInstantiationCache = null;
+            this._complexInstantiationCache = null;
+            this._hasGenericSignature = false;
+            this._hasGenericMember = false;
+            this._hasBaseTypeConflict = false;
+            this._knownBaseTypeCount = 0;
+            this._associatedContainerTypeSymbol = null;
+            this._constructorMethod = null;
+            this._hasDefaultConstructor = false;
+            this._functionSymbol = null;
+            this._inMemberTypeNameEx = false;
+            this.inSymbolPrivacyCheck = false;
+            this.inWrapCheck = false;
+            this.inWrapInfiniteExpandingReferenceCheck = false;
+            this.typeReference = null;
+            this._widenedType = null;
+            this._isArrayNamedTypeReference = undefined;
+            this.type = this;
+        }
+        PullTypeSymbol.prototype.isArrayNamedTypeReference = function () {
+            if (this._isArrayNamedTypeReference === undefined) {
+                this._isArrayNamedTypeReference = this.computeIsArrayNamedTypeReference();
+            }
+
+            return this._isArrayNamedTypeReference;
+        };
+
+        PullTypeSymbol.prototype.computeIsArrayNamedTypeReference = function () {
+            var typeArgs = this.getTypeArguments();
+            if (typeArgs && this.getTypeArguments().length === 1 && this.name === "Array") {
+                var declaration = this.getDeclarations()[0];
+
+                if (declaration && declaration.getParentDecl() && declaration.getParentDecl().getParentDecl() === null) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeSymbol.prototype.isType = function () {
+            return true;
+        };
+        PullTypeSymbol.prototype.isClass = function () {
+            return this.kind === 8 /* Class */ || (this._constructorMethod !== null);
+        };
+        PullTypeSymbol.prototype.isFunction = function () {
+            return (this.kind & (33554432 /* ConstructorType */ | 16777216 /* FunctionType */)) !== 0;
+        };
+        PullTypeSymbol.prototype.isConstructor = function () {
+            return this.kind === 33554432 /* ConstructorType */ || (this._associatedContainerTypeSymbol && this._associatedContainerTypeSymbol.isClass());
+        };
+        PullTypeSymbol.prototype.isTypeParameter = function () {
+            return false;
+        };
+        PullTypeSymbol.prototype.isTypeVariable = function () {
+            return false;
+        };
+        PullTypeSymbol.prototype.isError = function () {
+            return false;
+        };
+        PullTypeSymbol.prototype.isEnum = function () {
+            return this.kind === 64 /* Enum */;
+        };
+
+        PullTypeSymbol.prototype.getTypeParameterArgumentMap = function () {
+            return null;
+        };
+
+        PullTypeSymbol.prototype.isObject = function () {
+            return TypeScript.hasFlag(this.kind, 8 /* Class */ | 33554432 /* ConstructorType */ | 64 /* Enum */ | 16777216 /* FunctionType */ | 16 /* Interface */ | 8388608 /* ObjectType */ | 256 /* ObjectLiteral */);
+        };
+
+        PullTypeSymbol.prototype.isFunctionType = function () {
+            return this.getCallSignatures().length > 0 || this.getConstructSignatures().length > 0;
+        };
+
+        PullTypeSymbol.prototype.getKnownBaseTypeCount = function () {
+            return this._knownBaseTypeCount;
+        };
+        PullTypeSymbol.prototype.resetKnownBaseTypeCount = function () {
+            this._knownBaseTypeCount = 0;
+        };
+        PullTypeSymbol.prototype.incrementKnownBaseCount = function () {
+            this._knownBaseTypeCount++;
+        };
+
+        PullTypeSymbol.prototype.setHasBaseTypeConflict = function () {
+            this._hasBaseTypeConflict = true;
+        };
+        PullTypeSymbol.prototype.hasBaseTypeConflict = function () {
+            return this._hasBaseTypeConflict;
+        };
+
+        PullTypeSymbol.prototype.hasMembers = function () {
+            if (this._members !== TypeScript.sentinelEmptyArray) {
+                return true;
+            }
+
+            var parents = this.getExtendedTypes();
+
+            for (var i = 0; i < parents.length; i++) {
+                if (parents[i].hasMembers()) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeSymbol.prototype.setHasGenericSignature = function () {
+            this._hasGenericSignature = true;
+        };
+        PullTypeSymbol.prototype.getHasGenericSignature = function () {
+            return this._hasGenericSignature;
+        };
+
+        PullTypeSymbol.prototype.setHasGenericMember = function () {
+            this._hasGenericMember = true;
+        };
+        PullTypeSymbol.prototype.getHasGenericMember = function () {
+            return this._hasGenericMember;
+        };
+
+        PullTypeSymbol.prototype.setAssociatedContainerType = function (type) {
+            this._associatedContainerTypeSymbol = type;
+        };
+
+        PullTypeSymbol.prototype.getAssociatedContainerType = function () {
+            return this._associatedContainerTypeSymbol;
+        };
+
+        PullTypeSymbol.prototype.getArrayType = function () {
+            return this._arrayVersionOfThisType;
+        };
+
+        PullTypeSymbol.prototype.getElementType = function () {
+            return null;
+        };
+
+        PullTypeSymbol.prototype.setArrayType = function (arrayType) {
+            this._arrayVersionOfThisType = arrayType;
+        };
+
+        PullTypeSymbol.prototype.getFunctionSymbol = function () {
+            return this._functionSymbol;
+        };
+
+        PullTypeSymbol.prototype.setFunctionSymbol = function (symbol) {
+            if (symbol) {
+                this._functionSymbol = symbol;
+            }
+        };
+
+        PullTypeSymbol.prototype.findContainedNonMember = function (name) {
+            if (!this._containedNonMemberNameCache) {
+                return null;
+            }
+
+            return this._containedNonMemberNameCache[name];
+        };
+
+        PullTypeSymbol.prototype.findContainedNonMemberType = function (typeName, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            if (!this._containedNonMemberTypeNameCache) {
+                return null;
+            }
+
+            var nonMemberSymbol = this._containedNonMemberTypeNameCache[typeName];
+
+            if (nonMemberSymbol && kind !== 0 /* None */) {
+                nonMemberSymbol = TypeScript.hasFlag(nonMemberSymbol.kind, kind) ? nonMemberSymbol : null;
+            }
+
+            return nonMemberSymbol;
+        };
+
+        PullTypeSymbol.prototype.findContainedNonMemberContainer = function (containerName, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            if (!this._containedNonMemberContainerCache) {
+                return null;
+            }
+
+            var nonMemberSymbol = this._containedNonMemberContainerCache[containerName];
+
+            if (nonMemberSymbol && kind !== 0 /* None */) {
+                nonMemberSymbol = TypeScript.hasFlag(nonMemberSymbol.kind, kind) ? nonMemberSymbol : null;
+            }
+
+            return nonMemberSymbol;
+        };
+
+        PullTypeSymbol.prototype.addMember = function (memberSymbol) {
+            if (!memberSymbol) {
+                return;
+            }
+
+            memberSymbol.setContainer(this);
+
+            if (!this._memberNameCache) {
+                this._memberNameCache = TypeScript.createIntrinsicsObject();
+            }
+
+            if (this._members === TypeScript.sentinelEmptyArray) {
+                this._members = [];
+            }
+
+            this._members.push(memberSymbol);
+            this._memberNameCache[memberSymbol.name] = memberSymbol;
+        };
+
+        PullTypeSymbol.prototype.addEnclosedMemberType = function (enclosedType) {
+            if (!enclosedType) {
+                return;
+            }
+
+            enclosedType.setContainer(this);
+
+            if (!this._enclosedTypeNameCache) {
+                this._enclosedTypeNameCache = TypeScript.createIntrinsicsObject();
+            }
+
+            if (!this._enclosedMemberTypes) {
+                this._enclosedMemberTypes = [];
+            }
+
+            this._enclosedMemberTypes[this._enclosedMemberTypes.length] = enclosedType;
+            this._enclosedTypeNameCache[enclosedType.name] = enclosedType;
+        };
+
+        PullTypeSymbol.prototype.addEnclosedMemberContainer = function (enclosedContainer) {
+            if (!enclosedContainer) {
+                return;
+            }
+
+            enclosedContainer.setContainer(this);
+
+            if (!this._enclosedContainerCache) {
+                this._enclosedContainerCache = TypeScript.createIntrinsicsObject();
+            }
+
+            if (!this._enclosedMemberContainers) {
+                this._enclosedMemberContainers = [];
+            }
+
+            this._enclosedMemberContainers[this._enclosedMemberContainers.length] = enclosedContainer;
+            this._enclosedContainerCache[enclosedContainer.name] = enclosedContainer;
+        };
+
+        PullTypeSymbol.prototype.addEnclosedNonMember = function (enclosedNonMember) {
+            if (!enclosedNonMember) {
+                return;
+            }
+
+            enclosedNonMember.setContainer(this);
+
+            if (!this._containedNonMemberNameCache) {
+                this._containedNonMemberNameCache = TypeScript.createIntrinsicsObject();
+            }
+
+            this._containedNonMemberNameCache[enclosedNonMember.name] = enclosedNonMember;
+        };
+
+        PullTypeSymbol.prototype.addEnclosedNonMemberType = function (enclosedNonMemberType) {
+            if (!enclosedNonMemberType) {
+                return;
+            }
+
+            enclosedNonMemberType.setContainer(this);
+
+            if (!this._containedNonMemberTypeNameCache) {
+                this._containedNonMemberTypeNameCache = TypeScript.createIntrinsicsObject();
+            }
+
+            this._containedNonMemberTypeNameCache[enclosedNonMemberType.name] = enclosedNonMemberType;
+        };
+
+        PullTypeSymbol.prototype.addEnclosedNonMemberContainer = function (enclosedNonMemberContainer) {
+            if (!enclosedNonMemberContainer) {
+                return;
+            }
+
+            enclosedNonMemberContainer.setContainer(this);
+
+            if (!this._containedNonMemberContainerCache) {
+                this._containedNonMemberContainerCache = TypeScript.createIntrinsicsObject();
+            }
+
+            this._containedNonMemberContainerCache[enclosedNonMemberContainer.name] = enclosedNonMemberContainer;
+        };
+
+        PullTypeSymbol.prototype.addTypeParameter = function (typeParameter) {
+            if (!typeParameter) {
+                return;
+            }
+
+            if (!typeParameter.getContainer()) {
+                typeParameter.setContainer(this);
+            }
+
+            if (!this._typeParameterNameCache) {
+                this._typeParameterNameCache = TypeScript.createIntrinsicsObject();
+            }
+
+            if (!this._typeParameters) {
+                this._typeParameters = [];
+            }
+
+            this._typeParameters[this._typeParameters.length] = typeParameter;
+            this._typeParameterNameCache[typeParameter.getName()] = typeParameter;
+        };
+
+        PullTypeSymbol.prototype.getMembers = function () {
+            return this._members;
+        };
+
+        PullTypeSymbol.prototype.setHasDefaultConstructor = function (hasOne) {
+            if (typeof hasOne === "undefined") { hasOne = true; }
+            this._hasDefaultConstructor = hasOne;
+        };
+
+        PullTypeSymbol.prototype.getHasDefaultConstructor = function () {
+            return this._hasDefaultConstructor;
+        };
+
+        PullTypeSymbol.prototype.getConstructorMethod = function () {
+            return this._constructorMethod;
+        };
+
+        PullTypeSymbol.prototype.setConstructorMethod = function (constructorMethod) {
+            this._constructorMethod = constructorMethod;
+        };
+
+        PullTypeSymbol.prototype.getTypeParameters = function () {
+            if (!this._typeParameters) {
+                return TypeScript.sentinelEmptyArray;
+            }
+
+            return this._typeParameters;
+        };
+
+        PullTypeSymbol.prototype.getAllowedToReferenceTypeParameters = function () {
+            if (!!(this.kind && 8216 /* SomeInstantiatableType */) && this.isNamedTypeSymbol() && !this.isTypeParameter()) {
+                return this.getTypeParameters();
+            }
+
+            if (!this._allowedToReferenceTypeParameters) {
+                this._allowedToReferenceTypeParameters = TypeScript.PullInstantiationHelpers.getAllowedToReferenceTypeParametersFromDecl(this.getDeclarations()[0]);
+            }
+
+            return this._allowedToReferenceTypeParameters;
+        };
+
+        PullTypeSymbol.prototype.isGeneric = function () {
+            return (this._typeParameters && this._typeParameters.length > 0) || this._hasGenericSignature || this._hasGenericMember || this.isArrayNamedTypeReference();
+        };
+
+        PullTypeSymbol.prototype.canUseSimpleInstantiationCache = function (typeArgumentMap) {
+            if (this.isTypeParameter()) {
+                return true;
+            }
+
+            var typeParameters = this.getTypeParameters();
+            return typeArgumentMap && this.isNamedTypeSymbol() && typeParameters.length === 1 && typeArgumentMap[typeParameters[0].pullSymbolID].kind !== 8388608 /* ObjectType */;
+        };
+
+        PullTypeSymbol.prototype.getSimpleInstantiationCacheId = function (typeArgumentMap) {
+            if (this.isTypeParameter()) {
+                return typeArgumentMap[0].pullSymbolID;
+            }
+
+            return typeArgumentMap[this.getTypeParameters()[0].pullSymbolID].pullSymbolID;
+        };
+
+        PullTypeSymbol.prototype.addSpecialization = function (specializedVersionOfThisType, typeArgumentMap) {
+            if (this.canUseSimpleInstantiationCache(typeArgumentMap)) {
+                if (!this._simpleInstantiationCache) {
+                    this._simpleInstantiationCache = [];
+                }
+
+                this._simpleInstantiationCache[this.getSimpleInstantiationCacheId(typeArgumentMap)] = specializedVersionOfThisType;
+            } else {
+                if (!this._complexInstantiationCache) {
+                    this._complexInstantiationCache = TypeScript.createIntrinsicsObject();
+                }
+
+                this._complexInstantiationCache[getIDForTypeSubstitutions(this, typeArgumentMap)] = specializedVersionOfThisType;
+            }
+
+            if (!this._specializedVersionsOfThisType) {
+                this._specializedVersionsOfThisType = [];
+            }
+
+            this._specializedVersionsOfThisType.push(specializedVersionOfThisType);
+        };
+
+        PullTypeSymbol.prototype.getSpecialization = function (typeArgumentMap) {
+            if (this.canUseSimpleInstantiationCache(typeArgumentMap)) {
+                if (!this._simpleInstantiationCache) {
+                    return null;
+                }
+
+                var result = this._simpleInstantiationCache[this.getSimpleInstantiationCacheId(typeArgumentMap)];
+                return result || null;
+            } else {
+                if (!this._complexInstantiationCache) {
+                    return null;
+                }
+
+                if (this.getAllowedToReferenceTypeParameters().length == 0) {
+                    return this;
+                }
+
+                var result = this._complexInstantiationCache[getIDForTypeSubstitutions(this, typeArgumentMap)];
+                return result || null;
+            }
+        };
+
+        PullTypeSymbol.prototype.getKnownSpecializations = function () {
+            if (!this._specializedVersionsOfThisType) {
+                return TypeScript.sentinelEmptyArray;
+            }
+
+            return this._specializedVersionsOfThisType;
+        };
+
+        PullTypeSymbol.prototype.getTypeArguments = function () {
+            return null;
+        };
+
+        PullTypeSymbol.prototype.getTypeArgumentsOrTypeParameters = function () {
+            return this.getTypeParameters();
+        };
+
+        PullTypeSymbol.prototype.addCallOrConstructSignaturePrerequisiteBase = function (signature) {
+            if (signature.isGeneric()) {
+                this._hasGenericSignature = true;
+            }
+
+            signature.functionType = this;
+        };
+
+        PullTypeSymbol.prototype.addCallSignaturePrerequisite = function (callSignature) {
+            if (!this._callSignatures) {
+                this._callSignatures = [];
+            }
+
+            this.addCallOrConstructSignaturePrerequisiteBase(callSignature);
+        };
+
+        PullTypeSymbol.prototype.appendCallSignature = function (callSignature) {
+            this.addCallSignaturePrerequisite(callSignature);
+            this._callSignatures.push(callSignature);
+        };
+
+        PullTypeSymbol.prototype.insertCallSignatureAtIndex = function (callSignature, index) {
+            this.addCallSignaturePrerequisite(callSignature);
+            TypeScript.Debug.assert(index <= this._callSignatures.length);
+            if (index === this._callSignatures.length) {
+                this._callSignatures.push(callSignature);
+            } else {
+                this._callSignatures.splice(index, 0, callSignature);
+            }
+        };
+
+        PullTypeSymbol.prototype.addConstructSignaturePrerequisite = function (constructSignature) {
+            if (!this._constructSignatures) {
+                this._constructSignatures = [];
+            }
+
+            this.addCallOrConstructSignaturePrerequisiteBase(constructSignature);
+        };
+
+        PullTypeSymbol.prototype.appendConstructSignature = function (constructSignature) {
+            this.addConstructSignaturePrerequisite(constructSignature);
+            this._constructSignatures.push(constructSignature);
+        };
+
+        PullTypeSymbol.prototype.insertConstructSignatureAtIndex = function (constructSignature, index) {
+            this.addConstructSignaturePrerequisite(constructSignature);
+            TypeScript.Debug.assert(index <= this._constructSignatures.length);
+            if (index === this._constructSignatures.length) {
+                this._constructSignatures.push(constructSignature);
+            } else {
+                this._constructSignatures.splice(index, 0, constructSignature);
+            }
+        };
+
+        PullTypeSymbol.prototype.addIndexSignature = function (indexSignature) {
+            if (!this._indexSignatures) {
+                this._indexSignatures = [];
+            }
+
+            this._indexSignatures[this._indexSignatures.length] = indexSignature;
+
+            if (indexSignature.isGeneric()) {
+                this._hasGenericSignature = true;
+            }
+
+            indexSignature.functionType = this;
+        };
+
+        PullTypeSymbol.prototype.hasOwnCallSignatures = function () {
+            return this._callSignatures !== null;
+        };
+
+        PullTypeSymbol.prototype.getOwnCallSignatures = function () {
+            return this._callSignatures || TypeScript.sentinelEmptyArray;
+        };
+
+        PullTypeSymbol.prototype.getCallSignatures = function () {
+            if (this._allCallSignatures) {
+                return this._allCallSignatures;
+            }
+
+            var signatures = [];
+
+            if (this._callSignatures) {
+                signatures = signatures.concat(this._callSignatures);
+            }
+
+            if (this._extendedTypes && this.kind === 16 /* Interface */) {
+                for (var i = 0; i < this._extendedTypes.length; i++) {
+                    if (this._extendedTypes[i].hasBase(this)) {
+                        continue;
+                    }
+
+                    this._getResolver()._addUnhiddenSignaturesFromBaseType(this._callSignatures, this._extendedTypes[i].getCallSignatures(), signatures);
+                }
+            }
+
+            this._allCallSignatures = signatures;
+
+            return signatures;
+        };
+
+        PullTypeSymbol.prototype.hasOwnConstructSignatures = function () {
+            return this._constructSignatures !== null;
+        };
+
+        PullTypeSymbol.prototype.getOwnDeclaredConstructSignatures = function () {
+            return this._constructSignatures || TypeScript.sentinelEmptyArray;
+        };
+
+        PullTypeSymbol.prototype.getConstructSignatures = function () {
+            if (this._allConstructSignatures) {
+                return this._allConstructSignatures;
+            }
+
+            var signatures = [];
+
+            if (this._constructSignatures) {
+                signatures = signatures.concat(this._constructSignatures);
+            } else if (this.isConstructor()) {
+                if (this._extendedTypes && this._extendedTypes.length > 0) {
+                    signatures = this.getBaseClassConstructSignatures(this._extendedTypes[0]);
+                } else {
+                    signatures = [this.getDefaultClassConstructSignature()];
+                }
+            }
+
+            if (this._extendedTypes && this.kind === 16 /* Interface */) {
+                for (var i = 0; i < this._extendedTypes.length; i++) {
+                    if (this._extendedTypes[i].hasBase(this)) {
+                        continue;
+                    }
+
+                    this._getResolver()._addUnhiddenSignaturesFromBaseType(this._constructSignatures, this._extendedTypes[i].getConstructSignatures(), signatures);
+                }
+            }
+
+            this._allConstructSignatures = signatures;
+
+            return signatures;
+        };
+
+        PullTypeSymbol.prototype.hasOwnIndexSignatures = function () {
+            return this._indexSignatures !== null;
+        };
+
+        PullTypeSymbol.prototype.getOwnIndexSignatures = function () {
+            return this._indexSignatures || TypeScript.sentinelEmptyArray;
+        };
+
+        PullTypeSymbol.prototype.getIndexSignatures = function () {
+            if (this._allIndexSignatures) {
+                return this._allIndexSignatures;
+            }
+
+            var signatures = [];
+
+            if (this._indexSignatures) {
+                signatures = signatures.concat(this._indexSignatures);
+            }
+
+            if (this._extendedTypes) {
+                for (var i = 0; i < this._extendedTypes.length; i++) {
+                    if (this._extendedTypes[i].hasBase(this)) {
+                        continue;
+                    }
+
+                    this._getResolver()._addUnhiddenSignaturesFromBaseType(this._indexSignatures, this._extendedTypes[i].getIndexSignatures(), signatures);
+                }
+            }
+
+            this._allIndexSignatures = signatures;
+
+            return signatures;
+        };
+
+        PullTypeSymbol.prototype.getIndexSignaturesOfAugmentedType = function (resolver, globalFunctionInterface, globalObjectInterface) {
+            if (!this._allIndexSignaturesOfAugmentedType) {
+                var initialIndexSignatures = this.getIndexSignatures();
+                var shouldAddFunctionSignatures = false;
+                var shouldAddObjectSignatures = false;
+
+                if (globalFunctionInterface && this.isFunctionType() && this !== globalFunctionInterface) {
+                    var functionIndexSignatures = globalFunctionInterface.getIndexSignatures();
+                    if (functionIndexSignatures.length) {
+                        shouldAddFunctionSignatures = true;
+                    }
+                }
+
+                if (globalObjectInterface && this !== globalObjectInterface) {
+                    var objectIndexSignatures = globalObjectInterface.getIndexSignatures();
+                    if (objectIndexSignatures.length) {
+                        shouldAddObjectSignatures = true;
+                    }
+                }
+
+                if (shouldAddFunctionSignatures || shouldAddObjectSignatures) {
+                    this._allIndexSignaturesOfAugmentedType = initialIndexSignatures.slice(0);
+                    if (shouldAddFunctionSignatures) {
+                        resolver._addUnhiddenSignaturesFromBaseType(initialIndexSignatures, functionIndexSignatures, this._allIndexSignaturesOfAugmentedType);
+                    }
+                    if (shouldAddObjectSignatures) {
+                        if (shouldAddFunctionSignatures) {
+                            initialIndexSignatures = initialIndexSignatures.concat(functionIndexSignatures);
+                        }
+                        resolver._addUnhiddenSignaturesFromBaseType(initialIndexSignatures, objectIndexSignatures, this._allIndexSignaturesOfAugmentedType);
+                    }
+                } else {
+                    this._allIndexSignaturesOfAugmentedType = initialIndexSignatures;
+                }
+            }
+
+            return this._allIndexSignaturesOfAugmentedType;
+        };
+
+        PullTypeSymbol.prototype.getBaseClassConstructSignatures = function (baseType) {
+            TypeScript.Debug.assert(this.isConstructor() && baseType.isConstructor());
+            var instanceTypeSymbol = this.getAssociatedContainerType();
+            TypeScript.Debug.assert(instanceTypeSymbol.getDeclarations().length === 1);
+            if (baseType.hasBase(this)) {
+                return null;
+            }
+
+            var baseConstructSignatures = baseType.getConstructSignatures();
+            var signatures = [];
+            for (var i = 0; i < baseConstructSignatures.length; i++) {
+                var baseSignature = baseConstructSignatures[i];
+                var currentSignature = new PullSignatureSymbol(2097152 /* ConstructSignature */, baseSignature.isDefinition());
+                currentSignature.returnType = instanceTypeSymbol;
+                currentSignature.addTypeParametersFromReturnType();
+                for (var j = 0; j < baseSignature.parameters.length; j++) {
+                    currentSignature.addParameter(baseSignature.parameters[j], baseSignature.parameters[j].isOptional);
+                }
+                if (baseSignature.parameters.length > 0) {
+                    currentSignature.hasVarArgs = baseSignature.parameters[baseSignature.parameters.length - 1].isVarArg;
+                }
+
+                currentSignature.addDeclaration(instanceTypeSymbol.getDeclarations()[0]);
+                this.addCallOrConstructSignaturePrerequisiteBase(currentSignature);
+                signatures.push(currentSignature);
+            }
+
+            return signatures;
+        };
+
+        PullTypeSymbol.prototype.getDefaultClassConstructSignature = function () {
+            TypeScript.Debug.assert(this.isConstructor());
+            var instanceTypeSymbol = this.getAssociatedContainerType();
+            TypeScript.Debug.assert(instanceTypeSymbol.getDeclarations().length == 1);
+            var signature = new PullSignatureSymbol(2097152 /* ConstructSignature */, true);
+            signature.returnType = instanceTypeSymbol;
+            signature.addTypeParametersFromReturnType();
+            signature.addDeclaration(instanceTypeSymbol.getDeclarations()[0]);
+            this.addCallOrConstructSignaturePrerequisiteBase(signature);
+
+            return signature;
+        };
+
+        PullTypeSymbol.prototype.addImplementedType = function (implementedType) {
+            if (!implementedType) {
+                return;
+            }
+
+            if (!this._implementedTypes) {
+                this._implementedTypes = [];
+            }
+
+            this._implementedTypes[this._implementedTypes.length] = implementedType;
+
+            implementedType.addTypeThatExplicitlyImplementsThisType(this);
+        };
+
+        PullTypeSymbol.prototype.getImplementedTypes = function () {
+            if (!this._implementedTypes) {
+                return TypeScript.sentinelEmptyArray;
+            }
+
+            return this._implementedTypes;
+        };
+
+        PullTypeSymbol.prototype.addExtendedType = function (extendedType) {
+            if (!extendedType) {
+                return;
+            }
+
+            if (!this._extendedTypes) {
+                this._extendedTypes = [];
+            }
+
+            this._extendedTypes[this._extendedTypes.length] = extendedType;
+
+            extendedType.addTypeThatExtendsThisType(this);
+        };
+
+        PullTypeSymbol.prototype.getExtendedTypes = function () {
+            if (!this._extendedTypes) {
+                return TypeScript.sentinelEmptyArray;
+            }
+
+            return this._extendedTypes;
+        };
+
+        PullTypeSymbol.prototype.addTypeThatExtendsThisType = function (type) {
+            if (!type) {
+                return;
+            }
+
+            if (!this._typesThatExtendThisType) {
+                this._typesThatExtendThisType = [];
+            }
+
+            this._typesThatExtendThisType[this._typesThatExtendThisType.length] = type;
+        };
+
+        PullTypeSymbol.prototype.getTypesThatExtendThisType = function () {
+            if (!this._typesThatExtendThisType) {
+                this._typesThatExtendThisType = [];
+            }
+
+            return this._typesThatExtendThisType;
+        };
+
+        PullTypeSymbol.prototype.addTypeThatExplicitlyImplementsThisType = function (type) {
+            if (!type) {
+                return;
+            }
+
+            if (!this._typesThatExplicitlyImplementThisType) {
+                this._typesThatExplicitlyImplementThisType = [];
+            }
+
+            this._typesThatExplicitlyImplementThisType[this._typesThatExplicitlyImplementThisType.length] = type;
+        };
+
+        PullTypeSymbol.prototype.getTypesThatExplicitlyImplementThisType = function () {
+            if (!this._typesThatExplicitlyImplementThisType) {
+                this._typesThatExplicitlyImplementThisType = [];
+            }
+
+            return this._typesThatExplicitlyImplementThisType;
+        };
+
+        PullTypeSymbol.prototype.hasBase = function (potentialBase, visited) {
+            if (typeof visited === "undefined") { visited = []; }
+            if (this === potentialBase || this.getRootSymbol() === potentialBase || this === potentialBase.getRootSymbol()) {
+                return true;
+            }
+
+            if (TypeScript.ArrayUtilities.contains(visited, this)) {
+                return true;
+            }
+
+            visited.push(this);
+
+            var extendedTypes = this.getExtendedTypes();
+
+            for (var i = 0; i < extendedTypes.length; i++) {
+                if (extendedTypes[i].hasBase(potentialBase, visited)) {
+                    return true;
+                }
+            }
+
+            var implementedTypes = this.getImplementedTypes();
+
+            for (var i = 0; i < implementedTypes.length; i++) {
+                if (implementedTypes[i].hasBase(potentialBase, visited)) {
+                    return true;
+                }
+            }
+
+            visited.pop();
+
+            return false;
+        };
+
+        PullTypeSymbol.prototype.isValidBaseKind = function (baseType, isExtendedType) {
+            if (baseType.isError()) {
+                return false;
+            }
+
+            var thisIsClass = this.isClass();
+            if (isExtendedType) {
+                if (thisIsClass) {
+                    return baseType.kind === 8 /* Class */;
+                }
+            } else {
+                if (!thisIsClass) {
+                    return false;
+                }
+            }
+
+            return !!(baseType.kind & (16 /* Interface */ | 8 /* Class */));
+        };
+
+        PullTypeSymbol.prototype.findMember = function (name, lookInParent) {
+            var memberSymbol = null;
+
+            if (this._memberNameCache) {
+                memberSymbol = this._memberNameCache[name];
+            }
+
+            if (memberSymbol || !lookInParent) {
+                return memberSymbol;
+            }
+
+            if (this._extendedTypes) {
+                for (var i = 0; i < this._extendedTypes.length; i++) {
+                    memberSymbol = this._extendedTypes[i].findMember(name, lookInParent);
+
+                    if (memberSymbol) {
+                        return memberSymbol;
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        PullTypeSymbol.prototype.findNestedType = function (name, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            var memberSymbol;
+
+            if (!this._enclosedTypeNameCache) {
+                return null;
+            }
+
+            memberSymbol = this._enclosedTypeNameCache[name];
+
+            if (memberSymbol && kind !== 0 /* None */) {
+                memberSymbol = TypeScript.hasFlag(memberSymbol.kind, kind) ? memberSymbol : null;
+            }
+
+            return memberSymbol;
+        };
+
+        PullTypeSymbol.prototype.findNestedContainer = function (name, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            var memberSymbol;
+
+            if (!this._enclosedContainerCache) {
+                return null;
+            }
+
+            memberSymbol = this._enclosedContainerCache[name];
+
+            if (memberSymbol && kind !== 0 /* None */) {
+                memberSymbol = TypeScript.hasFlag(memberSymbol.kind, kind) ? memberSymbol : null;
+            }
+
+            return memberSymbol;
+        };
+
+        PullTypeSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisiblity) {
+            var allMembers = [];
+
+            if (this._members !== TypeScript.sentinelEmptyArray) {
+                for (var i = 0, n = this._members.length; i < n; i++) {
+                    var member = this._members[i];
+                    if ((member.kind & searchDeclKind) && (memberVisiblity !== 2 /* externallyVisible */ || !member.anyDeclHasFlag(2 /* Private */))) {
+                        allMembers[allMembers.length] = member;
+                    }
+                }
+            }
+
+            if (this._extendedTypes) {
+                var extenedMembersVisibility = memberVisiblity !== 0 /* all */ ? 2 /* externallyVisible */ : 0 /* all */;
+
+                for (var i = 0, n = this._extendedTypes.length; i < n; i++) {
+                    var extendedMembers = this._extendedTypes[i].getAllMembers(searchDeclKind, extenedMembersVisibility);
+
+                    for (var j = 0, m = extendedMembers.length; j < m; j++) {
+                        var extendedMember = extendedMembers[j];
+                        if (!(this._memberNameCache && this._memberNameCache[extendedMember.name])) {
+                            allMembers[allMembers.length] = extendedMember;
+                        }
+                    }
+                }
+            }
+
+            if (this.isContainer()) {
+                if (this._enclosedMemberTypes) {
+                    for (var i = 0; i < this._enclosedMemberTypes.length; i++) {
+                        allMembers[allMembers.length] = this._enclosedMemberTypes[i];
+                    }
+                }
+                if (this._enclosedMemberContainers) {
+                    for (var i = 0; i < this._enclosedMemberContainers.length; i++) {
+                        allMembers[allMembers.length] = this._enclosedMemberContainers[i];
+                    }
+                }
+            }
+
+            return allMembers;
+        };
+
+        PullTypeSymbol.prototype.findTypeParameter = function (name) {
+            if (!this._typeParameterNameCache) {
+                return null;
+            }
+
+            return this._typeParameterNameCache[name];
+        };
+
+        PullTypeSymbol.prototype.setResolved = function () {
+            _super.prototype.setResolved.call(this);
+        };
+
+        PullTypeSymbol.prototype.getNamePartForFullName = function () {
+            var name = _super.prototype.getNamePartForFullName.call(this);
+
+            var typars = this.getTypeArgumentsOrTypeParameters();
+            var typarString = PullSymbol.getTypeParameterString(typars, this, true);
+            return name + typarString;
+        };
+
+        PullTypeSymbol.prototype.getScopedName = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName) {
+            return this.getScopedNameEx(scopeSymbol, skipTypeParametersInName, useConstraintInName, false, false, skipInternalAliasName).toString();
+        };
+
+        PullTypeSymbol.prototype.isNamedTypeSymbol = function () {
+            var kind = this.kind;
+            if (kind === 2 /* Primitive */ || kind === 8 /* Class */ || kind === 4 /* Container */ || kind === 32 /* DynamicModule */ || kind === 128 /* TypeAlias */ || kind === 64 /* Enum */ || kind === 8192 /* TypeParameter */ || ((kind === 16 /* Interface */ || kind === 8388608 /* ObjectType */) && this.name !== "")) {
+                return true;
+            }
+
+            return false;
+        };
+
+        PullTypeSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) {
+            var s = this.getScopedNameEx(scopeSymbol, false, useConstraintInName).toString();
+            return s;
+        };
+
+        PullTypeSymbol.prototype.getScopedNameEx = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, getPrettyTypeName, getTypeParamMarkerInfo, skipInternalAliasName, shouldAllowArrayType) {
+            if (typeof shouldAllowArrayType === "undefined") { shouldAllowArrayType = true; }
+            if (this.isArrayNamedTypeReference() && shouldAllowArrayType) {
+                var elementType = this.getElementType();
+                var elementMemberName = elementType ? (elementType.isArrayNamedTypeReference() || elementType.isNamedTypeSymbol() ? elementType.getScopedNameEx(scopeSymbol, false, false, getPrettyTypeName, getTypeParamMarkerInfo, skipInternalAliasName) : elementType.getMemberTypeNameEx(false, scopeSymbol, getPrettyTypeName)) : TypeScript.MemberName.create("any");
+                return TypeScript.MemberName.create(elementMemberName, "", "[]");
+            }
+
+            if (!this.isNamedTypeSymbol()) {
+                return this.getMemberTypeNameEx(true, scopeSymbol, getPrettyTypeName);
+            }
+
+            if (skipTypeParametersInName) {
+                return TypeScript.MemberName.create(_super.prototype.getScopedName.call(this, scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName));
+            } else {
+                var builder = new TypeScript.MemberNameArray();
+                builder.prefix = _super.prototype.getScopedName.call(this, scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName);
+
+                var typars = this.getTypeArgumentsOrTypeParameters();
+                builder.add(PullSymbol.getTypeParameterStringEx(typars, scopeSymbol, getTypeParamMarkerInfo, useConstraintInName));
+
+                return builder;
+            }
+        };
+
+        PullTypeSymbol.prototype.hasOnlyOverloadCallSignatures = function () {
+            var members = this.getMembers();
+            var callSignatures = this.getCallSignatures();
+            var constructSignatures = this.getConstructSignatures();
+            return members.length === 0 && constructSignatures.length === 0 && callSignatures.length > 1;
+        };
+
+        PullTypeSymbol.prototype.getTypeOfSymbol = function () {
+            var associatedContainerType = this.getAssociatedContainerType();
+            if (associatedContainerType && associatedContainerType.isNamedTypeSymbol()) {
+                return associatedContainerType;
+            }
+
+            var functionSymbol = this.getFunctionSymbol();
+            if (functionSymbol && functionSymbol.kind === 16384 /* Function */ && !TypeScript.PullHelpers.isSymbolLocal(functionSymbol)) {
+                return TypeScript.PullHelpers.isExportedSymbolInClodule(functionSymbol) ? null : functionSymbol;
+            }
+
+            return null;
+        };
+
+        PullTypeSymbol.prototype.getMemberTypeNameEx = function (topLevel, scopeSymbol, getPrettyTypeName) {
+            var members = this.getMembers();
+            var callSignatures = this.getCallSignatures();
+            var constructSignatures = this.getConstructSignatures();
+            var indexSignatures = this.getIndexSignatures();
+
+            var typeOfSymbol = this.getTypeOfSymbol();
+            if (typeOfSymbol) {
+                var nameForTypeOf = typeOfSymbol.getScopedNameEx(scopeSymbol, true);
+                return TypeScript.MemberName.create(nameForTypeOf, "typeof ", "");
+            }
+
+            if (members.length > 0 || callSignatures.length > 0 || constructSignatures.length > 0 || indexSignatures.length > 0) {
+                if (this._inMemberTypeNameEx) {
+                    return TypeScript.MemberName.create("any");
+                }
+
+                this._inMemberTypeNameEx = true;
+
+                var allMemberNames = new TypeScript.MemberNameArray();
+                var curlies = !topLevel || indexSignatures.length !== 0;
+                var delim = "; ";
+                for (var i = 0; i < members.length; i++) {
+                    if (members[i].kind === 65536 /* Method */ && members[i].type.hasOnlyOverloadCallSignatures()) {
+                        var methodCallSignatures = members[i].type.getCallSignatures();
+                        var nameStr = members[i].getDisplayName(scopeSymbol) + (members[i].isOptional ? "?" : "");
+                        ;
+                        var methodMemberNames = PullSignatureSymbol.getSignaturesTypeNameEx(methodCallSignatures, nameStr, false, false, scopeSymbol);
+                        allMemberNames.addAll(methodMemberNames);
+                    } else {
+                        var memberTypeName = members[i].getNameAndTypeNameEx(scopeSymbol);
+                        if (memberTypeName.isArray() && memberTypeName.delim === delim) {
+                            allMemberNames.addAll(memberTypeName.entries);
+                        } else {
+                            allMemberNames.add(memberTypeName);
+                        }
+                    }
+                    curlies = true;
+                }
+
+                var getPrettyFunctionOverload = getPrettyTypeName && !curlies && this.hasOnlyOverloadCallSignatures();
+
+                var signatureCount = callSignatures.length + constructSignatures.length + indexSignatures.length;
+                var useShortFormSignature = !curlies && (signatureCount === 1);
+                var signatureMemberName;
+
+                if (callSignatures.length > 0) {
+                    signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(callSignatures, "", useShortFormSignature, false, scopeSymbol, getPrettyFunctionOverload);
+                    allMemberNames.addAll(signatureMemberName);
+                }
+
+                if (constructSignatures.length > 0) {
+                    signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(constructSignatures, "new", useShortFormSignature, false, scopeSymbol);
+                    allMemberNames.addAll(signatureMemberName);
+                }
+
+                if (indexSignatures.length > 0) {
+                    signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(indexSignatures, "", useShortFormSignature, true, scopeSymbol);
+                    allMemberNames.addAll(signatureMemberName);
+                }
+
+                if ((curlies) || (!getPrettyFunctionOverload && (signatureCount > 1) && topLevel)) {
+                    allMemberNames.prefix = "{ ";
+                    allMemberNames.suffix = "}";
+                    allMemberNames.delim = delim;
+                } else if (allMemberNames.entries.length > 1) {
+                    allMemberNames.delim = delim;
+                }
+
+                this._inMemberTypeNameEx = false;
+
+                return allMemberNames;
+            }
+
+            return TypeScript.MemberName.create("{}");
+        };
+
+        PullTypeSymbol.prototype.getGenerativeTypeClassification = function (enclosingType) {
+            return 2 /* Closed */;
+        };
+
+        PullTypeSymbol.prototype.wrapsSomeTypeParameter = function (typeParameterArgumentMap, skipTypeArgumentCheck) {
+            return this.getWrappingTypeParameterID(typeParameterArgumentMap, skipTypeArgumentCheck) != 0;
+        };
+
+        PullTypeSymbol.prototype.getWrappingTypeParameterID = function (typeParameterArgumentMap, skipTypeArgumentCheck) {
+            var type = this;
+
+            if (type.isTypeParameter()) {
+                if (typeParameterArgumentMap[type.pullSymbolID] || typeParameterArgumentMap[type.getRootSymbol().pullSymbolID]) {
+                    return type.pullSymbolID;
+                }
+
+                var constraint = type.getConstraint();
+                var wrappingTypeParameterID = constraint ? constraint.getWrappingTypeParameterID(typeParameterArgumentMap) : 0;
+                return wrappingTypeParameterID;
+            }
+
+            if (type.inWrapCheck) {
+                return 0;
+            }
+
+            this._wrapsTypeParameterCache = this._wrapsTypeParameterCache || new TypeScript.WrapsTypeParameterCache();
+            var wrappingTypeParameterID = this._wrapsTypeParameterCache.getWrapsTypeParameter(typeParameterArgumentMap);
+            if (wrappingTypeParameterID === undefined) {
+                wrappingTypeParameterID = this.getWrappingTypeParameterIDWorker(typeParameterArgumentMap, skipTypeArgumentCheck);
+
+                this._wrapsTypeParameterCache.setWrapsTypeParameter(typeParameterArgumentMap, wrappingTypeParameterID);
+            }
+            return wrappingTypeParameterID;
+        };
+
+        PullTypeSymbol.prototype.getWrappingTypeParameterIDFromSignatures = function (signatures, typeParameterArgumentMap) {
+            for (var i = 0; i < signatures.length; i++) {
+                var wrappingTypeParameterID = signatures[i].getWrappingTypeParameterID(typeParameterArgumentMap);
+                if (wrappingTypeParameterID !== 0) {
+                    return wrappingTypeParameterID;
+                }
+            }
+
+            return 0;
+        };
+
+        PullTypeSymbol.prototype.getWrappingTypeParameterIDWorker = function (typeParameterArgumentMap, skipTypeArgumentCheck) {
+            var type = this;
+            var wrappingTypeParameterID = 0;
+
+            if (!skipTypeArgumentCheck) {
+                type.inWrapCheck = true;
+
+                var typeArguments = type.getTypeArguments();
+
+                if (type.isGeneric() && !typeArguments) {
+                    typeArguments = type.getTypeParameters();
+                }
+
+                if (typeArguments) {
+                    for (var i = 0; !wrappingTypeParameterID && i < typeArguments.length; i++) {
+                        wrappingTypeParameterID = typeArguments[i].getWrappingTypeParameterID(typeParameterArgumentMap);
+                    }
+                }
+            }
+
+            if (skipTypeArgumentCheck || !(type.kind & 8216 /* SomeInstantiatableType */) || !type.name) {
+                var members = type.getAllMembers(68147712 /* SomeValue */, 0 /* all */);
+                for (var i = 0; !wrappingTypeParameterID && i < members.length; i++) {
+                    TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(members[i]);
+                    wrappingTypeParameterID = members[i].type.getWrappingTypeParameterID(typeParameterArgumentMap);
+                }
+
+                wrappingTypeParameterID = wrappingTypeParameterID || this.getWrappingTypeParameterIDFromSignatures(type.getCallSignatures(), typeParameterArgumentMap) || this.getWrappingTypeParameterIDFromSignatures(type.getConstructSignatures(), typeParameterArgumentMap) || this.getWrappingTypeParameterIDFromSignatures(type.getIndexSignatures(), typeParameterArgumentMap);
+            }
+
+            if (!skipTypeArgumentCheck) {
+                type.inWrapCheck = false;
+            }
+
+            return wrappingTypeParameterID;
+        };
+
+        PullTypeSymbol.prototype.wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReference = function (enclosingType) {
+            TypeScript.Debug.assert(this.isNamedTypeSymbol());
+            TypeScript.Debug.assert(TypeScript.PullHelpers.getRootType(enclosingType) == enclosingType);
+            var knownWrapMap = TypeScript.BitMatrix.getBitMatrix(true);
+            var wrapsIntoInfinitelyExpandingTypeReference = this._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceRecurse(enclosingType, knownWrapMap);
+            knownWrapMap.release();
+            return wrapsIntoInfinitelyExpandingTypeReference;
+        };
+
+        PullTypeSymbol.prototype._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceRecurse = function (enclosingType, knownWrapMap) {
+            var wrapsIntoInfinitelyExpandingTypeReference = knownWrapMap.valueAt(this.pullSymbolID, enclosingType.pullSymbolID);
+            if (wrapsIntoInfinitelyExpandingTypeReference != undefined) {
+                return wrapsIntoInfinitelyExpandingTypeReference;
+            }
+
+            if (this.inWrapInfiniteExpandingReferenceCheck) {
+                return false;
+            }
+
+            this.inWrapInfiniteExpandingReferenceCheck = true;
+            wrapsIntoInfinitelyExpandingTypeReference = this._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceWorker(enclosingType, knownWrapMap);
+            knownWrapMap.setValueAt(this.pullSymbolID, enclosingType.pullSymbolID, wrapsIntoInfinitelyExpandingTypeReference);
+            this.inWrapInfiniteExpandingReferenceCheck = false;
+
+            return wrapsIntoInfinitelyExpandingTypeReference;
+        };
+
+        PullTypeSymbol.prototype._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceWorker = function (enclosingType, knownWrapMap) {
+            var thisRootType = TypeScript.PullHelpers.getRootType(this);
+
+            if (thisRootType != enclosingType) {
+                var thisIsNamedType = this.isNamedTypeSymbol();
+
+                if (thisIsNamedType) {
+                    if (thisRootType.inWrapInfiniteExpandingReferenceCheck) {
+                        return false;
+                    }
+
+                    thisRootType.inWrapInfiniteExpandingReferenceCheck = true;
+                }
+
+                var wrapsIntoInfinitelyExpandingTypeReference = this._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceStructure(enclosingType, knownWrapMap);
+
+                if (thisIsNamedType) {
+                    thisRootType.inWrapInfiniteExpandingReferenceCheck = false;
+                }
+
+                return wrapsIntoInfinitelyExpandingTypeReference;
+            }
+
+            var enclosingTypeParameters = enclosingType.getTypeParameters();
+            var typeArguments = this.getTypeArguments();
+            for (var i = 0; i < typeArguments.length; i++) {
+                if (TypeScript.ArrayUtilities.contains(enclosingTypeParameters, typeArguments[i])) {
+                    continue;
+                }
+
+                if (typeArguments[i].wrapsSomeTypeParameter(this.getTypeParameterArgumentMap())) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeSymbol.prototype._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceStructure = function (enclosingType, knownWrapMap) {
+            var members = this.getAllMembers(68147712 /* SomeValue */, 0 /* all */);
+            for (var i = 0; i < members.length; i++) {
+                if (members[i].type && members[i].type._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceRecurse(enclosingType, knownWrapMap)) {
+                    return true;
+                }
+            }
+
+            var sigs = this.getCallSignatures();
+            for (var i = 0; i < sigs.length; i++) {
+                if (sigs[i]._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReference(enclosingType, knownWrapMap)) {
+                    return true;
+                }
+            }
+
+            sigs = this.getConstructSignatures();
+            for (var i = 0; i < sigs.length; i++) {
+                if (sigs[i]._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReference(enclosingType, knownWrapMap)) {
+                    return true;
+                }
+            }
+
+            sigs = this.getIndexSignatures();
+            for (var i = 0; i < sigs.length; i++) {
+                if (sigs[i]._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReference(enclosingType, knownWrapMap)) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeSymbol.prototype.widenedType = function (resolver, ast, context) {
+            if (!this._widenedType) {
+                this._widenedType = resolver.widenType(this, ast, context);
+            }
+            return this._widenedType;
+        };
+        return PullTypeSymbol;
+    })(PullSymbol);
+    TypeScript.PullTypeSymbol = PullTypeSymbol;
+
+    var PullPrimitiveTypeSymbol = (function (_super) {
+        __extends(PullPrimitiveTypeSymbol, _super);
+        function PullPrimitiveTypeSymbol(name) {
+            _super.call(this, name, 2 /* Primitive */);
+
+            this.isResolved = true;
+        }
+        PullPrimitiveTypeSymbol.prototype.isAny = function () {
+            return !this.isStringConstant() && this.name === "any";
+        };
+
+        PullPrimitiveTypeSymbol.prototype.isNull = function () {
+            return !this.isStringConstant() && this.name === "null";
+        };
+
+        PullPrimitiveTypeSymbol.prototype.isUndefined = function () {
+            return !this.isStringConstant() && this.name === "undefined";
+        };
+
+        PullPrimitiveTypeSymbol.prototype.isStringConstant = function () {
+            return false;
+        };
+
+        PullPrimitiveTypeSymbol.prototype.setUnresolved = function () {
+        };
+
+        PullPrimitiveTypeSymbol.prototype.getDisplayName = function () {
+            if (this.isNull() || this.isUndefined()) {
+                return "any";
+            } else {
+                return _super.prototype.getDisplayName.call(this);
+            }
+        };
+        return PullPrimitiveTypeSymbol;
+    })(PullTypeSymbol);
+    TypeScript.PullPrimitiveTypeSymbol = PullPrimitiveTypeSymbol;
+
+    var PullStringConstantTypeSymbol = (function (_super) {
+        __extends(PullStringConstantTypeSymbol, _super);
+        function PullStringConstantTypeSymbol(name) {
+            _super.call(this, name);
+        }
+        PullStringConstantTypeSymbol.prototype.isStringConstant = function () {
+            return true;
+        };
+        return PullStringConstantTypeSymbol;
+    })(PullPrimitiveTypeSymbol);
+    TypeScript.PullStringConstantTypeSymbol = PullStringConstantTypeSymbol;
+
+    var PullErrorTypeSymbol = (function (_super) {
+        __extends(PullErrorTypeSymbol, _super);
+        function PullErrorTypeSymbol(_anyType, name) {
+            _super.call(this, name);
+            this._anyType = _anyType;
+
+            TypeScript.Debug.assert(this._anyType);
+            this.isResolved = true;
+        }
+        PullErrorTypeSymbol.prototype.isError = function () {
+            return true;
+        };
+
+        PullErrorTypeSymbol.prototype._getResolver = function () {
+            return this._anyType._getResolver();
+        };
+
+        PullErrorTypeSymbol.prototype.getName = function (scopeSymbol, useConstraintInName) {
+            return this._anyType.getName(scopeSymbol, useConstraintInName);
+        };
+
+        PullErrorTypeSymbol.prototype.getDisplayName = function (scopeSymbol, useConstraintInName, skipInternalAliasName) {
+            return this._anyType.getName(scopeSymbol, useConstraintInName);
+        };
+
+        PullErrorTypeSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) {
+            return this._anyType.getName(scopeSymbol, useConstraintInName);
+        };
+        return PullErrorTypeSymbol;
+    })(PullPrimitiveTypeSymbol);
+    TypeScript.PullErrorTypeSymbol = PullErrorTypeSymbol;
+
+    var PullContainerSymbol = (function (_super) {
+        __extends(PullContainerSymbol, _super);
+        function PullContainerSymbol(name, kind) {
+            _super.call(this, name, kind);
+            this.instanceSymbol = null;
+            this.assignedValue = null;
+            this.assignedType = null;
+            this.assignedContainer = null;
+        }
+        PullContainerSymbol.prototype.isContainer = function () {
+            return true;
+        };
+
+        PullContainerSymbol.prototype.setInstanceSymbol = function (symbol) {
+            this.instanceSymbol = symbol;
+        };
+
+        PullContainerSymbol.prototype.getInstanceSymbol = function () {
+            return this.instanceSymbol;
+        };
+
+        PullContainerSymbol.prototype.setExportAssignedValueSymbol = function (symbol) {
+            this.assignedValue = symbol;
+        };
+
+        PullContainerSymbol.prototype.getExportAssignedValueSymbol = function () {
+            return this.assignedValue;
+        };
+
+        PullContainerSymbol.prototype.setExportAssignedTypeSymbol = function (type) {
+            this.assignedType = type;
+        };
+
+        PullContainerSymbol.prototype.getExportAssignedTypeSymbol = function () {
+            return this.assignedType;
+        };
+
+        PullContainerSymbol.prototype.setExportAssignedContainerSymbol = function (container) {
+            this.assignedContainer = container;
+        };
+
+        PullContainerSymbol.prototype.getExportAssignedContainerSymbol = function () {
+            return this.assignedContainer;
+        };
+
+        PullContainerSymbol.prototype.hasExportAssignment = function () {
+            return !!this.assignedValue || !!this.assignedType || !!this.assignedContainer;
+        };
+
+        PullContainerSymbol.usedAsSymbol = function (containerSymbol, symbol) {
+            if (!containerSymbol || !containerSymbol.isContainer()) {
+                return false;
+            }
+
+            if (!containerSymbol.isAlias() && containerSymbol.type === symbol) {
+                return true;
+            }
+
+            var moduleSymbol = containerSymbol;
+            var valueExportSymbol = moduleSymbol.getExportAssignedValueSymbol();
+            var typeExportSymbol = moduleSymbol.getExportAssignedTypeSymbol();
+            var containerExportSymbol = moduleSymbol.getExportAssignedContainerSymbol();
+            if (valueExportSymbol || typeExportSymbol || containerExportSymbol) {
+                return valueExportSymbol === symbol || typeExportSymbol == symbol || containerExportSymbol == symbol || PullContainerSymbol.usedAsSymbol(containerExportSymbol, symbol);
+            }
+
+            return false;
+        };
+
+        PullContainerSymbol.prototype.getInstanceType = function () {
+            return this.instanceSymbol ? this.instanceSymbol.type : null;
+        };
+        return PullContainerSymbol;
+    })(PullTypeSymbol);
+    TypeScript.PullContainerSymbol = PullContainerSymbol;
+
+    var PullTypeAliasSymbol = (function (_super) {
+        __extends(PullTypeAliasSymbol, _super);
+        function PullTypeAliasSymbol(name) {
+            _super.call(this, name, 128 /* TypeAlias */);
+            this._assignedValue = null;
+            this._assignedType = null;
+            this._assignedContainer = null;
+            this._isUsedAsValue = false;
+            this._typeUsedExternally = false;
+            this._isUsedInExportAlias = false;
+            this.retrievingExportAssignment = false;
+            this.linkedAliasSymbols = null;
+        }
+        PullTypeAliasSymbol.prototype.isUsedInExportedAlias = function () {
+            this._resolveDeclaredSymbol();
+            return this._isUsedInExportAlias;
+        };
+
+        PullTypeAliasSymbol.prototype.typeUsedExternally = function () {
+            this._resolveDeclaredSymbol();
+            return this._typeUsedExternally;
+        };
+
+        PullTypeAliasSymbol.prototype.isUsedAsValue = function () {
+            this._resolveDeclaredSymbol();
+            return this._isUsedAsValue;
+        };
+
+        PullTypeAliasSymbol.prototype.setTypeUsedExternally = function () {
+            this._typeUsedExternally = true;
+        };
+
+        PullTypeAliasSymbol.prototype.setIsUsedInExportedAlias = function () {
+            this._isUsedInExportAlias = true;
+            if (this.linkedAliasSymbols) {
+                this.linkedAliasSymbols.forEach(function (s) {
+                    return s.setIsUsedInExportedAlias();
+                });
+            }
+        };
+
+        PullTypeAliasSymbol.prototype.addLinkedAliasSymbol = function (contingentValueSymbol) {
+            if (!this.linkedAliasSymbols) {
+                this.linkedAliasSymbols = [contingentValueSymbol];
+            } else {
+                this.linkedAliasSymbols.push(contingentValueSymbol);
+            }
+        };
+
+        PullTypeAliasSymbol.prototype.setIsUsedAsValue = function () {
+            this._isUsedAsValue = true;
+            if (this.linkedAliasSymbols) {
+                this.linkedAliasSymbols.forEach(function (s) {
+                    return s.setIsUsedAsValue();
+                });
+            }
+        };
+
+        PullTypeAliasSymbol.prototype.assignedValue = function () {
+            this._resolveDeclaredSymbol();
+            return this._assignedValue;
+        };
+
+        PullTypeAliasSymbol.prototype.assignedType = function () {
+            this._resolveDeclaredSymbol();
+            return this._assignedType;
+        };
+
+        PullTypeAliasSymbol.prototype.assignedContainer = function () {
+            this._resolveDeclaredSymbol();
+            return this._assignedContainer;
+        };
+
+        PullTypeAliasSymbol.prototype.isAlias = function () {
+            return true;
+        };
+        PullTypeAliasSymbol.prototype.isContainer = function () {
+            return true;
+        };
+
+        PullTypeAliasSymbol.prototype.setAssignedValueSymbol = function (symbol) {
+            this._assignedValue = symbol;
+        };
+
+        PullTypeAliasSymbol.prototype.getExportAssignedValueSymbol = function () {
+            if (this._assignedValue) {
+                return this._assignedValue;
+            }
+
+            if (this.retrievingExportAssignment) {
+                return null;
+            }
+
+            if (this._assignedContainer) {
+                if (this._assignedContainer.hasExportAssignment()) {
+                    this.retrievingExportAssignment = true;
+                    var sym = this._assignedContainer.getExportAssignedValueSymbol();
+                    this.retrievingExportAssignment = false;
+                    return sym;
+                }
+
+                return this._assignedContainer.getInstanceSymbol();
+            }
+
+            return null;
+        };
+
+        PullTypeAliasSymbol.prototype.setAssignedTypeSymbol = function (type) {
+            this._assignedType = type;
+        };
+
+        PullTypeAliasSymbol.prototype.getExportAssignedTypeSymbol = function () {
+            if (this.retrievingExportAssignment) {
+                return null;
+            }
+
+            if (this._assignedType) {
+                if (this._assignedType.isAlias()) {
+                    this.retrievingExportAssignment = true;
+                    var sym = this._assignedType.getExportAssignedTypeSymbol();
+                    this.retrievingExportAssignment = false;
+                } else if (this._assignedType !== this._assignedContainer) {
+                    return this._assignedType;
+                }
+            }
+
+            if (this._assignedContainer) {
+                this.retrievingExportAssignment = true;
+                var sym = this._assignedContainer.getExportAssignedTypeSymbol();
+                this.retrievingExportAssignment = false;
+                if (sym) {
+                    return sym;
+                }
+            }
+
+            return this._assignedContainer;
+        };
+
+        PullTypeAliasSymbol.prototype.setAssignedContainerSymbol = function (container) {
+            this._assignedContainer = container;
+        };
+
+        PullTypeAliasSymbol.prototype.getExportAssignedContainerSymbol = function () {
+            if (this.retrievingExportAssignment) {
+                return null;
+            }
+
+            if (this._assignedContainer) {
+                this.retrievingExportAssignment = true;
+                var sym = this._assignedContainer.getExportAssignedContainerSymbol();
+                this.retrievingExportAssignment = false;
+                if (sym) {
+                    return sym;
+                }
+            }
+
+            return this._assignedContainer;
+        };
+
+        PullTypeAliasSymbol.prototype.getMembers = function () {
+            if (this._assignedType) {
+                return this._assignedType.getMembers();
+            }
+
+            return TypeScript.sentinelEmptyArray;
+        };
+
+        PullTypeAliasSymbol.prototype.getCallSignatures = function () {
+            if (this._assignedType) {
+                return this._assignedType.getCallSignatures();
+            }
+
+            return TypeScript.sentinelEmptyArray;
+        };
+
+        PullTypeAliasSymbol.prototype.getConstructSignatures = function () {
+            if (this._assignedType) {
+                return this._assignedType.getConstructSignatures();
+            }
+
+            return TypeScript.sentinelEmptyArray;
+        };
+
+        PullTypeAliasSymbol.prototype.getIndexSignatures = function () {
+            if (this._assignedType) {
+                return this._assignedType.getIndexSignatures();
+            }
+
+            return TypeScript.sentinelEmptyArray;
+        };
+
+        PullTypeAliasSymbol.prototype.findMember = function (name) {
+            if (this._assignedType) {
+                return this._assignedType.findMember(name, true);
+            }
+
+            return null;
+        };
+
+        PullTypeAliasSymbol.prototype.findNestedType = function (name) {
+            if (this._assignedType) {
+                return this._assignedType.findNestedType(name);
+            }
+
+            return null;
+        };
+
+        PullTypeAliasSymbol.prototype.findNestedContainer = function (name) {
+            if (this._assignedType) {
+                return this._assignedType.findNestedContainer(name);
+            }
+
+            return null;
+        };
+
+        PullTypeAliasSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisibility) {
+            if (this._assignedType) {
+                return this._assignedType.getAllMembers(searchDeclKind, memberVisibility);
+            }
+
+            return TypeScript.sentinelEmptyArray;
+        };
+        return PullTypeAliasSymbol;
+    })(PullTypeSymbol);
+    TypeScript.PullTypeAliasSymbol = PullTypeAliasSymbol;
+
+    var PullTypeParameterSymbol = (function (_super) {
+        __extends(PullTypeParameterSymbol, _super);
+        function PullTypeParameterSymbol(name) {
+            _super.call(this, name, 8192 /* TypeParameter */);
+            this._constraint = null;
+        }
+        PullTypeParameterSymbol.prototype.isTypeParameter = function () {
+            return true;
+        };
+
+        PullTypeParameterSymbol.prototype.setConstraint = function (constraintType) {
+            this._constraint = constraintType;
+        };
+
+        PullTypeParameterSymbol.prototype.getConstraint = function () {
+            return this._constraint;
+        };
+
+        PullTypeParameterSymbol.prototype.getBaseConstraint = function (semanticInfoChain) {
+            var preBaseConstraint = this.getConstraintRecursively({});
+            TypeScript.Debug.assert(preBaseConstraint === null || !preBaseConstraint.isTypeParameter());
+            return preBaseConstraint || semanticInfoChain.emptyTypeSymbol;
+        };
+
+        PullTypeParameterSymbol.prototype.getConstraintRecursively = function (visitedTypeParameters) {
+            var constraint = this.getConstraint();
+
+            if (constraint) {
+                if (constraint.isTypeParameter()) {
+                    var constraintAsTypeParameter = constraint;
+                    if (!visitedTypeParameters[constraintAsTypeParameter.pullSymbolID]) {
+                        visitedTypeParameters[constraintAsTypeParameter.pullSymbolID] = constraintAsTypeParameter;
+                        return constraintAsTypeParameter.getConstraintRecursively(visitedTypeParameters);
+                    }
+                } else {
+                    return constraint;
+                }
+            }
+
+            return null;
+        };
+
+        PullTypeParameterSymbol.prototype.getDefaultConstraint = function (semanticInfoChain) {
+            return this._constraint || semanticInfoChain.emptyTypeSymbol;
+        };
+
+        PullTypeParameterSymbol.prototype.getCallSignatures = function () {
+            if (this._constraint) {
+                return this._constraint.getCallSignatures();
+            }
+
+            return _super.prototype.getCallSignatures.call(this);
+        };
+
+        PullTypeParameterSymbol.prototype.getConstructSignatures = function () {
+            if (this._constraint) {
+                return this._constraint.getConstructSignatures();
+            }
+
+            return _super.prototype.getConstructSignatures.call(this);
+        };
+
+        PullTypeParameterSymbol.prototype.getIndexSignatures = function () {
+            if (this._constraint) {
+                return this._constraint.getIndexSignatures();
+            }
+
+            return _super.prototype.getIndexSignatures.call(this);
+        };
+
+        PullTypeParameterSymbol.prototype.isGeneric = function () {
+            return true;
+        };
+
+        PullTypeParameterSymbol.prototype.fullName = function (scopeSymbol) {
+            var name = this.getDisplayName(scopeSymbol);
+            var container = this.getContainer();
+            if (container) {
+                var containerName = container.fullName(scopeSymbol);
+                name = name + " in " + containerName;
+            }
+
+            return name;
+        };
+
+        PullTypeParameterSymbol.prototype.getName = function (scopeSymbol, useConstraintInName) {
+            var name = _super.prototype.getName.call(this, scopeSymbol);
+
+            if (this.isPrinting) {
+                return name;
+            }
+
+            this.isPrinting = true;
+
+            if (useConstraintInName && this._constraint) {
+                name += " extends " + this._constraint.toString(scopeSymbol);
+            }
+
+            this.isPrinting = false;
+
+            return name;
+        };
+
+        PullTypeParameterSymbol.prototype.getDisplayName = function (scopeSymbol, useConstraintInName, skipInternalAliasName) {
+            var name = _super.prototype.getDisplayName.call(this, scopeSymbol, useConstraintInName, skipInternalAliasName);
+
+            if (this.isPrinting) {
+                return name;
+            }
+
+            this.isPrinting = true;
+
+            if (useConstraintInName && this._constraint) {
+                name += " extends " + this._constraint.toString(scopeSymbol);
+            }
+
+            this.isPrinting = false;
+
+            return name;
+        };
+
+        PullTypeParameterSymbol.prototype.isExternallyVisible = function (inIsExternallyVisibleSymbols) {
+            return true;
+        };
+        return PullTypeParameterSymbol;
+    })(PullTypeSymbol);
+    TypeScript.PullTypeParameterSymbol = PullTypeParameterSymbol;
+
+    var PullAccessorSymbol = (function (_super) {
+        __extends(PullAccessorSymbol, _super);
+        function PullAccessorSymbol(name) {
+            _super.call(this, name, 4096 /* Property */);
+            this._getterSymbol = null;
+            this._setterSymbol = null;
+        }
+        PullAccessorSymbol.prototype.isAccessor = function () {
+            return true;
+        };
+
+        PullAccessorSymbol.prototype.setSetter = function (setter) {
+            if (!setter) {
+                return;
+            }
+
+            this._setterSymbol = setter;
+        };
+
+        PullAccessorSymbol.prototype.getSetter = function () {
+            return this._setterSymbol;
+        };
+
+        PullAccessorSymbol.prototype.setGetter = function (getter) {
+            if (!getter) {
+                return;
+            }
+
+            this._getterSymbol = getter;
+        };
+
+        PullAccessorSymbol.prototype.getGetter = function () {
+            return this._getterSymbol;
+        };
+        return PullAccessorSymbol;
+    })(PullSymbol);
+    TypeScript.PullAccessorSymbol = PullAccessorSymbol;
+
+    function getIDForTypeSubstitutions(instantiatingTypeOrSignature, typeArgumentMap) {
+        var substitution = "";
+        var members = null;
+
+        var allowedToReferenceTypeParameters = instantiatingTypeOrSignature.getAllowedToReferenceTypeParameters();
+        for (var i = 0; i < allowedToReferenceTypeParameters.length; i++) {
+            var typeParameter = allowedToReferenceTypeParameters[i];
+            var typeParameterID = typeParameter.pullSymbolID;
+            var typeArg = typeArgumentMap[typeParameterID];
+            if (!typeArg) {
+                typeArg = typeParameter;
+            }
+            substitution += typeParameterID + ":" + getIDForTypeSubstitutionsOfType(typeArg);
+        }
+
+        return substitution;
+    }
+    TypeScript.getIDForTypeSubstitutions = getIDForTypeSubstitutions;
+
+    function getIDForTypeSubstitutionsOfType(type) {
+        var structure;
+        if (type.isError()) {
+            structure = "E" + getIDForTypeSubstitutionsOfType(type._anyType);
+        } else if (!type.isNamedTypeSymbol()) {
+            structure = getIDForTypeSubstitutionsFromObjectType(type);
+        }
+
+        if (!structure) {
+            structure = type.pullSymbolID + "#";
+        }
+
+        return structure;
+    }
+
+    function getIDForTypeSubstitutionsFromObjectType(type) {
+        if (type.isResolved) {
+            var getIDForTypeSubStitutionWalker = new GetIDForTypeSubStitutionWalker();
+            TypeScript.PullHelpers.walkPullTypeSymbolStructure(type, getIDForTypeSubStitutionWalker);
+        }
+
+        return null;
+    }
+
+    var GetIDForTypeSubStitutionWalker = (function () {
+        function GetIDForTypeSubStitutionWalker() {
+            this.structure = "";
+        }
+        GetIDForTypeSubStitutionWalker.prototype.memberSymbolWalk = function (memberSymbol) {
+            this.structure += memberSymbol.name + "@" + getIDForTypeSubstitutionsOfType(memberSymbol.type);
+            return true;
+        };
+        GetIDForTypeSubStitutionWalker.prototype.callSignatureWalk = function (signatureSymbol) {
+            this.structure += "(";
+            return true;
+        };
+        GetIDForTypeSubStitutionWalker.prototype.constructSignatureWalk = function (signatureSymbol) {
+            this.structure += "new(";
+            return true;
+        };
+        GetIDForTypeSubStitutionWalker.prototype.indexSignatureWalk = function (signatureSymbol) {
+            this.structure += "[](";
+            return true;
+        };
+        GetIDForTypeSubStitutionWalker.prototype.signatureParameterWalk = function (parameterSymbol) {
+            this.structure += parameterSymbol.name + "@" + getIDForTypeSubstitutionsOfType(parameterSymbol.type);
+            return true;
+        };
+        GetIDForTypeSubStitutionWalker.prototype.signatureReturnTypeWalk = function (returnType) {
+            this.structure += ")" + getIDForTypeSubstitutionsOfType(returnType);
+            return true;
+        };
+        return GetIDForTypeSubStitutionWalker;
+    })();
+
+    (function (GetAllMembersVisiblity) {
+        GetAllMembersVisiblity[GetAllMembersVisiblity["all"] = 0] = "all";
+
+        GetAllMembersVisiblity[GetAllMembersVisiblity["internallyVisible"] = 1] = "internallyVisible";
+
+        GetAllMembersVisiblity[GetAllMembersVisiblity["externallyVisible"] = 2] = "externallyVisible";
+    })(TypeScript.GetAllMembersVisiblity || (TypeScript.GetAllMembersVisiblity = {}));
+    var GetAllMembersVisiblity = TypeScript.GetAllMembersVisiblity;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var PullTypeEnclosingTypeWalker = (function () {
+        function PullTypeEnclosingTypeWalker() {
+            this.currentSymbols = null;
+        }
+        PullTypeEnclosingTypeWalker.prototype.getEnclosingType = function () {
+            if (this.currentSymbols && this.currentSymbols.length > 0) {
+                return this.currentSymbols[0];
+            }
+
+            return null;
+        };
+
+        PullTypeEnclosingTypeWalker.prototype._canWalkStructure = function () {
+            var enclosingType = this.getEnclosingType();
+            return !!enclosingType && enclosingType.isGeneric();
+        };
+
+        PullTypeEnclosingTypeWalker.prototype._getCurrentSymbol = function () {
+            if (this.currentSymbols && this.currentSymbols.length) {
+                return this.currentSymbols[this.currentSymbols.length - 1];
+            }
+
+            return null;
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.getGenerativeClassification = function () {
+            if (this._canWalkStructure()) {
+                var currentType = this.currentSymbols[this.currentSymbols.length - 1];
+                if (!currentType) {
+                    return 0 /* Unknown */;
+                }
+
+                var variableNeededToFixNodeJitterBug = this.getEnclosingType();
+
+                return currentType.getGenerativeTypeClassification(variableNeededToFixNodeJitterBug);
+            }
+
+            return 2 /* Closed */;
+        };
+
+        PullTypeEnclosingTypeWalker.prototype._pushSymbol = function (symbol) {
+            return this.currentSymbols.push(symbol);
+        };
+
+        PullTypeEnclosingTypeWalker.prototype._popSymbol = function () {
+            return this.currentSymbols.pop();
+        };
+
+        PullTypeEnclosingTypeWalker.prototype._setEnclosingTypeOfParentDecl = function (decl, setSignature) {
+            var parentDecl = decl.getParentDecl();
+            if (parentDecl) {
+                if (parentDecl.kind & 8216 /* SomeInstantiatableType */) {
+                    this._setEnclosingTypeWorker(parentDecl.getSymbol(), true);
+                } else {
+                    this._setEnclosingTypeOfParentDecl(parentDecl, true);
+                }
+
+                if (this._canWalkStructure()) {
+                    var symbol = decl.getSymbol();
+                    if (symbol) {
+                        if (!symbol.isType() && !symbol.isSignature()) {
+                            symbol = symbol.type;
+                        }
+
+                        this._pushSymbol(symbol);
+                    }
+
+                    if (setSignature) {
+                        var signature = decl.getSignatureSymbol();
+                        if (signature) {
+                            this._pushSymbol(signature);
+                        }
+                    }
+                }
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype._setEnclosingTypeWorker = function (symbol, setSignature) {
+            if (symbol.isType() && symbol.isNamedTypeSymbol()) {
+                this.currentSymbols = [TypeScript.PullHelpers.getRootType(symbol)];
+                return;
+            }
+
+            var decls = symbol.getDeclarations();
+            for (var i = 0; i < decls.length; i++) {
+                var decl = decls[i];
+                this._setEnclosingTypeOfParentDecl(decl, setSignature);
+                if (this._canWalkStructure()) {
+                    return;
+                }
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.setCurrentSymbol = function (symbol) {
+            TypeScript.Debug.assert(this._canWalkStructure());
+            this.currentSymbols[this.currentSymbols.length - 1] = symbol;
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.startWalkingType = function (symbol) {
+            var currentSymbols = this.currentSymbols;
+
+            var setEnclosingType = !this.getEnclosingType() || symbol.isNamedTypeSymbol();
+            if (setEnclosingType) {
+                this.currentSymbols = null;
+                this.setEnclosingType(symbol);
+            }
+            return currentSymbols;
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.endWalkingType = function (currentSymbolsWhenStartedWalkingTypes) {
+            this.currentSymbols = currentSymbolsWhenStartedWalkingTypes;
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.setEnclosingType = function (symbol) {
+            TypeScript.Debug.assert(!this.getEnclosingType());
+            this._setEnclosingTypeWorker(symbol, symbol.isSignature());
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.walkMemberType = function (memberName, resolver) {
+            if (this._canWalkStructure()) {
+                var currentType = this._getCurrentSymbol();
+                var memberSymbol = currentType ? resolver._getNamedPropertySymbolOfAugmentedType(memberName, currentType) : null;
+                this._pushSymbol(memberSymbol ? memberSymbol.type : null);
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.postWalkMemberType = function () {
+            if (this._canWalkStructure()) {
+                this._popSymbol();
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.walkSignature = function (kind, index) {
+            if (this._canWalkStructure()) {
+                var currentType = this._getCurrentSymbol();
+                var signatures;
+                if (currentType) {
+                    if (kind == 1048576 /* CallSignature */) {
+                        signatures = currentType.getCallSignatures();
+                    } else if (kind == 2097152 /* ConstructSignature */) {
+                        signatures = currentType.getConstructSignatures();
+                    } else {
+                        signatures = currentType.getIndexSignatures();
+                    }
+                }
+
+                this._pushSymbol(signatures ? signatures[index] : null);
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.postWalkSignature = function () {
+            if (this._canWalkStructure()) {
+                this._popSymbol();
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.walkTypeArgument = function (index) {
+            if (this._canWalkStructure()) {
+                var typeArgument = null;
+                var currentType = this._getCurrentSymbol();
+                if (currentType) {
+                    var typeArguments = currentType.getTypeArguments();
+                    typeArgument = typeArguments ? typeArguments[index] : null;
+                }
+                this._pushSymbol(typeArgument);
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.postWalkTypeArgument = function () {
+            if (this._canWalkStructure()) {
+                this._popSymbol();
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.walkTypeParameterConstraint = function (index) {
+            if (this._canWalkStructure()) {
+                var typeParameters;
+                var currentSymbol = this._getCurrentSymbol();
+                if (currentSymbol) {
+                    if (currentSymbol.isSignature()) {
+                        typeParameters = currentSymbol.getTypeParameters();
+                    } else {
+                        TypeScript.Debug.assert(currentSymbol.isType());
+                        typeParameters = currentSymbol.getTypeParameters();
+                    }
+                }
+                this._pushSymbol(typeParameters ? typeParameters[index].getConstraint() : null);
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.postWalkTypeParameterConstraint = function () {
+            if (this._canWalkStructure()) {
+                this._popSymbol();
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.walkReturnType = function () {
+            if (this._canWalkStructure()) {
+                var currentSignature = this._getCurrentSymbol();
+                this._pushSymbol(currentSignature ? currentSignature.returnType : null);
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.postWalkReturnType = function () {
+            if (this._canWalkStructure()) {
+                this._popSymbol();
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.walkParameterType = function (iParam) {
+            if (this._canWalkStructure()) {
+                var currentSignature = this._getCurrentSymbol();
+                this._pushSymbol(currentSignature ? currentSignature.getParameterTypeAtIndex(iParam) : null);
+            }
+        };
+        PullTypeEnclosingTypeWalker.prototype.postWalkParameterType = function () {
+            if (this._canWalkStructure()) {
+                this._popSymbol();
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.getBothKindOfIndexSignatures = function (resolver, context, includeAugmentedType) {
+            if (this._canWalkStructure()) {
+                var currentType = this._getCurrentSymbol();
+                if (currentType) {
+                    return resolver._getBothKindsOfIndexSignatures(currentType, context, includeAugmentedType);
+                }
+            }
+            return null;
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.walkIndexSignatureReturnType = function (indexSigInfo, useStringIndexSignature, onlySignature) {
+            if (this._canWalkStructure()) {
+                var indexSig = indexSigInfo ? (useStringIndexSignature ? indexSigInfo.stringSignature : indexSigInfo.numericSignature) : null;
+                this._pushSymbol(indexSig);
+                if (!onlySignature) {
+                    this._pushSymbol(indexSig ? indexSig.returnType : null);
+                }
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.postWalkIndexSignatureReturnType = function (onlySignature) {
+            if (this._canWalkStructure()) {
+                if (!onlySignature) {
+                    this._popSymbol();
+                }
+                this._popSymbol();
+            }
+        };
+        return PullTypeEnclosingTypeWalker;
+    })();
+    TypeScript.PullTypeEnclosingTypeWalker = PullTypeEnclosingTypeWalker;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var CandidateInferenceInfo = (function () {
+        function CandidateInferenceInfo() {
+            this.typeParameter = null;
+            this._inferredTypeAfterFixing = null;
+            this.inferenceCandidates = [];
+        }
+        CandidateInferenceInfo.prototype.addCandidate = function (candidate) {
+            if (!this._inferredTypeAfterFixing) {
+                this.inferenceCandidates[this.inferenceCandidates.length] = candidate;
+            }
+        };
+
+        CandidateInferenceInfo.prototype.isFixed = function () {
+            return !!this._inferredTypeAfterFixing;
+        };
+
+        CandidateInferenceInfo.prototype.fixTypeParameter = function (resolver, context) {
+            var _this = this;
+            if (!this._inferredTypeAfterFixing) {
+                var collection = {
+                    getLength: function () {
+                        return _this.inferenceCandidates.length;
+                    },
+                    getTypeAtIndex: function (index) {
+                        return _this.inferenceCandidates[index].type;
+                    }
+                };
+
+                var bestCommonType = resolver.findBestCommonType(collection, context, new TypeScript.TypeComparisonInfo());
+                this._inferredTypeAfterFixing = bestCommonType.widenedType(resolver, null, context);
+            }
+        };
+        return CandidateInferenceInfo;
+    })();
+    TypeScript.CandidateInferenceInfo = CandidateInferenceInfo;
+
+    var TypeArgumentInferenceContext = (function () {
+        function TypeArgumentInferenceContext(resolver, context, signatureBeingInferred) {
+            this.resolver = resolver;
+            this.context = context;
+            this.signatureBeingInferred = signatureBeingInferred;
+            this.inferenceCache = TypeScript.BitMatrix.getBitMatrix(false);
+            this.candidateCache = [];
+            var typeParameters = signatureBeingInferred.getTypeParameters();
+            for (var i = 0; i < typeParameters.length; i++) {
+                this.addInferenceRoot(typeParameters[i]);
+            }
+        }
+        TypeArgumentInferenceContext.prototype.alreadyRelatingTypes = function (objectType, parameterType) {
+            if (this.inferenceCache.valueAt(objectType.pullSymbolID, parameterType.pullSymbolID)) {
+                return true;
+            } else {
+                this.inferenceCache.setValueAt(objectType.pullSymbolID, parameterType.pullSymbolID, true);
+                return false;
+            }
+        };
+
+        TypeArgumentInferenceContext.prototype.resetRelationshipCache = function () {
+            this.inferenceCache.release();
+            this.inferenceCache = TypeScript.BitMatrix.getBitMatrix(false);
+        };
+
+        TypeArgumentInferenceContext.prototype.addInferenceRoot = function (param) {
+            var info = this.candidateCache[param.pullSymbolID];
+
+            if (!info) {
+                info = new CandidateInferenceInfo();
+                info.typeParameter = param;
+                this.candidateCache[param.pullSymbolID] = info;
+            }
+        };
+
+        TypeArgumentInferenceContext.prototype.getInferenceInfo = function (param) {
+            return this.candidateCache[param.pullSymbolID];
+        };
+
+        TypeArgumentInferenceContext.prototype.addCandidateForInference = function (param, candidate) {
+            var info = this.getInferenceInfo(param);
+
+            if (info && candidate && info.inferenceCandidates.indexOf(candidate) < 0) {
+                info.addCandidate(candidate);
+            }
+        };
+
+        TypeArgumentInferenceContext.prototype.inferTypeArguments = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        TypeArgumentInferenceContext.prototype.fixTypeParameter = function (typeParameter) {
+            var candidateInfo = this.candidateCache[typeParameter.pullSymbolID];
+            if (candidateInfo) {
+                candidateInfo.fixTypeParameter(this.resolver, this.context);
+            }
+        };
+
+        TypeArgumentInferenceContext.prototype._finalizeInferredTypeArguments = function () {
+            var results = [];
+            var typeParameters = this.signatureBeingInferred.getTypeParameters();
+            for (var i = 0; i < typeParameters.length; i++) {
+                var info = this.candidateCache[typeParameters[i].pullSymbolID];
+
+                info.fixTypeParameter(this.resolver, this.context);
+
+                for (var i = 0; i < results.length; i++) {
+                    if (results[i].type === info.typeParameter) {
+                        results[i].type = info._inferredTypeAfterFixing;
+                    }
+                }
+
+                results.push(info._inferredTypeAfterFixing);
+            }
+
+            return results;
+        };
+
+        TypeArgumentInferenceContext.prototype.isInvocationInferenceContext = function () {
+            throw TypeScript.Errors.abstract();
+        };
+        return TypeArgumentInferenceContext;
+    })();
+    TypeScript.TypeArgumentInferenceContext = TypeArgumentInferenceContext;
+
+    var InvocationTypeArgumentInferenceContext = (function (_super) {
+        __extends(InvocationTypeArgumentInferenceContext, _super);
+        function InvocationTypeArgumentInferenceContext(resolver, context, signatureBeingInferred, argumentASTs) {
+            _super.call(this, resolver, context, signatureBeingInferred);
+            this.argumentASTs = argumentASTs;
+        }
+        InvocationTypeArgumentInferenceContext.prototype.isInvocationInferenceContext = function () {
+            return true;
+        };
+
+        InvocationTypeArgumentInferenceContext.prototype.inferTypeArguments = function () {
+            var _this = this;
+            this.signatureBeingInferred.forAllParameterTypes(this.argumentASTs.nonSeparatorCount(), function (parameterType, argumentIndex) {
+                var argumentAST = _this.argumentASTs.nonSeparatorAt(argumentIndex);
+
+                _this.context.pushInferentialType(parameterType, _this);
+                var argumentType = _this.resolver.resolveAST(argumentAST, true, _this.context).type;
+                _this.resolver.relateTypeToTypeParametersWithNewEnclosingTypes(argumentType, parameterType, _this, _this.context);
+                _this.context.popAnyContextualType();
+
+                return true;
+            });
+
+            return this._finalizeInferredTypeArguments();
+        };
+        return InvocationTypeArgumentInferenceContext;
+    })(TypeArgumentInferenceContext);
+    TypeScript.InvocationTypeArgumentInferenceContext = InvocationTypeArgumentInferenceContext;
+
+    var ContextualSignatureInstantiationTypeArgumentInferenceContext = (function (_super) {
+        __extends(ContextualSignatureInstantiationTypeArgumentInferenceContext, _super);
+        function ContextualSignatureInstantiationTypeArgumentInferenceContext(resolver, context, signatureBeingInferred, contextualSignature, shouldFixContextualSignatureParameterTypes) {
+            _super.call(this, resolver, context, signatureBeingInferred);
+            this.contextualSignature = contextualSignature;
+            this.shouldFixContextualSignatureParameterTypes = shouldFixContextualSignatureParameterTypes;
+        }
+        ContextualSignatureInstantiationTypeArgumentInferenceContext.prototype.isInvocationInferenceContext = function () {
+            return false;
+        };
+
+        ContextualSignatureInstantiationTypeArgumentInferenceContext.prototype.inferTypeArguments = function () {
+            var _this = this;
+            var relateTypesCallback = function (parameterTypeBeingInferred, contextualParameterType) {
+                if (_this.shouldFixContextualSignatureParameterTypes) {
+                    contextualParameterType = _this.context.fixAllTypeParametersReferencedByType(contextualParameterType, _this.resolver, _this);
+                }
+                _this.resolver.relateTypeToTypeParametersWithNewEnclosingTypes(contextualParameterType, parameterTypeBeingInferred, _this, _this.context);
+
+                return true;
+            };
+
+            this.signatureBeingInferred.forAllCorrespondingParameterTypesInThisAndOtherSignature(this.contextualSignature, relateTypesCallback);
+
+            return this._finalizeInferredTypeArguments();
+        };
+        return ContextualSignatureInstantiationTypeArgumentInferenceContext;
+    })(TypeArgumentInferenceContext);
+    TypeScript.ContextualSignatureInstantiationTypeArgumentInferenceContext = ContextualSignatureInstantiationTypeArgumentInferenceContext;
+
+    var PullContextualTypeContext = (function () {
+        function PullContextualTypeContext(contextualType, provisional, isInferentiallyTyping, typeArgumentInferenceContext) {
+            this.contextualType = contextualType;
+            this.provisional = provisional;
+            this.isInferentiallyTyping = isInferentiallyTyping;
+            this.typeArgumentInferenceContext = typeArgumentInferenceContext;
+            this.provisionallyTypedSymbols = [];
+            this.hasProvisionalErrors = false;
+            this.astSymbolMap = [];
+        }
+        PullContextualTypeContext.prototype.recordProvisionallyTypedSymbol = function (symbol) {
+            this.provisionallyTypedSymbols[this.provisionallyTypedSymbols.length] = symbol;
+        };
+
+        PullContextualTypeContext.prototype.invalidateProvisionallyTypedSymbols = function () {
+            for (var i = 0; i < this.provisionallyTypedSymbols.length; i++) {
+                this.provisionallyTypedSymbols[i].setUnresolved();
+            }
+        };
+
+        PullContextualTypeContext.prototype.setSymbolForAST = function (ast, symbol) {
+            this.astSymbolMap[ast.syntaxID()] = symbol;
+        };
+
+        PullContextualTypeContext.prototype.getSymbolForAST = function (ast) {
+            return this.astSymbolMap[ast.syntaxID()];
+        };
+        return PullContextualTypeContext;
+    })();
+    TypeScript.PullContextualTypeContext = PullContextualTypeContext;
+
+    var PullTypeResolutionContext = (function () {
+        function PullTypeResolutionContext(resolver, inTypeCheck, fileName) {
+            if (typeof inTypeCheck === "undefined") { inTypeCheck = false; }
+            if (typeof fileName === "undefined") { fileName = null; }
+            this.resolver = resolver;
+            this.inTypeCheck = inTypeCheck;
+            this.fileName = fileName;
+            this.contextStack = [];
+            this.typeCheckedNodes = null;
+            this.enclosingTypeWalker1 = null;
+            this.enclosingTypeWalker2 = null;
+            this.inBaseTypeResolution = false;
+            if (inTypeCheck) {
+                TypeScript.Debug.assert(fileName, "A file name must be provided if you are typechecking");
+                this.typeCheckedNodes = TypeScript.BitVector.getBitVector(false);
+            }
+        }
+        PullTypeResolutionContext.prototype.setTypeChecked = function (ast) {
+            if (!this.inProvisionalResolution()) {
+                this.typeCheckedNodes.setValueAt(ast.syntaxID(), true);
+            }
+        };
+
+        PullTypeResolutionContext.prototype.canTypeCheckAST = function (ast) {
+            return this.typeCheck() && !this.typeCheckedNodes.valueAt(ast.syntaxID()) && this.fileName === ast.fileName();
+        };
+
+        PullTypeResolutionContext.prototype._pushAnyContextualType = function (type, provisional, isInferentiallyTyping, argContext) {
+            this.contextStack.push(new PullContextualTypeContext(type, provisional, isInferentiallyTyping, argContext));
+        };
+
+        PullTypeResolutionContext.prototype.pushNewContextualType = function (type) {
+            this._pushAnyContextualType(type, this.inProvisionalResolution(), false, null);
+        };
+
+        PullTypeResolutionContext.prototype.propagateContextualType = function (type) {
+            this._pushAnyContextualType(type, this.inProvisionalResolution(), this.isInferentiallyTyping(), this.getCurrentTypeArgumentInferenceContext());
+        };
+
+        PullTypeResolutionContext.prototype.pushInferentialType = function (type, typeArgumentInferenceContext) {
+            this._pushAnyContextualType(type, true, true, typeArgumentInferenceContext);
+        };
+
+        PullTypeResolutionContext.prototype.pushProvisionalType = function (type) {
+            this._pushAnyContextualType(type, true, false, null);
+        };
+
+        PullTypeResolutionContext.prototype.popAnyContextualType = function () {
+            var tc = this.contextStack.pop();
+
+            tc.invalidateProvisionallyTypedSymbols();
+
+            if (tc.hasProvisionalErrors && this.inProvisionalResolution()) {
+                this.contextStack[this.contextStack.length - 1].hasProvisionalErrors = true;
+            }
+
+            return tc;
+        };
+
+        PullTypeResolutionContext.prototype.hasProvisionalErrors = function () {
+            return this.contextStack.length ? this.contextStack[this.contextStack.length - 1].hasProvisionalErrors : false;
+        };
+
+        PullTypeResolutionContext.prototype.getContextualType = function () {
+            var context = !this.contextStack.length ? null : this.contextStack[this.contextStack.length - 1];
+
+            if (context) {
+                var type = context.contextualType;
+
+                if (!type) {
+                    return null;
+                }
+
+                return type;
+            }
+
+            return null;
+        };
+
+        PullTypeResolutionContext.prototype.fixAllTypeParametersReferencedByType = function (type, resolver, argContext) {
+            var argContext = this.getCurrentTypeArgumentInferenceContext();
+            if (type.wrapsSomeTypeParameter(argContext.candidateCache)) {
+                var typeParameterArgumentMap = [];
+
+                for (var n in argContext.candidateCache) {
+                    var typeParameter = argContext.candidateCache[n] && argContext.candidateCache[n].typeParameter;
+                    if (typeParameter) {
+                        var dummyMap = [];
+                        dummyMap[typeParameter.pullSymbolID] = typeParameter;
+                        if (type.wrapsSomeTypeParameter(dummyMap)) {
+                            argContext.fixTypeParameter(typeParameter);
+                            TypeScript.Debug.assert(argContext.candidateCache[n]._inferredTypeAfterFixing);
+                            typeParameterArgumentMap[typeParameter.pullSymbolID] = argContext.candidateCache[n]._inferredTypeAfterFixing;
+                        }
+                    }
+                }
+
+                return resolver.instantiateType(type, typeParameterArgumentMap);
+            }
+
+            return type;
+        };
+
+        PullTypeResolutionContext.prototype.getCurrentTypeArgumentInferenceContext = function () {
+            return this.contextStack.length ? this.contextStack[this.contextStack.length - 1].typeArgumentInferenceContext : null;
+        };
+
+        PullTypeResolutionContext.prototype.isInferentiallyTyping = function () {
+            return this.contextStack.length > 0 && this.contextStack[this.contextStack.length - 1].isInferentiallyTyping;
+        };
+
+        PullTypeResolutionContext.prototype.inProvisionalResolution = function () {
+            return (!this.contextStack.length ? false : this.contextStack[this.contextStack.length - 1].provisional);
+        };
+
+        PullTypeResolutionContext.prototype.isInBaseTypeResolution = function () {
+            return this.inBaseTypeResolution;
+        };
+
+        PullTypeResolutionContext.prototype.startBaseTypeResolution = function () {
+            var wasInBaseTypeResoltion = this.inBaseTypeResolution;
+            this.inBaseTypeResolution = true;
+            return wasInBaseTypeResoltion;
+        };
+
+        PullTypeResolutionContext.prototype.doneBaseTypeResolution = function (wasInBaseTypeResolution) {
+            this.inBaseTypeResolution = wasInBaseTypeResolution;
+        };
+
+        PullTypeResolutionContext.prototype.setTypeInContext = function (symbol, type) {
+            if (symbol.type && symbol.type.isError() && !type.isError()) {
+                return;
+            }
+            symbol.type = type;
+
+            if (this.contextStack.length && this.inProvisionalResolution()) {
+                this.contextStack[this.contextStack.length - 1].recordProvisionallyTypedSymbol(symbol);
+            }
+        };
+
+        PullTypeResolutionContext.prototype.postDiagnostic = function (diagnostic) {
+            if (diagnostic) {
+                if (this.inProvisionalResolution()) {
+                    (this.contextStack[this.contextStack.length - 1]).hasProvisionalErrors = true;
+                } else if (this.inTypeCheck && this.resolver) {
+                    this.resolver.semanticInfoChain.addDiagnostic(diagnostic);
+                }
+            }
+        };
+
+        PullTypeResolutionContext.prototype.typeCheck = function () {
+            return this.inTypeCheck && !this.inProvisionalResolution();
+        };
+
+        PullTypeResolutionContext.prototype.setSymbolForAST = function (ast, symbol) {
+            this.contextStack[this.contextStack.length - 1].setSymbolForAST(ast, symbol);
+        };
+
+        PullTypeResolutionContext.prototype.getSymbolForAST = function (ast) {
+            for (var i = this.contextStack.length - 1; i >= 0; i--) {
+                var typeContext = this.contextStack[i];
+                if (!typeContext.provisional) {
+                    break;
+                }
+
+                var symbol = typeContext.getSymbolForAST(ast);
+                if (symbol) {
+                    return symbol;
+                }
+            }
+
+            return null;
+        };
+
+        PullTypeResolutionContext.prototype.startWalkingTypes = function (symbol1, symbol2) {
+            if (!this.enclosingTypeWalker1) {
+                this.enclosingTypeWalker1 = new TypeScript.PullTypeEnclosingTypeWalker();
+            }
+            var symbolsWhenStartedWalkingTypes1 = this.enclosingTypeWalker1.startWalkingType(symbol1);
+            if (!this.enclosingTypeWalker2) {
+                this.enclosingTypeWalker2 = new TypeScript.PullTypeEnclosingTypeWalker();
+            }
+            var symbolsWhenStartedWalkingTypes2 = this.enclosingTypeWalker2.startWalkingType(symbol2);
+            return { symbolsWhenStartedWalkingTypes1: symbolsWhenStartedWalkingTypes1, symbolsWhenStartedWalkingTypes2: symbolsWhenStartedWalkingTypes2 };
+        };
+
+        PullTypeResolutionContext.prototype.endWalkingTypes = function (symbolsWhenStartedWalkingTypes) {
+            this.enclosingTypeWalker1.endWalkingType(symbolsWhenStartedWalkingTypes.symbolsWhenStartedWalkingTypes1);
+            this.enclosingTypeWalker2.endWalkingType(symbolsWhenStartedWalkingTypes.symbolsWhenStartedWalkingTypes2);
+        };
+
+        PullTypeResolutionContext.prototype.setEnclosingTypes = function (symbol1, symbol2) {
+            if (!this.enclosingTypeWalker1) {
+                this.enclosingTypeWalker1 = new TypeScript.PullTypeEnclosingTypeWalker();
+            }
+            this.enclosingTypeWalker1.setEnclosingType(symbol1);
+            if (!this.enclosingTypeWalker2) {
+                this.enclosingTypeWalker2 = new TypeScript.PullTypeEnclosingTypeWalker();
+            }
+            this.enclosingTypeWalker2.setEnclosingType(symbol2);
+        };
+
+        PullTypeResolutionContext.prototype.walkMemberTypes = function (memberName) {
+            this.enclosingTypeWalker1.walkMemberType(memberName, this.resolver);
+            this.enclosingTypeWalker2.walkMemberType(memberName, this.resolver);
+        };
+
+        PullTypeResolutionContext.prototype.postWalkMemberTypes = function () {
+            this.enclosingTypeWalker1.postWalkMemberType();
+            this.enclosingTypeWalker2.postWalkMemberType();
+        };
+
+        PullTypeResolutionContext.prototype.walkSignatures = function (kind, index, index2) {
+            this.enclosingTypeWalker1.walkSignature(kind, index);
+            this.enclosingTypeWalker2.walkSignature(kind, index2 == undefined ? index : index2);
+        };
+
+        PullTypeResolutionContext.prototype.postWalkSignatures = function () {
+            this.enclosingTypeWalker1.postWalkSignature();
+            this.enclosingTypeWalker2.postWalkSignature();
+        };
+
+        PullTypeResolutionContext.prototype.walkTypeParameterConstraints = function (index) {
+            this.enclosingTypeWalker1.walkTypeParameterConstraint(index);
+            this.enclosingTypeWalker2.walkTypeParameterConstraint(index);
+        };
+
+        PullTypeResolutionContext.prototype.postWalkTypeParameterConstraints = function () {
+            this.enclosingTypeWalker1.postWalkTypeParameterConstraint();
+            this.enclosingTypeWalker2.postWalkTypeParameterConstraint();
+        };
+
+        PullTypeResolutionContext.prototype.walkTypeArgument = function (index) {
+            this.enclosingTypeWalker1.walkTypeArgument(index);
+            this.enclosingTypeWalker2.walkTypeArgument(index);
+        };
+
+        PullTypeResolutionContext.prototype.postWalkTypeArgument = function () {
+            this.enclosingTypeWalker1.postWalkTypeArgument();
+            this.enclosingTypeWalker2.postWalkTypeArgument();
+        };
+
+        PullTypeResolutionContext.prototype.walkReturnTypes = function () {
+            this.enclosingTypeWalker1.walkReturnType();
+            this.enclosingTypeWalker2.walkReturnType();
+        };
+
+        PullTypeResolutionContext.prototype.postWalkReturnTypes = function () {
+            this.enclosingTypeWalker1.postWalkReturnType();
+            this.enclosingTypeWalker2.postWalkReturnType();
+        };
+
+        PullTypeResolutionContext.prototype.walkParameterTypes = function (iParam) {
+            this.enclosingTypeWalker1.walkParameterType(iParam);
+            this.enclosingTypeWalker2.walkParameterType(iParam);
+        };
+
+        PullTypeResolutionContext.prototype.postWalkParameterTypes = function () {
+            this.enclosingTypeWalker1.postWalkParameterType();
+            this.enclosingTypeWalker2.postWalkParameterType();
+        };
+
+        PullTypeResolutionContext.prototype.getBothKindOfIndexSignatures = function (includeAugmentedType1, includeAugmentedType2) {
+            var indexSigs1 = this.enclosingTypeWalker1.getBothKindOfIndexSignatures(this.resolver, this, includeAugmentedType1);
+            var indexSigs2 = this.enclosingTypeWalker2.getBothKindOfIndexSignatures(this.resolver, this, includeAugmentedType2);
+            return { indexSigs1: indexSigs1, indexSigs2: indexSigs2 };
+        };
+
+        PullTypeResolutionContext.prototype.walkIndexSignatureReturnTypes = function (indexSigs, useStringIndexSignature1, useStringIndexSignature2, onlySignature) {
+            this.enclosingTypeWalker1.walkIndexSignatureReturnType(indexSigs.indexSigs1, useStringIndexSignature1, onlySignature);
+            this.enclosingTypeWalker2.walkIndexSignatureReturnType(indexSigs.indexSigs2, useStringIndexSignature2, onlySignature);
+        };
+
+        PullTypeResolutionContext.prototype.postWalkIndexSignatureReturnTypes = function (onlySignature) {
+            this.enclosingTypeWalker1.postWalkIndexSignatureReturnType(onlySignature);
+            this.enclosingTypeWalker2.postWalkIndexSignatureReturnType(onlySignature);
+        };
+
+        PullTypeResolutionContext.prototype.swapEnclosingTypeWalkers = function () {
+            var tempEnclosingWalker1 = this.enclosingTypeWalker1;
+            this.enclosingTypeWalker1 = this.enclosingTypeWalker2;
+            this.enclosingTypeWalker2 = tempEnclosingWalker1;
+        };
+
+        PullTypeResolutionContext.prototype.oneOfClassificationsIsInfinitelyExpanding = function () {
+            var generativeClassification1 = this.enclosingTypeWalker1.getGenerativeClassification();
+            if (generativeClassification1 === 3 /* InfinitelyExpanding */) {
+                return true;
+            }
+            var generativeClassification2 = this.enclosingTypeWalker2.getGenerativeClassification();
+            if (generativeClassification2 === 3 /* InfinitelyExpanding */) {
+                return true;
+            }
+
+            return false;
+        };
+
+        PullTypeResolutionContext.prototype.resetEnclosingTypeWalkers = function () {
+            var enclosingTypeWalker1 = this.enclosingTypeWalker1;
+            var enclosingTypeWalker2 = this.enclosingTypeWalker2;
+            this.enclosingTypeWalker1 = null;
+            this.enclosingTypeWalker2 = null;
+            return {
+                enclosingTypeWalker1: enclosingTypeWalker1,
+                enclosingTypeWalker2: enclosingTypeWalker2
+            };
+        };
+
+        PullTypeResolutionContext.prototype.setEnclosingTypeWalkers = function (enclosingTypeWalkers) {
+            this.enclosingTypeWalker1 = enclosingTypeWalkers.enclosingTypeWalker1;
+            this.enclosingTypeWalker2 = enclosingTypeWalkers.enclosingTypeWalker2;
+        };
+        return PullTypeResolutionContext;
+    })();
+    TypeScript.PullTypeResolutionContext = PullTypeResolutionContext;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var OverloadApplicabilityStatus;
+    (function (OverloadApplicabilityStatus) {
+        OverloadApplicabilityStatus[OverloadApplicabilityStatus["NotAssignable"] = 0] = "NotAssignable";
+        OverloadApplicabilityStatus[OverloadApplicabilityStatus["AssignableButWithProvisionalErrors"] = 1] = "AssignableButWithProvisionalErrors";
+        OverloadApplicabilityStatus[OverloadApplicabilityStatus["AssignableWithNoProvisionalErrors"] = 2] = "AssignableWithNoProvisionalErrors";
+        OverloadApplicabilityStatus[OverloadApplicabilityStatus["Subtype"] = 3] = "Subtype";
+    })(OverloadApplicabilityStatus || (OverloadApplicabilityStatus = {}));
+
+    var PullAdditionalCallResolutionData = (function () {
+        function PullAdditionalCallResolutionData() {
+            this.targetSymbol = null;
+            this.resolvedSignatures = null;
+            this.candidateSignature = null;
+            this.actualParametersContextTypeSymbols = null;
+            this.diagnosticsFromOverloadResolution = [];
+        }
+        return PullAdditionalCallResolutionData;
+    })();
+    TypeScript.PullAdditionalCallResolutionData = PullAdditionalCallResolutionData;
+
+    var PullAdditionalObjectLiteralResolutionData = (function () {
+        function PullAdditionalObjectLiteralResolutionData() {
+            this.membersContextTypeSymbols = null;
+        }
+        return PullAdditionalObjectLiteralResolutionData;
+    })();
+    TypeScript.PullAdditionalObjectLiteralResolutionData = PullAdditionalObjectLiteralResolutionData;
+
+    var MemberWithBaseOrigin = (function () {
+        function MemberWithBaseOrigin(memberSymbol, baseOrigin) {
+            this.memberSymbol = memberSymbol;
+            this.baseOrigin = baseOrigin;
+        }
+        return MemberWithBaseOrigin;
+    })();
+
+    var SignatureWithBaseOrigin = (function () {
+        function SignatureWithBaseOrigin(signature, baseOrigin) {
+            this.signature = signature;
+            this.baseOrigin = baseOrigin;
+        }
+        return SignatureWithBaseOrigin;
+    })();
+
+    var InheritedIndexSignatureInfo = (function () {
+        function InheritedIndexSignatureInfo() {
+        }
+        return InheritedIndexSignatureInfo;
+    })();
+
+    var CompilerReservedName;
+    (function (CompilerReservedName) {
+        CompilerReservedName[CompilerReservedName["_this"] = 1] = "_this";
+        CompilerReservedName[CompilerReservedName["_super"] = 2] = "_super";
+        CompilerReservedName[CompilerReservedName["arguments"] = 3] = "arguments";
+        CompilerReservedName[CompilerReservedName["_i"] = 4] = "_i";
+        CompilerReservedName[CompilerReservedName["require"] = 5] = "require";
+        CompilerReservedName[CompilerReservedName["exports"] = 6] = "exports";
+    })(CompilerReservedName || (CompilerReservedName = {}));
+
+    function getCompilerReservedName(name) {
+        var nameText = name.valueText();
+        return CompilerReservedName[nameText];
+    }
+
+    var PullTypeResolver = (function () {
+        function PullTypeResolver(compilationSettings, semanticInfoChain) {
+            this.compilationSettings = compilationSettings;
+            this.semanticInfoChain = semanticInfoChain;
+            this._cachedArrayInterfaceType = null;
+            this._cachedNumberInterfaceType = null;
+            this._cachedStringInterfaceType = null;
+            this._cachedBooleanInterfaceType = null;
+            this._cachedObjectInterfaceType = null;
+            this._cachedFunctionInterfaceType = null;
+            this._cachedIArgumentsInterfaceType = null;
+            this._cachedRegExpInterfaceType = null;
+            this._cachedAnyTypeArgs = null;
+            this.typeCheckCallBacks = [];
+            this.postTypeCheckWorkitems = [];
+            this._cachedFunctionArgumentsSymbol = null;
+            this.assignableCache = TypeScript.BitMatrix.getBitMatrix(true);
+            this.subtypeCache = TypeScript.BitMatrix.getBitMatrix(true);
+            this.identicalCache = TypeScript.BitMatrix.getBitMatrix(true);
+            this.inResolvingOtherDeclsWalker = new TypeScript.PullHelpers.OtherPullDeclsWalker();
+        }
+        PullTypeResolver.prototype.cachedArrayInterfaceType = function () {
+            if (!this._cachedArrayInterfaceType) {
+                this._cachedArrayInterfaceType = this.getSymbolFromDeclPath("Array", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (!this._cachedArrayInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedArrayInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedArrayInterfaceType;
+        };
+
+        PullTypeResolver.prototype.getArrayNamedType = function () {
+            return this.cachedArrayInterfaceType();
+        };
+
+        PullTypeResolver.prototype.cachedNumberInterfaceType = function () {
+            if (!this._cachedNumberInterfaceType) {
+                this._cachedNumberInterfaceType = this.getSymbolFromDeclPath("Number", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (this._cachedNumberInterfaceType && !this._cachedNumberInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedNumberInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedNumberInterfaceType;
+        };
+
+        PullTypeResolver.prototype.cachedStringInterfaceType = function () {
+            if (!this._cachedStringInterfaceType) {
+                this._cachedStringInterfaceType = this.getSymbolFromDeclPath("String", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (this._cachedStringInterfaceType && !this._cachedStringInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedStringInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedStringInterfaceType;
+        };
+
+        PullTypeResolver.prototype.cachedBooleanInterfaceType = function () {
+            if (!this._cachedBooleanInterfaceType) {
+                this._cachedBooleanInterfaceType = this.getSymbolFromDeclPath("Boolean", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (this._cachedBooleanInterfaceType && !this._cachedBooleanInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedBooleanInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedBooleanInterfaceType;
+        };
+
+        PullTypeResolver.prototype.cachedObjectInterfaceType = function () {
+            if (!this._cachedObjectInterfaceType) {
+                this._cachedObjectInterfaceType = this.getSymbolFromDeclPath("Object", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (!this._cachedObjectInterfaceType) {
+                this._cachedObjectInterfaceType = this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            if (!this._cachedObjectInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedObjectInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedObjectInterfaceType;
+        };
+
+        PullTypeResolver.prototype.cachedFunctionInterfaceType = function () {
+            if (!this._cachedFunctionInterfaceType) {
+                this._cachedFunctionInterfaceType = this.getSymbolFromDeclPath("Function", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (this._cachedFunctionInterfaceType && !this._cachedFunctionInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedFunctionInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedFunctionInterfaceType;
+        };
+
+        PullTypeResolver.prototype.cachedIArgumentsInterfaceType = function () {
+            if (!this._cachedIArgumentsInterfaceType) {
+                this._cachedIArgumentsInterfaceType = this.getSymbolFromDeclPath("IArguments", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (this._cachedIArgumentsInterfaceType && !this._cachedIArgumentsInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedIArgumentsInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedIArgumentsInterfaceType;
+        };
+
+        PullTypeResolver.prototype.cachedRegExpInterfaceType = function () {
+            if (!this._cachedRegExpInterfaceType) {
+                this._cachedRegExpInterfaceType = this.getSymbolFromDeclPath("RegExp", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (this._cachedRegExpInterfaceType && !this._cachedRegExpInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedRegExpInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedRegExpInterfaceType;
+        };
+
+        PullTypeResolver.prototype.cachedFunctionArgumentsSymbol = function () {
+            if (!this._cachedFunctionArgumentsSymbol) {
+                this._cachedFunctionArgumentsSymbol = new TypeScript.PullSymbol("arguments", 512 /* Variable */);
+                this._cachedFunctionArgumentsSymbol.type = this.cachedIArgumentsInterfaceType() || this.semanticInfoChain.anyTypeSymbol;
+                this._cachedFunctionArgumentsSymbol.setResolved();
+
+                var functionArgumentsDecl = new TypeScript.PullSynthesizedDecl("arguments", "arguments", 2048 /* Parameter */, 0 /* None */, null, this.semanticInfoChain);
+                functionArgumentsDecl.setSymbol(this._cachedFunctionArgumentsSymbol);
+                this._cachedFunctionArgumentsSymbol.addDeclaration(functionArgumentsDecl);
+            }
+
+            return this._cachedFunctionArgumentsSymbol;
+        };
+
+        PullTypeResolver.prototype.getApparentType = function (type) {
+            if (type.isTypeParameter()) {
+                var baseConstraint = type.getBaseConstraint(this.semanticInfoChain);
+                if (baseConstraint === this.semanticInfoChain.anyTypeSymbol) {
+                    return this.semanticInfoChain.emptyTypeSymbol;
+                } else {
+                    type = baseConstraint;
+                }
+            }
+            if (type.isPrimitive()) {
+                if (type === this.semanticInfoChain.numberTypeSymbol) {
+                    return this.cachedNumberInterfaceType();
+                }
+                if (type === this.semanticInfoChain.booleanTypeSymbol) {
+                    return this.cachedBooleanInterfaceType();
+                }
+                if (type === this.semanticInfoChain.stringTypeSymbol) {
+                    return this.cachedStringInterfaceType();
+                }
+                return type;
+            }
+            if (type.isEnum()) {
+                return this.cachedNumberInterfaceType();
+            }
+            return type;
+        };
+
+        PullTypeResolver.prototype.setTypeChecked = function (ast, context) {
+            context.setTypeChecked(ast);
+        };
+
+        PullTypeResolver.prototype.canTypeCheckAST = function (ast, context) {
+            return context.canTypeCheckAST(ast);
+        };
+
+        PullTypeResolver.prototype.setSymbolForAST = function (ast, symbol, context) {
+            if (context && context.inProvisionalResolution()) {
+                context.setSymbolForAST(ast, symbol);
+            } else {
+                this.semanticInfoChain.setSymbolForAST(ast, symbol);
+            }
+        };
+
+        PullTypeResolver.prototype.getSymbolForAST = function (ast, context) {
+            var symbol = this.semanticInfoChain.getSymbolForAST(ast);
+
+            if (!symbol) {
+                if (context && context.inProvisionalResolution()) {
+                    symbol = context.getSymbolForAST(ast);
+                }
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.getASTForDecl = function (decl) {
+            return this.semanticInfoChain.getASTForDecl(decl);
+        };
+
+        PullTypeResolver.prototype.getNewErrorTypeSymbol = function (name) {
+            if (typeof name === "undefined") { name = null; }
+            return new TypeScript.PullErrorTypeSymbol(this.semanticInfoChain.anyTypeSymbol, name);
+        };
+
+        PullTypeResolver.prototype.getEnclosingDecl = function (decl) {
+            var declPath = decl.getParentPath();
+
+            if (declPath.length > 1 && declPath[declPath.length - 1] === decl) {
+                return declPath[declPath.length - 2];
+            } else {
+                return declPath[declPath.length - 1];
+            }
+        };
+
+        PullTypeResolver.prototype.getExportedMemberSymbol = function (symbol, parent) {
+            if (!(symbol.kind & (65536 /* Method */ | 4096 /* Property */))) {
+                var isContainer = (parent.kind & (4 /* Container */ | 32 /* DynamicModule */)) !== 0;
+                var containerType = !isContainer ? parent.getAssociatedContainerType() : parent;
+
+                if (isContainer && containerType) {
+                    if (symbol.anyDeclHasFlag(1 /* Exported */)) {
+                        return symbol;
+                    }
+
+                    return null;
+                }
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype._getNamedPropertySymbolOfAugmentedType = function (symbolName, parent) {
+            var memberSymbol = this.getNamedPropertySymbol(symbolName, 68147712 /* SomeValue */, parent);
+            if (memberSymbol) {
+                return memberSymbol;
+            }
+
+            if (this.cachedFunctionInterfaceType() && parent.isFunctionType()) {
+                memberSymbol = this.cachedFunctionInterfaceType().findMember(symbolName, true);
+                if (memberSymbol) {
+                    return memberSymbol;
+                }
+            }
+
+            if (this.cachedObjectInterfaceType()) {
+                return this.cachedObjectInterfaceType().findMember(symbolName, true);
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.getNamedPropertySymbol = function (symbolName, declSearchKind, parent) {
+            var member = null;
+
+            if (declSearchKind & 68147712 /* SomeValue */) {
+                member = parent.findMember(symbolName, true);
+            } else if (declSearchKind & 58728795 /* SomeType */) {
+                member = parent.findNestedType(symbolName);
+            } else if (declSearchKind & 164 /* SomeContainer */) {
+                member = parent.findNestedContainer(symbolName);
+            }
+
+            if (member) {
+                return this.getExportedMemberSymbol(member, parent);
+            }
+
+            var containerType = parent.getAssociatedContainerType();
+
+            if (containerType) {
+                if (containerType.isClass()) {
+                    return null;
+                }
+
+                parent = containerType;
+
+                if (declSearchKind & 68147712 /* SomeValue */) {
+                    member = parent.findMember(symbolName, true);
+                } else if (declSearchKind & 58728795 /* SomeType */) {
+                    member = parent.findNestedType(symbolName);
+                } else if (declSearchKind & 164 /* SomeContainer */) {
+                    member = parent.findNestedContainer(symbolName);
+                }
+
+                if (member) {
+                    return this.getExportedMemberSymbol(member, parent);
+                }
+            }
+
+            if (parent.kind & 164 /* SomeContainer */) {
+                var typeDeclarations = parent.getDeclarations();
+                var childDecls = null;
+
+                for (var j = 0; j < typeDeclarations.length; j++) {
+                    childDecls = typeDeclarations[j].searchChildDecls(symbolName, declSearchKind);
+
+                    if (childDecls.length) {
+                        member = childDecls[0].getSymbol();
+
+                        if (!member) {
+                            member = childDecls[0].getSignatureSymbol();
+                        }
+                        return this.getExportedMemberSymbol(member, parent);
+                    }
+
+                    if ((declSearchKind & 58728795 /* SomeType */) !== 0 || (declSearchKind & 68147712 /* SomeValue */) !== 0) {
+                        childDecls = typeDeclarations[j].searchChildDecls(symbolName, 128 /* TypeAlias */);
+                        if (childDecls.length && childDecls[0].kind === 128 /* TypeAlias */) {
+                            var aliasSymbol = this.getExportedMemberSymbol(childDecls[0].getSymbol(), parent);
+                            if (aliasSymbol) {
+                                if ((declSearchKind & 58728795 /* SomeType */) !== 0) {
+                                    var typeSymbol = aliasSymbol.getExportAssignedTypeSymbol();
+                                    if (typeSymbol) {
+                                        return typeSymbol;
+                                    }
+                                } else {
+                                    var valueSymbol = aliasSymbol.getExportAssignedValueSymbol();
+                                    if (valueSymbol) {
+                                        aliasSymbol.setIsUsedAsValue();
+                                        return valueSymbol;
+                                    }
+                                }
+
+                                return aliasSymbol;
+                            }
+                        }
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.getSymbolFromDeclPath = function (symbolName, declPath, declSearchKind) {
+            var _this = this;
+            var symbol = null;
+
+            var decl = null;
+            var childDecls;
+            var declSymbol = null;
+            var declMembers;
+            var pathDeclKind;
+            var valDecl = null;
+            var kind;
+            var instanceSymbol = null;
+            var instanceType = null;
+            var childSymbol = null;
+
+            var allowedContainerDeclKind = 4 /* Container */ | 32 /* DynamicModule */;
+            if (TypeScript.hasFlag(declSearchKind, 67108864 /* EnumMember */)) {
+                allowedContainerDeclKind |= 64 /* Enum */;
+            }
+
+            var isAcceptableAlias = function (symbol) {
+                if (symbol.isAlias()) {
+                    _this.resolveDeclaredSymbol(symbol);
+                    if (TypeScript.hasFlag(declSearchKind, 164 /* SomeContainer */)) {
+                        if (symbol.assignedContainer() || symbol.getExportAssignedContainerSymbol()) {
+                            return true;
+                        }
+                    } else if (TypeScript.hasFlag(declSearchKind, 58728795 /* SomeType */)) {
+                        var type = symbol.getExportAssignedTypeSymbol();
+                        if (type && type.kind !== 32 /* DynamicModule */) {
+                            return true;
+                        }
+
+                        var type = symbol.assignedType();
+                        if (type && type.kind !== 32 /* DynamicModule */) {
+                            return true;
+                        }
+                    } else if (TypeScript.hasFlag(declSearchKind, 68147712 /* SomeValue */ & ~67108864 /* EnumMember */)) {
+                        if (symbol.assignedType() && symbol.assignedType().isError()) {
+                            return true;
+                        } else if (symbol.assignedValue() || symbol.getExportAssignedValueSymbol()) {
+                            return true;
+                        } else {
+                            var assignedType = symbol.assignedType();
+                            if (assignedType && assignedType.isContainer() && assignedType.getInstanceType()) {
+                                return true;
+                            }
+
+                            var decls = symbol.getDeclarations();
+                            var ast = decls[0].ast();
+                            return ast.moduleReference.kind() === 245 /* ExternalModuleReference */;
+                        }
+                    }
+                }
+
+                return false;
+            };
+
+            var tryFindAlias = function (decl) {
+                var childDecls = decl.searchChildDecls(symbolName, 128 /* TypeAlias */);
+
+                if (childDecls.length) {
+                    var sym = childDecls[0].getSymbol();
+                    if (isAcceptableAlias(sym)) {
+                        return sym;
+                    }
+                }
+                return null;
+            };
+
+            for (var i = declPath.length - 1; i >= 0; i--) {
+                decl = declPath[i];
+                pathDeclKind = decl.kind;
+
+                if (decl.flags & 2097152 /* DeclaredInAWithBlock */) {
+                    return this.semanticInfoChain.anyTypeSymbol;
+                }
+
+                if (pathDeclKind & allowedContainerDeclKind) {
+                    childDecls = decl.searchChildDecls(symbolName, declSearchKind);
+
+                    if (childDecls.length) {
+                        return childDecls[0].getSymbol();
+                    }
+
+                    var alias = tryFindAlias(decl);
+                    if (alias) {
+                        return alias;
+                    }
+
+                    if (declSearchKind & 68147712 /* SomeValue */) {
+                        instanceSymbol = decl.getSymbol().getInstanceSymbol();
+
+                        if (instanceSymbol) {
+                            instanceType = instanceSymbol.type;
+
+                            childSymbol = this.getNamedPropertySymbol(symbolName, declSearchKind, instanceType);
+
+                            if (childSymbol && (childSymbol.kind & declSearchKind) && !childSymbol.anyDeclHasFlag(16 /* Static */)) {
+                                return childSymbol;
+                            }
+                        }
+
+                        valDecl = decl.getValueDecl();
+
+                        if (valDecl) {
+                            decl = valDecl;
+                        }
+                    }
+
+                    declSymbol = decl.getSymbol().type;
+
+                    var childSymbol = this.getNamedPropertySymbol(symbolName, declSearchKind, declSymbol);
+
+                    if (childSymbol && (childSymbol.kind & declSearchKind) && !childSymbol.anyDeclHasFlag(16 /* Static */)) {
+                        return childSymbol;
+                    }
+                } else if ((declSearchKind & (58728795 /* SomeType */ | 164 /* SomeContainer */)) || !(pathDeclKind & 8 /* Class */)) {
+                    var candidateSymbol = null;
+
+                    if (pathDeclKind === 131072 /* FunctionExpression */ && symbolName === decl.getFunctionExpressionName()) {
+                        candidateSymbol = decl.getSymbol();
+                    }
+
+                    childDecls = decl.searchChildDecls(symbolName, declSearchKind);
+
+                    if (childDecls.length) {
+                        if (decl.kind & 1032192 /* SomeFunction */) {
+                            decl.ensureSymbolIsBound();
+                        }
+                        return childDecls[0].getSymbol();
+                    }
+
+                    if (candidateSymbol) {
+                        return candidateSymbol;
+                    }
+
+                    var alias = tryFindAlias(decl);
+                    if (alias) {
+                        return alias;
+                    }
+                }
+            }
+
+            symbol = this.semanticInfoChain.findSymbol([symbolName], declSearchKind);
+            if (symbol) {
+                return symbol;
+            }
+
+            if (!TypeScript.hasFlag(declSearchKind, 128 /* TypeAlias */)) {
+                symbol = this.semanticInfoChain.findSymbol([symbolName], 128 /* TypeAlias */);
+                if (symbol && isAcceptableAlias(symbol)) {
+                    return symbol;
+                }
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.getVisibleDeclsFromDeclPath = function (declPath, declSearchKind) {
+            var result = [];
+            var decl = null;
+            var childDecls;
+            var pathDeclKind;
+
+            for (var i = declPath.length - 1; i >= 0; i--) {
+                decl = declPath[i];
+                pathDeclKind = decl.kind;
+
+                var declKind = decl.kind;
+
+                if (declKind !== 8 /* Class */ && declKind !== 16 /* Interface */) {
+                    this.addFilteredDecls(decl.getChildDecls(), declSearchKind, result);
+                }
+
+                switch (declKind) {
+                    case 4 /* Container */:
+                    case 32 /* DynamicModule */:
+                        var otherDecls = this.semanticInfoChain.findDeclsFromPath(declPath.slice(0, i + 1), 164 /* SomeContainer */);
+                        for (var j = 0, m = otherDecls.length; j < m; j++) {
+                            var otherDecl = otherDecls[j];
+                            if (otherDecl === decl) {
+                                continue;
+                            }
+
+                            var otherDeclChildren = otherDecl.getChildDecls();
+                            for (var k = 0, s = otherDeclChildren.length; k < s; k++) {
+                                var otherDeclChild = otherDeclChildren[k];
+                                if ((otherDeclChild.flags & 1 /* Exported */) && (otherDeclChild.kind & declSearchKind)) {
+                                    result.push(otherDeclChild);
+                                }
+                            }
+                        }
+
+                        break;
+
+                    case 8 /* Class */:
+                    case 16 /* Interface */:
+                        var parameters = decl.getTypeParameters();
+                        if (parameters && parameters.length) {
+                            this.addFilteredDecls(parameters, declSearchKind, result);
+                        }
+
+                        break;
+
+                    case 131072 /* FunctionExpression */:
+                        var functionExpressionName = decl.getFunctionExpressionName();
+                        if (functionExpressionName) {
+                            result.push(decl);
+                        }
+
+                    case 16384 /* Function */:
+                    case 32768 /* ConstructorMethod */:
+                    case 65536 /* Method */:
+                        var parameters = decl.getTypeParameters();
+                        if (parameters && parameters.length) {
+                            this.addFilteredDecls(parameters, declSearchKind, result);
+                        }
+
+                        break;
+                }
+            }
+
+            var topLevelDecls = this.semanticInfoChain.topLevelDecls();
+            for (var i = 0, n = topLevelDecls.length; i < n; i++) {
+                var topLevelDecl = topLevelDecls[i];
+                if (declPath.length > 0 && topLevelDecl.fileName() === declPath[0].fileName()) {
+                    continue;
+                }
+
+                if (!topLevelDecl.isExternalModule()) {
+                    this.addFilteredDecls(topLevelDecl.getChildDecls(), declSearchKind, result);
+                }
+            }
+
+            return result;
+        };
+
+        PullTypeResolver.prototype.addFilteredDecls = function (decls, declSearchKind, result) {
+            if (decls.length) {
+                for (var i = 0, n = decls.length; i < n; i++) {
+                    var decl = decls[i];
+                    if (decl.kind & declSearchKind) {
+                        result.push(decl);
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.getVisibleDecls = function (enclosingDecl) {
+            var declPath = enclosingDecl.getParentPath();
+
+            var declSearchKind = 58728795 /* SomeType */ | 164 /* SomeContainer */ | 68147712 /* SomeValue */;
+
+            return this.getVisibleDeclsFromDeclPath(declPath, declSearchKind);
+        };
+
+        PullTypeResolver.prototype.getVisibleContextSymbols = function (enclosingDecl, context) {
+            var contextualTypeSymbol = context.getContextualType();
+            if (!contextualTypeSymbol || this.isAnyOrEquivalent(contextualTypeSymbol)) {
+                return null;
+            }
+
+            var declSearchKind = 58728795 /* SomeType */ | 164 /* SomeContainer */ | 68147712 /* SomeValue */;
+            var members = contextualTypeSymbol.getAllMembers(declSearchKind, 2 /* externallyVisible */);
+
+            for (var i = 0; i < members.length; i++) {
+                members[i].setUnresolved();
+            }
+
+            return members;
+        };
+
+        PullTypeResolver.prototype.getVisibleMembersFromExpression = function (expression, enclosingDecl, context) {
+            var lhs = this.resolveAST(expression, false, context);
+
+            if (isTypesOnlyLocation(expression) && (lhs.kind === 8 /* Class */ || lhs.kind === 16 /* Interface */ || lhs.kind === 64 /* Enum */)) {
+                return null;
+            }
+
+            var lhsType = lhs.type;
+            if (!lhsType) {
+                return null;
+            }
+
+            this.resolveDeclaredSymbol(lhsType, context);
+
+            if (lhsType.isContainer() && lhsType.isAlias()) {
+                lhsType = lhsType.getExportAssignedTypeSymbol();
+            }
+
+            if (this.isAnyOrEquivalent(lhsType)) {
+                return null;
+            }
+
+            var memberVisibilty = 2 /* externallyVisible */;
+            var containerSymbol = lhsType;
+            if (containerSymbol.kind === 33554432 /* ConstructorType */) {
+                containerSymbol = containerSymbol.getConstructSignatures()[0].returnType;
+            }
+
+            if (containerSymbol && containerSymbol.isClass()) {
+                var declPath = enclosingDecl.getParentPath();
+                if (declPath && declPath.length) {
+                    var declarations = containerSymbol.getDeclarations();
+                    for (var i = 0, n = declarations.length; i < n; i++) {
+                        var declaration = declarations[i];
+                        if (TypeScript.ArrayUtilities.contains(declPath, declaration)) {
+                            memberVisibilty = 1 /* internallyVisible */;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            var declSearchKind = 58728795 /* SomeType */ | 164 /* SomeContainer */ | 68147712 /* SomeValue */;
+
+            var members = [];
+
+            if (lhsType.isContainer()) {
+                var exportedAssignedContainerSymbol = lhsType.getExportAssignedContainerSymbol();
+                if (exportedAssignedContainerSymbol) {
+                    lhsType = exportedAssignedContainerSymbol;
+                }
+            }
+
+            lhsType = this.getApparentType(lhsType);
+
+            if (!lhsType.isResolved) {
+                var potentiallySpecializedType = this.resolveDeclaredSymbol(lhsType, context);
+
+                if (potentiallySpecializedType !== lhsType) {
+                    if (!lhs.isType()) {
+                        context.setTypeInContext(lhs, potentiallySpecializedType);
+                    }
+
+                    lhsType = potentiallySpecializedType;
+                }
+            }
+
+            members = lhsType.getAllMembers(declSearchKind, memberVisibilty);
+
+            if (lhsType.isContainer()) {
+                var associatedInstance = lhsType.getInstanceSymbol();
+                if (associatedInstance) {
+                    var instanceType = associatedInstance.type;
+                    this.resolveDeclaredSymbol(instanceType, context);
+                    var instanceMembers = instanceType.getAllMembers(declSearchKind, memberVisibilty);
+                    members = members.concat(instanceMembers);
+                }
+
+                var exportedContainer = lhsType.getExportAssignedContainerSymbol();
+                if (exportedContainer) {
+                    var exportedContainerMembers = exportedContainer.getAllMembers(declSearchKind, memberVisibilty);
+                    members = members.concat(exportedContainerMembers);
+                }
+            } else if (!lhsType.isConstructor() && !lhsType.isEnum()) {
+                var associatedContainerSymbol = lhsType.getAssociatedContainerType();
+                if (associatedContainerSymbol) {
+                    var containerType = associatedContainerSymbol.type;
+                    this.resolveDeclaredSymbol(containerType, context);
+                    var containerMembers = containerType.getAllMembers(declSearchKind, memberVisibilty);
+                    members = members.concat(containerMembers);
+                }
+            }
+
+            if (lhsType.isFunctionType() && this.cachedFunctionInterfaceType()) {
+                members = members.concat(this.cachedFunctionInterfaceType().getAllMembers(declSearchKind, 2 /* externallyVisible */));
+            }
+
+            return members;
+        };
+
+        PullTypeResolver.prototype.isAnyOrEquivalent = function (type) {
+            return (type === this.semanticInfoChain.anyTypeSymbol) || type.isError();
+        };
+
+        PullTypeResolver.prototype.resolveExternalModuleReference = function (idText, currentFileName) {
+            var originalIdText = idText;
+            var symbol = null;
+
+            if (TypeScript.isRelative(originalIdText)) {
+                var path = TypeScript.getRootFilePath(TypeScript.switchToForwardSlashes(currentFileName));
+                symbol = this.semanticInfoChain.findExternalModule(path + idText);
+            } else {
+                idText = originalIdText;
+
+                symbol = this.semanticInfoChain.findAmbientExternalModuleInGlobalContext(TypeScript.quoteStr(originalIdText));
+
+                if (!symbol) {
+                    var path = TypeScript.getRootFilePath(TypeScript.switchToForwardSlashes(currentFileName));
+
+                    while (symbol === null && path != "") {
+                        symbol = this.semanticInfoChain.findExternalModule(path + idText);
+                        if (symbol === null) {
+                            if (path === '/') {
+                                path = '';
+                            } else {
+                                path = TypeScript.normalizePath(path + "..");
+                                path = path && path != '/' ? path + '/' : path;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.resolveDeclaredSymbol = function (symbol, context) {
+            if (!symbol || symbol.isResolved || symbol.isTypeReference()) {
+                return symbol;
+            }
+
+            if (!context) {
+                context = new TypeScript.PullTypeResolutionContext(this);
+            }
+
+            return this.resolveDeclaredSymbolWorker(symbol, context);
+        };
+
+        PullTypeResolver.prototype.resolveDeclaredSymbolWorker = function (symbol, context) {
+            if (!symbol || symbol.isResolved) {
+                return symbol;
+            }
+
+            if (symbol.inResolution) {
+                if (!symbol.type && !symbol.isType()) {
+                    symbol.type = this.semanticInfoChain.anyTypeSymbol;
+                }
+
+                return symbol;
+            }
+
+            var decls = symbol.getDeclarations();
+
+            for (var i = 0; i < decls.length; i++) {
+                var decl = decls[i];
+
+                var ast = this.semanticInfoChain.getASTForDecl(decl);
+
+                if (!ast || (ast.kind() === 139 /* GetAccessor */ && ast.parent.parent.kind() === 215 /* ObjectLiteralExpression */) || (ast.kind() === 140 /* SetAccessor */ && ast.parent.parent.kind() === 215 /* ObjectLiteralExpression */)) {
+                    return symbol;
+                }
+
+                if (ast.parent && ast.parent.kind() === 236 /* CatchClause */ && ast.parent.identifier === ast) {
+                    return symbol;
+                }
+
+                if (ast.parent && ast.parent.kind() === 219 /* SimpleArrowFunctionExpression */ && ast.parent.identifier === ast) {
+                    return symbol;
+                }
+
+                var enclosingModule = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(ast);
+                var resolvedSymbol;
+                if (TypeScript.ASTHelpers.isAnyNameOfModule(enclosingModule, ast)) {
+                    resolvedSymbol = this.resolveSingleModuleDeclaration(enclosingModule, ast, context);
+                } else if (ast.kind() === 120 /* SourceUnit */ && decl.kind === 32 /* DynamicModule */) {
+                    resolvedSymbol = this.resolveModuleSymbol(decl.getSymbol(), context, null, null, ast);
+                } else {
+                    TypeScript.Debug.assert(ast.kind() !== 11 /* IdentifierName */ && ast.kind() !== 212 /* MemberAccessExpression */);
+                    resolvedSymbol = this.resolveAST(ast, false, context);
+                }
+
+                if (decl.kind === 2048 /* Parameter */ && !symbol.isResolved && !symbol.type && resolvedSymbol && symbol.anyDeclHasFlag(8388608 /* PropertyParameter */ | 67108864 /* ConstructorParameter */)) {
+                    symbol.type = resolvedSymbol.type;
+                    symbol.setResolved();
+                }
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.resolveOtherDecl = function (otherDecl, context) {
+            var astForOtherDecl = this.getASTForDecl(otherDecl);
+            var moduleDecl = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(astForOtherDecl);
+            if (TypeScript.ASTHelpers.isAnyNameOfModule(moduleDecl, astForOtherDecl)) {
+                this.resolveSingleModuleDeclaration(moduleDecl, astForOtherDecl, context);
+            } else {
+                this.resolveAST(astForOtherDecl, false, context);
+            }
+        };
+
+        PullTypeResolver.prototype.resolveOtherDeclarations = function (astName, context) {
+            var _this = this;
+            var resolvedDecl = this.semanticInfoChain.getDeclForAST(astName);
+            var symbol = resolvedDecl.getSymbol();
+
+            var allDecls = symbol.getDeclarations();
+            this.inResolvingOtherDeclsWalker.walkOtherPullDecls(resolvedDecl, symbol.getDeclarations(), function (otherDecl) {
+                return _this.resolveOtherDecl(otherDecl, context);
+            });
+        };
+
+        PullTypeResolver.prototype.resolveSourceUnit = function (sourceUnit, context) {
+            var enclosingDecl = this.getEnclosingDeclForAST(sourceUnit);
+            var moduleSymbol = enclosingDecl.getSymbol();
+            this.ensureAllSymbolsAreBound(moduleSymbol);
+
+            this.resolveFirstExportAssignmentStatement(sourceUnit.moduleElements, context);
+            this.resolveAST(sourceUnit.moduleElements, false, context);
+
+            if (this.canTypeCheckAST(sourceUnit, context)) {
+                this.typeCheckSourceUnit(sourceUnit, context);
+            }
+
+            return moduleSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckSourceUnit = function (sourceUnit, context) {
+            var _this = this;
+            this.setTypeChecked(sourceUnit, context);
+
+            this.resolveAST(sourceUnit.moduleElements, false, context);
+
+            this.typeCheckCallBacks.push(function (context) {
+                return _this.verifyUniquenessOfImportNamesInSourceUnit(sourceUnit);
+            });
+        };
+
+        PullTypeResolver.prototype.verifyUniquenessOfImportNamesInSourceUnit = function (sourceUnit) {
+            var _this = this;
+            var enclosingDecl = this.semanticInfoChain.getDeclForAST(sourceUnit);
+
+            var doesImportNameExistInOtherFiles = function (name) {
+                var importSymbol = _this.semanticInfoChain.findTopLevelSymbol(name, 128 /* TypeAlias */, null);
+                return importSymbol && importSymbol.isAlias();
+            };
+
+            this.checkUniquenessOfImportNames([enclosingDecl], doesImportNameExistInOtherFiles);
+        };
+
+        PullTypeResolver.prototype.resolveEnumDeclaration = function (ast, context) {
+            var containerDecl = this.semanticInfoChain.getDeclForAST(ast);
+            var containerSymbol = containerDecl.getSymbol();
+
+            if (containerSymbol.isResolved || containerSymbol.inResolution) {
+                return containerSymbol;
+            }
+
+            containerSymbol.inResolution = true;
+
+            var containerDecls = containerSymbol.getDeclarations();
+
+            for (var i = 0; i < containerDecls.length; i++) {
+                var childDecls = containerDecls[i].getChildDecls();
+
+                for (var j = 0; j < childDecls.length; j++) {
+                    childDecls[j].ensureSymbolIsBound();
+                }
+            }
+
+            containerSymbol.setResolved();
+
+            this.resolveOtherDeclarations(ast, context);
+
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckEnumDeclaration(ast, context);
+            }
+
+            return containerSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckEnumDeclaration = function (ast, context) {
+            var _this = this;
+            this.setTypeChecked(ast, context);
+
+            this.resolveAST(ast.enumElements, false, context);
+            var containerDecl = this.semanticInfoChain.getDeclForAST(ast);
+            this.validateVariableDeclarationGroups(containerDecl, context);
+
+            this.typeCheckCallBacks.push(function (context) {
+                return _this.checkInitializersInEnumDeclarations(containerDecl, context);
+            });
+
+            if (!TypeScript.ASTHelpers.enumIsElided(ast)) {
+                this.checkNameForCompilerGeneratedDeclarationCollision(ast, true, ast.identifier, context);
+            }
+        };
+
+        PullTypeResolver.prototype.postTypeCheckEnumDeclaration = function (ast, context) {
+            this.checkThisCaptureVariableCollides(ast, true, context);
+        };
+
+        PullTypeResolver.prototype.checkInitializersInEnumDeclarations = function (decl, context) {
+            var symbol = decl.getSymbol();
+
+            var declarations = symbol.getDeclarations();
+            if (decl !== declarations[0]) {
+                return;
+            }
+
+            var seenEnumDeclWithNoFirstMember = false;
+            for (var i = 0; i < declarations.length; ++i) {
+                var currentDecl = declarations[i];
+
+                var ast = currentDecl.ast();
+                if (ast.enumElements.nonSeparatorCount() === 0) {
+                    continue;
+                }
+
+                var firstVariable = ast.enumElements.nonSeparatorAt(0);
+                if (!firstVariable.equalsValueClause) {
+                    if (!seenEnumDeclWithNoFirstMember) {
+                        seenEnumDeclWithNoFirstMember = true;
+                    } else {
+                        this.semanticInfoChain.addDiagnosticFromAST(firstVariable, TypeScript.DiagnosticCode.In_enums_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_the_first_enum_element);
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveModuleDeclaration = function (ast, context) {
+            var result;
+
+            if (ast.stringLiteral) {
+                result = this.resolveSingleModuleDeclaration(ast, ast.stringLiteral, context);
+            } else {
+                var moduleNames = TypeScript.ASTHelpers.getModuleNames(ast.name);
+                for (var i = 0, n = moduleNames.length; i < n; i++) {
+                    result = this.resolveSingleModuleDeclaration(ast, moduleNames[i], context);
+                }
+            }
+
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckModuleDeclaration(ast, context);
+            }
+
+            return result;
+        };
+
+        PullTypeResolver.prototype.ensureAllSymbolsAreBound = function (containerSymbol) {
+            if (containerSymbol) {
+                var containerDecls = containerSymbol.getDeclarations();
+
+                for (var i = 0; i < containerDecls.length; i++) {
+                    var childDecls = containerDecls[i].getChildDecls();
+
+                    for (var j = 0; j < childDecls.length; j++) {
+                        childDecls[j].ensureSymbolIsBound();
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveModuleSymbol = function (containerSymbol, context, moduleDeclAST, moduleDeclNameAST, sourceUnitAST) {
+            if (containerSymbol.isResolved || containerSymbol.inResolution) {
+                return containerSymbol;
+            }
+
+            containerSymbol.inResolution = true;
+            this.ensureAllSymbolsAreBound(containerSymbol);
+
+            var instanceSymbol = containerSymbol.getInstanceSymbol();
+
+            if (instanceSymbol) {
+                this.resolveDeclaredSymbol(instanceSymbol, context);
+            }
+
+            var isLastName = TypeScript.ASTHelpers.isLastNameOfModule(moduleDeclAST, moduleDeclNameAST);
+            if (isLastName) {
+                this.resolveFirstExportAssignmentStatement(moduleDeclAST.moduleElements, context);
+            } else if (sourceUnitAST) {
+                this.resolveFirstExportAssignmentStatement(sourceUnitAST.moduleElements, context);
+            }
+
+            containerSymbol.setResolved();
+
+            if (moduleDeclNameAST) {
+                this.resolveOtherDeclarations(moduleDeclNameAST, context);
+            }
+
+            return containerSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveFirstExportAssignmentStatement = function (moduleElements, context) {
+            for (var i = 0, n = moduleElements.childCount(); i < n; i++) {
+                var moduleElement = moduleElements.childAt(i);
+                if (moduleElement.kind() === 134 /* ExportAssignment */) {
+                    this.resolveExportAssignmentStatement(moduleElement, context);
+                    return;
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveSingleModuleDeclaration = function (ast, astName, context) {
+            var containerDecl = this.semanticInfoChain.getDeclForAST(astName);
+            var containerSymbol = containerDecl.getSymbol();
+
+            return this.resolveModuleSymbol(containerSymbol, context, ast, astName, null);
+        };
+
+        PullTypeResolver.prototype.typeCheckModuleDeclaration = function (ast, context) {
+            if (ast.stringLiteral) {
+                this.typeCheckSingleModuleDeclaration(ast, ast.stringLiteral, context);
+            } else {
+                var moduleNames = TypeScript.ASTHelpers.getModuleNames(ast.name);
+                for (var i = 0, n = moduleNames.length; i < n; i++) {
+                    this.typeCheckSingleModuleDeclaration(ast, moduleNames[i], context);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckSingleModuleDeclaration = function (ast, astName, context) {
+            var _this = this;
+            this.setTypeChecked(ast, context);
+
+            if (TypeScript.ASTHelpers.isLastNameOfModule(ast, astName)) {
+                this.resolveAST(ast.moduleElements, false, context);
+            }
+
+            var containerDecl = this.semanticInfoChain.getDeclForAST(astName);
+            this.validateVariableDeclarationGroups(containerDecl, context);
+
+            if (ast.stringLiteral) {
+                if (TypeScript.isRelative(ast.stringLiteral.valueText())) {
+                    this.semanticInfoChain.addDiagnosticFromAST(ast.stringLiteral, TypeScript.DiagnosticCode.Ambient_external_module_declaration_cannot_specify_relative_module_name);
+                }
+            }
+
+            if (!TypeScript.ASTHelpers.moduleIsElided(ast) && !ast.stringLiteral) {
+                this.checkNameForCompilerGeneratedDeclarationCollision(astName, true, astName, context);
+            }
+
+            this.typeCheckCallBacks.push(function (context) {
+                return _this.verifyUniquenessOfImportNamesInModule(containerDecl);
+            });
+        };
+
+        PullTypeResolver.prototype.verifyUniquenessOfImportNamesInModule = function (decl) {
+            var symbol = decl.getSymbol();
+            if (!symbol) {
+                return;
+            }
+
+            var decls = symbol.getDeclarations();
+
+            if (decls[0] !== decl) {
+                return;
+            }
+
+            this.checkUniquenessOfImportNames(decls);
+        };
+
+        PullTypeResolver.prototype.checkUniquenessOfImportNames = function (decls, doesNameExistOutside) {
+            var _this = this;
+            var importDeclarationNames;
+
+            for (var i = 0; i < decls.length; ++i) {
+                var childDecls = decls[i].getChildDecls();
+                for (var j = 0; j < childDecls.length; ++j) {
+                    var childDecl = childDecls[j];
+                    if (childDecl.kind === 128 /* TypeAlias */) {
+                        importDeclarationNames = importDeclarationNames || TypeScript.createIntrinsicsObject();
+                        importDeclarationNames[childDecl.name] = true;
+                    }
+                }
+            }
+
+            if (!importDeclarationNames && !doesNameExistOutside) {
+                return;
+            }
+
+            for (var i = 0; i < decls.length; ++i) {
+                this.scanVariableDeclarationGroups(decls[i], function (firstDeclInGroup) {
+                    var nameConflict = importDeclarationNames && importDeclarationNames[firstDeclInGroup.name];
+                    if (!nameConflict) {
+                        nameConflict = doesNameExistOutside && doesNameExistOutside(firstDeclInGroup.name);
+                        if (nameConflict) {
+                            importDeclarationNames = importDeclarationNames || TypeScript.createIntrinsicsObject();
+                            importDeclarationNames[firstDeclInGroup.name] = true;
+                        }
+                    }
+
+                    if (nameConflict) {
+                        _this.semanticInfoChain.addDiagnosticFromAST(firstDeclInGroup.ast(), TypeScript.DiagnosticCode.Variable_declaration_cannot_have_the_same_name_as_an_import_declaration);
+                    }
+                });
+            }
+        };
+
+        PullTypeResolver.prototype.scanVariableDeclarationGroups = function (enclosingDecl, firstDeclHandler, subsequentDeclHandler) {
+            var declGroups = enclosingDecl.getVariableDeclGroups();
+
+            for (var i = 0; i < declGroups.length; i++) {
+                var firstSymbol = null;
+                var enclosingDeclForFirstSymbol = null;
+
+                if (enclosingDecl.kind === 1 /* Script */ && declGroups[i].length) {
+                    var name = declGroups[i][0].name;
+                    var candidateSymbol = this.semanticInfoChain.findTopLevelSymbol(name, 512 /* Variable */, enclosingDecl);
+                    if (candidateSymbol && candidateSymbol.isResolved) {
+                        if (!candidateSymbol.anyDeclHasFlag(118784 /* ImplicitVariable */)) {
+                            firstSymbol = candidateSymbol;
+                        }
+                    }
+                }
+
+                for (var j = 0; j < declGroups[i].length; j++) {
+                    var decl = declGroups[i][j];
+
+                    var name = decl.name;
+
+                    var symbol = decl.getSymbol();
+
+                    if (j === 0) {
+                        firstDeclHandler(decl);
+                        if (!subsequentDeclHandler) {
+                            break;
+                        }
+
+                        if (!firstSymbol || !firstSymbol.type) {
+                            firstSymbol = symbol;
+                            continue;
+                        }
+                    }
+
+                    subsequentDeclHandler(decl, firstSymbol);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.postTypeCheckModuleDeclaration = function (ast, context) {
+            this.checkThisCaptureVariableCollides(ast, true, context);
+        };
+
+        PullTypeResolver.prototype.isTypeRefWithoutTypeArgs = function (term) {
+            if (term.kind() === 11 /* IdentifierName */) {
+                return true;
+            } else if (term.kind() === 121 /* QualifiedName */) {
+                var binex = term;
+
+                if (binex.right.kind() === 11 /* IdentifierName */) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.createInstantiatedType = function (type, typeArguments) {
+            if (!type.isGeneric()) {
+                return type;
+            }
+
+            var typeParameters = type.getTypeArgumentsOrTypeParameters();
+
+            var typeParameterArgumentMap = [];
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameterArgumentMap[typeParameters[i].pullSymbolID] = typeArguments[i] || new TypeScript.PullErrorTypeSymbol(this.semanticInfoChain.anyTypeSymbol, typeParameters[i].name);
+            }
+
+            return TypeScript.PullInstantiatedTypeReferenceSymbol.create(this, type, typeParameterArgumentMap);
+        };
+
+        PullTypeResolver.prototype.resolveReferenceTypeDeclaration = function (classOrInterface, name, heritageClauses, context) {
+            var _this = this;
+            var typeDecl = this.semanticInfoChain.getDeclForAST(classOrInterface);
+            var enclosingDecl = this.getEnclosingDecl(typeDecl);
+            var typeDeclSymbol = typeDecl.getSymbol();
+            var typeDeclIsClass = classOrInterface.kind() === 131 /* ClassDeclaration */;
+            var hasVisited = this.getSymbolForAST(classOrInterface, context) !== null;
+
+            if ((typeDeclSymbol.isResolved && hasVisited) || (typeDeclSymbol.inResolution && !context.isInBaseTypeResolution())) {
+                return typeDeclSymbol;
+            }
+
+            var wasResolving = typeDeclSymbol.inResolution;
+            typeDeclSymbol.startResolving();
+
+            var typeRefDecls = typeDeclSymbol.getDeclarations();
+
+            for (var i = 0; i < typeRefDecls.length; i++) {
+                var childDecls = typeRefDecls[i].getChildDecls();
+
+                for (var j = 0; j < childDecls.length; j++) {
+                    childDecls[j].ensureSymbolIsBound();
+                }
+            }
+
+            if (!typeDeclSymbol.isResolved) {
+                var typeDeclTypeParameters = typeDeclSymbol.getTypeParameters();
+                for (var i = 0; i < typeDeclTypeParameters.length; i++) {
+                    this.resolveDeclaredSymbol(typeDeclTypeParameters[i], context);
+                }
+            }
+
+            var wasInBaseTypeResolution = context.startBaseTypeResolution();
+
+            if (!typeDeclIsClass && !hasVisited) {
+                typeDeclSymbol.resetKnownBaseTypeCount();
+            }
+
+            var extendsClause = TypeScript.ASTHelpers.getExtendsHeritageClause(heritageClauses);
+            if (extendsClause) {
+                for (var i = typeDeclSymbol.getKnownBaseTypeCount(); i < extendsClause.typeNames.nonSeparatorCount(); i = typeDeclSymbol.getKnownBaseTypeCount()) {
+                    typeDeclSymbol.incrementKnownBaseCount();
+                    var parentType = this.resolveTypeReference(extendsClause.typeNames.nonSeparatorAt(i), context);
+
+                    if (typeDeclSymbol.isValidBaseKind(parentType, true)) {
+                        this.setSymbolForAST(extendsClause.typeNames.nonSeparatorAt(i), parentType, null);
+
+                        if (!typeDeclSymbol.hasBase(parentType) && !parentType.hasBase(typeDeclSymbol)) {
+                            typeDeclSymbol.addExtendedType(parentType);
+
+                            var specializations = typeDeclSymbol.getKnownSpecializations();
+
+                            for (var j = 0; j < specializations.length; j++) {
+                                specializations[j].addExtendedType(parentType);
+                            }
+                        }
+                    } else if (parentType && !this.getSymbolForAST(extendsClause.typeNames.nonSeparatorAt(i), context)) {
+                        this.setSymbolForAST(extendsClause.typeNames.nonSeparatorAt(i), parentType, null);
+                    }
+                }
+            }
+
+            var implementsClause = TypeScript.ASTHelpers.getImplementsHeritageClause(heritageClauses);
+            if (implementsClause && typeDeclIsClass) {
+                var extendsCount = extendsClause ? extendsClause.typeNames.nonSeparatorCount() : 0;
+                for (var i = typeDeclSymbol.getKnownBaseTypeCount(); ((i - extendsCount) >= 0) && ((i - extendsCount) < implementsClause.typeNames.nonSeparatorCount()); i = typeDeclSymbol.getKnownBaseTypeCount()) {
+                    typeDeclSymbol.incrementKnownBaseCount();
+                    var implementedTypeAST = implementsClause.typeNames.nonSeparatorAt(i - extendsCount);
+                    var implementedType = this.resolveTypeReference(implementedTypeAST, context);
+
+                    if (typeDeclSymbol.isValidBaseKind(implementedType, false)) {
+                        this.setSymbolForAST(implementsClause.typeNames.nonSeparatorAt(i - extendsCount), implementedType, null);
+
+                        if (!typeDeclSymbol.hasBase(implementedType) && !implementedType.hasBase(typeDeclSymbol)) {
+                            typeDeclSymbol.addImplementedType(implementedType);
+                        }
+                    } else if (implementedType && !this.getSymbolForAST(implementsClause.typeNames.nonSeparatorAt(i - extendsCount), context)) {
+                        this.setSymbolForAST(implementsClause.typeNames.nonSeparatorAt(i - extendsCount), implementedType, null);
+                    }
+                }
+            }
+
+            context.doneBaseTypeResolution(wasInBaseTypeResolution);
+
+            if (wasInBaseTypeResolution) {
+                typeDeclSymbol.inResolution = false;
+
+                this.typeCheckCallBacks.push(function (context) {
+                    if (classOrInterface.kind() === 131 /* ClassDeclaration */) {
+                        _this.resolveClassDeclaration(classOrInterface, context);
+                    } else {
+                        _this.resolveInterfaceDeclaration(classOrInterface, context);
+                    }
+                });
+
+                return typeDeclSymbol;
+            }
+
+            this.setSymbolForAST(name, typeDeclSymbol, context);
+            this.setSymbolForAST(classOrInterface, typeDeclSymbol, context);
+
+            typeDeclSymbol.setResolved();
+
+            return typeDeclSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveClassDeclaration = function (classDeclAST, context) {
+            var classDecl = this.semanticInfoChain.getDeclForAST(classDeclAST);
+            var classDeclSymbol = classDecl.getSymbol();
+
+            if (!classDeclSymbol.isResolved) {
+                this.resolveReferenceTypeDeclaration(classDeclAST, classDeclAST.identifier, classDeclAST.heritageClauses, context);
+
+                var constructorMethod = classDeclSymbol.getConstructorMethod();
+                var extendedTypes = classDeclSymbol.getExtendedTypes();
+                var parentType = extendedTypes.length ? extendedTypes[0] : null;
+
+                if (constructorMethod) {
+                    if (parentType) {
+                        var parentConstructorSymbol = parentType.getConstructorMethod();
+
+                        if (parentConstructorSymbol) {
+                            var parentConstructorTypeSymbol = parentConstructorSymbol.type;
+                            var constructorTypeSymbol = constructorMethod.type;
+                            if (!constructorTypeSymbol.hasBase(parentConstructorTypeSymbol)) {
+                                constructorTypeSymbol.addExtendedType(parentConstructorTypeSymbol);
+                            }
+                        }
+                    }
+
+                    if (!classDeclSymbol.isResolved) {
+                        return classDeclSymbol;
+                    }
+                }
+
+                this.resolveOtherDeclarations(classDeclAST, context);
+            }
+
+            if (this.canTypeCheckAST(classDeclAST, context)) {
+                this.typeCheckClassDeclaration(classDeclAST, context);
+            }
+
+            return classDeclSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckTypeParametersOfTypeDeclaration = function (classOrInterface, context) {
+            var _this = this;
+            var typeParametersList = classOrInterface.kind() == 131 /* ClassDeclaration */ ? classOrInterface.typeParameterList : classOrInterface.typeParameterList;
+
+            if (typeParametersList) {
+                var typeDecl = this.semanticInfoChain.getDeclForAST(classOrInterface);
+                var typeDeclSymbol = typeDecl.getSymbol();
+
+                for (var i = 0; i < typeParametersList.typeParameters.nonSeparatorCount(); i++) {
+                    var typeParameterAST = typeParametersList.typeParameters.nonSeparatorAt(i);
+                    this.resolveTypeParameterDeclaration(typeParameterAST, context);
+
+                    var typeParameterDecl = this.semanticInfoChain.getDeclForAST(typeParameterAST);
+                    var typeParameterSymbol = typeParameterDecl.getSymbol();
+
+                    this.checkSymbolPrivacy(typeDeclSymbol, typeParameterSymbol, function (symbol) {
+                        return _this.typeParameterOfTypeDeclarationPrivacyErrorReporter(classOrInterface, typeParameterAST, typeParameterSymbol, symbol, context);
+                    });
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckClassDeclaration = function (classDeclAST, context) {
+            this.setTypeChecked(classDeclAST, context);
+
+            var classDecl = this.semanticInfoChain.getDeclForAST(classDeclAST);
+            var classDeclSymbol = classDecl.getSymbol();
+
+            this.checkNameForCompilerGeneratedDeclarationCollision(classDeclAST, true, classDeclAST.identifier, context);
+            this.resolveAST(classDeclAST.classElements, false, context);
+
+            this.typeCheckTypeParametersOfTypeDeclaration(classDeclAST, context);
+            this.typeCheckBases(classDeclAST, classDeclAST.identifier, classDeclAST.heritageClauses, classDeclSymbol, this.getEnclosingDecl(classDecl), context);
+
+            if (!classDeclSymbol.hasBaseTypeConflict()) {
+                this.typeCheckMembersAgainstIndexer(classDeclSymbol, classDecl, context);
+            }
+
+            this.checkTypeForDuplicateIndexSignatures(classDeclSymbol);
+        };
+
+        PullTypeResolver.prototype.postTypeCheckClassDeclaration = function (classDeclAST, context) {
+            this.checkThisCaptureVariableCollides(classDeclAST, true, context);
+        };
+
+        PullTypeResolver.prototype.resolveTypeSymbolSignatures = function (typeSymbol, context) {
+            var callSignatures = typeSymbol.getCallSignatures();
+            for (var i = 0; i < callSignatures.length; i++) {
+                this.resolveDeclaredSymbol(callSignatures[i], context);
+            }
+
+            var constructSignatures = typeSymbol.getConstructSignatures();
+            for (var i = 0; i < constructSignatures.length; i++) {
+                this.resolveDeclaredSymbol(constructSignatures[i], context);
+            }
+
+            var indexSignatures = typeSymbol.getIndexSignatures();
+            for (var i = 0; i < indexSignatures.length; i++) {
+                this.resolveDeclaredSymbol(indexSignatures[i], context);
+            }
+        };
+
+        PullTypeResolver.prototype.resolveInterfaceDeclaration = function (interfaceDeclAST, context) {
+            this.resolveReferenceTypeDeclaration(interfaceDeclAST, interfaceDeclAST.identifier, interfaceDeclAST.heritageClauses, context);
+
+            var interfaceDecl = this.semanticInfoChain.getDeclForAST(interfaceDeclAST);
+            var interfaceDeclSymbol = interfaceDecl.getSymbol();
+
+            this.resolveTypeSymbolSignatures(interfaceDeclSymbol, context);
+
+            if (interfaceDeclSymbol.isResolved) {
+                this.resolveOtherDeclarations(interfaceDeclAST, context);
+
+                if (this.canTypeCheckAST(interfaceDeclAST, context)) {
+                    this.typeCheckInterfaceDeclaration(interfaceDeclAST, context);
+                }
+            }
+
+            return interfaceDeclSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckInterfaceDeclaration = function (interfaceDeclAST, context) {
+            this.setTypeChecked(interfaceDeclAST, context);
+
+            var interfaceDecl = this.semanticInfoChain.getDeclForAST(interfaceDeclAST);
+            var interfaceDeclSymbol = interfaceDecl.getSymbol();
+
+            this.resolveAST(interfaceDeclAST.body.typeMembers, false, context);
+
+            this.typeCheckTypeParametersOfTypeDeclaration(interfaceDeclAST, context);
+            this.typeCheckBases(interfaceDeclAST, interfaceDeclAST.identifier, interfaceDeclAST.heritageClauses, interfaceDeclSymbol, this.getEnclosingDecl(interfaceDecl), context);
+
+            if (!interfaceDeclSymbol.hasBaseTypeConflict()) {
+                this.typeCheckMembersAgainstIndexer(interfaceDeclSymbol, interfaceDecl, context);
+            }
+
+            var allInterfaceDecls = interfaceDeclSymbol.getDeclarations();
+            if (interfaceDecl === allInterfaceDecls[allInterfaceDecls.length - 1]) {
+                this.checkTypeForDuplicateIndexSignatures(interfaceDeclSymbol);
+            }
+
+            if (!this.checkInterfaceDeclForIdenticalTypeParameters(interfaceDeclAST, context)) {
+                this.semanticInfoChain.addDiagnosticFromAST(interfaceDeclAST.identifier, TypeScript.DiagnosticCode.All_declarations_of_an_interface_must_have_identical_type_parameters);
+            }
+        };
+
+        PullTypeResolver.prototype.checkInterfaceDeclForIdenticalTypeParameters = function (interfaceDeclAST, context) {
+            var interfaceDecl = this.semanticInfoChain.getDeclForAST(interfaceDeclAST);
+            var interfaceDeclSymbol = interfaceDecl.getSymbol();
+
+            if (!interfaceDeclSymbol.isGeneric()) {
+                return true;
+            }
+
+            var firstInterfaceDecl = interfaceDeclSymbol.getDeclarations()[0];
+            if (firstInterfaceDecl == interfaceDecl) {
+                return true;
+            }
+
+            var typeParameters = interfaceDecl.getTypeParameters();
+            var firstInterfaceDeclTypeParameters = firstInterfaceDecl.getTypeParameters();
+
+            if (typeParameters.length != firstInterfaceDeclTypeParameters.length) {
+                return false;
+            }
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                var typeParameter = typeParameters[i];
+                var firstInterfaceDeclTypeParameter = firstInterfaceDeclTypeParameters[i];
+
+                if (typeParameter.name != firstInterfaceDeclTypeParameter.name) {
+                    return false;
+                }
+
+                var typeParameterSymbol = typeParameter.getSymbol();
+                var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter);
+                var firstInterfaceDeclTypeParameterAST = this.semanticInfoChain.getASTForDecl(firstInterfaceDeclTypeParameter);
+
+                if (!!typeParameterAST.constraint != !!firstInterfaceDeclTypeParameterAST.constraint) {
+                    return false;
+                }
+
+                if (typeParameterAST.constraint) {
+                    var typeParameterConstraint = this.resolveAST(typeParameterAST.constraint, false, context);
+                    if (!this.typesAreIdenticalWithNewEnclosingTypes(typeParameterConstraint, typeParameterSymbol.getConstraint(), context)) {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.checkTypeForDuplicateIndexSignatures = function (enclosingTypeSymbol) {
+            var indexSignatures = enclosingTypeSymbol.getOwnIndexSignatures();
+            var firstStringIndexer = null;
+            var firstNumberIndexer = null;
+            for (var i = 0; i < indexSignatures.length; i++) {
+                var currentIndexer = indexSignatures[i];
+                var currentParameterType = currentIndexer.parameters[0].type;
+                TypeScript.Debug.assert(currentParameterType);
+                if (currentParameterType === this.semanticInfoChain.stringTypeSymbol) {
+                    if (firstStringIndexer) {
+                        this.semanticInfoChain.addDiagnosticFromAST(currentIndexer.getDeclarations()[0].ast(), TypeScript.DiagnosticCode.Duplicate_string_index_signature, null, [this.semanticInfoChain.locationFromAST(firstStringIndexer.getDeclarations()[0].ast())]);
+                        return;
+                    } else {
+                        firstStringIndexer = currentIndexer;
+                    }
+                } else if (currentParameterType === this.semanticInfoChain.numberTypeSymbol) {
+                    if (firstNumberIndexer) {
+                        this.semanticInfoChain.addDiagnosticFromAST(currentIndexer.getDeclarations()[0].ast(), TypeScript.DiagnosticCode.Duplicate_number_index_signature, null, [this.semanticInfoChain.locationFromAST(firstNumberIndexer.getDeclarations()[0].ast())]);
+                        return;
+                    } else {
+                        firstNumberIndexer = currentIndexer;
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.filterSymbol = function (symbol, kind, enclosingDecl, context) {
+            if (symbol) {
+                if (symbol.kind & kind) {
+                    return symbol;
+                }
+
+                if (symbol.isAlias()) {
+                    this.resolveDeclaredSymbol(symbol, context);
+
+                    var alias = symbol;
+                    if (kind & 164 /* SomeContainer */) {
+                        return alias.getExportAssignedContainerSymbol();
+                    } else if (kind & 58728795 /* SomeType */) {
+                        return alias.getExportAssignedTypeSymbol();
+                    } else if (kind & 68147712 /* SomeValue */) {
+                        return alias.getExportAssignedValueSymbol();
+                    }
+                }
+            }
+            return null;
+        };
+
+        PullTypeResolver.prototype.getMemberSymbolOfKind = function (symbolName, kind, pullTypeSymbol, enclosingDecl, context) {
+            var memberSymbol = this.getNamedPropertySymbol(symbolName, kind, pullTypeSymbol);
+
+            return {
+                symbol: this.filterSymbol(memberSymbol, kind, enclosingDecl, context),
+                aliasSymbol: memberSymbol && memberSymbol.isAlias() ? memberSymbol : null
+            };
+        };
+
+        PullTypeResolver.prototype.resolveIdentifierOfInternalModuleReference = function (importDecl, identifier, moduleSymbol, enclosingDecl, context) {
+            var rhsName = identifier.valueText();
+            if (rhsName.length === 0) {
+                return null;
+            }
+
+            var moduleTypeSymbol = moduleSymbol.type;
+            var memberSymbol = this.getMemberSymbolOfKind(rhsName, 164 /* SomeContainer */, moduleTypeSymbol, enclosingDecl, context);
+            var containerSymbol = memberSymbol.symbol;
+            var valueSymbol = null;
+            var typeSymbol = null;
+            var aliasSymbol = null;
+
+            var acceptableAlias = true;
+
+            if (containerSymbol) {
+                acceptableAlias = (containerSymbol.kind & 59753052 /* AcceptableAlias */) !== 0;
+                aliasSymbol = memberSymbol.aliasSymbol;
+            }
+
+            if (!acceptableAlias && containerSymbol && containerSymbol.kind === 128 /* TypeAlias */) {
+                this.resolveDeclaredSymbol(containerSymbol, context);
+                var aliasedAssignedValue = containerSymbol.getExportAssignedValueSymbol();
+                var aliasedAssignedType = containerSymbol.getExportAssignedTypeSymbol();
+                var aliasedAssignedContainer = containerSymbol.getExportAssignedContainerSymbol();
+
+                if (aliasedAssignedValue || aliasedAssignedType || aliasedAssignedContainer) {
+                    aliasSymbol = containerSymbol;
+                    valueSymbol = aliasedAssignedValue;
+                    typeSymbol = aliasedAssignedType;
+                    containerSymbol = aliasedAssignedContainer;
+                    acceptableAlias = true;
+                }
+            }
+
+            if (!acceptableAlias) {
+                this.semanticInfoChain.addDiagnosticFromAST(identifier, TypeScript.DiagnosticCode.Import_declaration_referencing_identifier_from_internal_module_can_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules);
+                return null;
+            }
+
+            if (!valueSymbol) {
+                if (moduleTypeSymbol.getInstanceSymbol()) {
+                    memberSymbol = this.getMemberSymbolOfKind(rhsName, 68147712 /* SomeValue */, moduleTypeSymbol.getInstanceSymbol().type, enclosingDecl, context);
+                    valueSymbol = memberSymbol.symbol;
+                    if (valueSymbol && memberSymbol.aliasSymbol) {
+                        aliasSymbol = memberSymbol.aliasSymbol;
+                    }
+                }
+            }
+
+            if (!typeSymbol) {
+                memberSymbol = this.getMemberSymbolOfKind(rhsName, 58728795 /* SomeType */, moduleTypeSymbol, enclosingDecl, context);
+                typeSymbol = memberSymbol.symbol;
+                if (typeSymbol && memberSymbol.aliasSymbol) {
+                    aliasSymbol = memberSymbol.aliasSymbol;
+                }
+            }
+
+            if (!valueSymbol && !typeSymbol && !containerSymbol) {
+                this.semanticInfoChain.addDiagnosticFromAST(identifier, TypeScript.DiagnosticCode.Could_not_find_symbol_0_in_module_1, [rhsName, moduleSymbol.toString()]);
+                return null;
+            }
+
+            if (!typeSymbol && containerSymbol) {
+                typeSymbol = containerSymbol;
+            }
+
+            return {
+                valueSymbol: valueSymbol,
+                typeSymbol: typeSymbol,
+                containerSymbol: containerSymbol,
+                aliasSymbol: aliasSymbol
+            };
+        };
+
+        PullTypeResolver.prototype.resolveModuleReference = function (importDecl, moduleNameExpr, enclosingDecl, context, declPath) {
+            TypeScript.Debug.assert(moduleNameExpr.kind() === 121 /* QualifiedName */ || moduleNameExpr.kind() === 11 /* IdentifierName */ || moduleNameExpr.kind() === 14 /* StringLiteral */, "resolving module reference should always be either name or member reference");
+
+            var moduleSymbol = null;
+            var moduleName;
+
+            if (moduleNameExpr.kind() === 121 /* QualifiedName */) {
+                var dottedNameAST = moduleNameExpr;
+                var moduleContainer = this.resolveModuleReference(importDecl, dottedNameAST.left, enclosingDecl, context, declPath);
+                if (moduleContainer) {
+                    moduleName = dottedNameAST.right.valueText();
+
+                    moduleSymbol = this.getMemberSymbolOfKind(moduleName, 4 /* Container */, moduleContainer.type, enclosingDecl, context).symbol;
+                    if (!moduleSymbol) {
+                        this.semanticInfoChain.addDiagnosticFromAST(dottedNameAST.right, TypeScript.DiagnosticCode.Could_not_find_module_0_in_module_1, [moduleName, moduleContainer.toString()]);
+                    }
+                }
+            } else {
+                var valueText = moduleNameExpr.kind() === 11 /* IdentifierName */ ? moduleNameExpr.valueText() : moduleNameExpr.valueText();
+                var text = moduleNameExpr.kind() === 11 /* IdentifierName */ ? moduleNameExpr.text() : moduleNameExpr.text();
+
+                if (text.length > 0) {
+                    var resolvedModuleNameSymbol = this.getSymbolFromDeclPath(valueText, declPath, 4 /* Container */);
+                    moduleSymbol = this.filterSymbol(resolvedModuleNameSymbol, 4 /* Container */, enclosingDecl, context);
+                    if (moduleSymbol) {
+                        this.semanticInfoChain.setSymbolForAST(moduleNameExpr, moduleSymbol);
+                        if (resolvedModuleNameSymbol.isAlias()) {
+                            this.semanticInfoChain.setAliasSymbolForAST(moduleNameExpr, resolvedModuleNameSymbol);
+                            var importDeclSymbol = importDecl.getSymbol();
+                            importDeclSymbol.addLinkedAliasSymbol(resolvedModuleNameSymbol);
+                        }
+                    } else {
+                        this.semanticInfoChain.addDiagnosticFromAST(moduleNameExpr, TypeScript.DiagnosticCode.Unable_to_resolve_module_reference_0, [valueText]);
+                    }
+                }
+            }
+
+            return moduleSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveInternalModuleReference = function (importStatementAST, context) {
+            var importDecl = this.semanticInfoChain.getDeclForAST(importStatementAST);
+            var enclosingDecl = this.getEnclosingDecl(importDecl);
+
+            var moduleReference = importStatementAST.moduleReference;
+
+            var aliasExpr = moduleReference.kind() === 245 /* ExternalModuleReference */ ? moduleReference.stringLiteral : moduleReference.moduleName;
+
+            var declPath = enclosingDecl.getParentPath();
+            var aliasedType = null;
+            var importDeclSymbol = importDecl.getSymbol();
+
+            if (aliasExpr.kind() === 11 /* IdentifierName */ || aliasExpr.kind() === 14 /* StringLiteral */) {
+                var moduleSymbol = this.resolveModuleReference(importDecl, aliasExpr, enclosingDecl, context, declPath);
+                if (moduleSymbol) {
+                    aliasedType = moduleSymbol.type;
+                    this.semanticInfoChain.setAliasSymbolForAST(moduleReference, this.semanticInfoChain.getAliasSymbolForAST(aliasExpr));
+                    if (aliasedType.anyDeclHasFlag(32768 /* InitializedModule */)) {
+                        var moduleName = aliasExpr.kind() === 11 /* IdentifierName */ ? aliasExpr.valueText() : aliasExpr.valueText();
+                        var valueSymbol = this.getSymbolFromDeclPath(moduleName, declPath, 68147712 /* SomeValue */);
+                        var instanceSymbol = aliasedType.getInstanceSymbol();
+
+                        if (valueSymbol && (instanceSymbol != valueSymbol || valueSymbol.type === aliasedType)) {
+                            var text = aliasExpr.kind() === 11 /* IdentifierName */ ? aliasExpr.text() : aliasExpr.text();
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(aliasExpr, TypeScript.DiagnosticCode.Internal_module_reference_0_in_import_declaration_does_not_reference_module_instance_for_1, [text, moduleSymbol.type.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)]));
+                        } else {
+                            importDeclSymbol.setAssignedValueSymbol(valueSymbol);
+                        }
+                    }
+                } else {
+                    aliasedType = this.getNewErrorTypeSymbol();
+                }
+            } else if (aliasExpr.kind() === 121 /* QualifiedName */) {
+                var dottedNameAST = aliasExpr;
+                var moduleSymbol = this.resolveModuleReference(importDecl, dottedNameAST.left, enclosingDecl, context, declPath);
+                if (moduleSymbol) {
+                    var identifierResolution = this.resolveIdentifierOfInternalModuleReference(importDecl, dottedNameAST.right, moduleSymbol, enclosingDecl, context);
+                    if (identifierResolution) {
+                        importDeclSymbol.setAssignedValueSymbol(identifierResolution.valueSymbol);
+                        importDeclSymbol.setAssignedTypeSymbol(identifierResolution.typeSymbol);
+                        importDeclSymbol.setAssignedContainerSymbol(identifierResolution.containerSymbol);
+                        this.semanticInfoChain.setAliasSymbolForAST(moduleReference, identifierResolution.aliasSymbol);
+                        return null;
+                    }
+                }
+            }
+
+            if (!aliasedType) {
+                importDeclSymbol.setAssignedTypeSymbol(this.getNewErrorTypeSymbol());
+            }
+
+            return aliasedType;
+        };
+
+        PullTypeResolver.prototype.resolveImportDeclaration = function (importStatementAST, context) {
+            var importDecl = this.semanticInfoChain.getDeclForAST(importStatementAST);
+            var enclosingDecl = this.getEnclosingDecl(importDecl);
+            var importDeclSymbol = importDecl.getSymbol();
+
+            var aliasedType = null;
+
+            if (importDeclSymbol.isResolved) {
+                return importDeclSymbol;
+            }
+
+            importDeclSymbol.startResolving();
+
+            if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) {
+                var modPath = importStatementAST.moduleReference.stringLiteral.valueText();
+                var declPath = enclosingDecl.getParentPath();
+
+                aliasedType = this.resolveExternalModuleReference(modPath, importDecl.fileName());
+
+                if (!aliasedType) {
+                    var path = importStatementAST.moduleReference.stringLiteral.text();
+                    this.semanticInfoChain.addDiagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Unable_to_resolve_external_module_0, [path]);
+                    aliasedType = this.getNewErrorTypeSymbol();
+                }
+            } else {
+                aliasedType = this.resolveInternalModuleReference(importStatementAST, context);
+            }
+
+            if (aliasedType) {
+                if (!aliasedType.isContainer()) {
+                    this.semanticInfoChain.addDiagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Module_cannot_be_aliased_to_a_non_module_type);
+                    if (!aliasedType.isError()) {
+                        aliasedType = this.getNewErrorTypeSymbol();
+                    }
+                }
+
+                if (aliasedType.isContainer()) {
+                    importDeclSymbol.setAssignedContainerSymbol(aliasedType);
+                }
+                importDeclSymbol.setAssignedTypeSymbol(aliasedType);
+
+                this.setSymbolForAST(importStatementAST.moduleReference, aliasedType, null);
+            }
+
+            importDeclSymbol.setResolved();
+
+            this.resolveDeclaredSymbol(importDeclSymbol.assignedValue(), context);
+            this.resolveDeclaredSymbol(importDeclSymbol.assignedType(), context);
+            this.resolveDeclaredSymbol(importDeclSymbol.assignedContainer(), context);
+
+            if (aliasedType && importDeclSymbol.anyDeclHasFlag(1 /* Exported */)) {
+                importDeclSymbol.setIsUsedInExportedAlias();
+
+                if (aliasedType.isContainer() && aliasedType.getExportAssignedValueSymbol()) {
+                    importDeclSymbol.setIsUsedAsValue();
+                }
+            }
+
+            if (this.canTypeCheckAST(importStatementAST, context)) {
+                this.typeCheckImportDeclaration(importStatementAST, context);
+            }
+
+            return importDeclSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckImportDeclaration = function (importStatementAST, context) {
+            var _this = this;
+            this.setTypeChecked(importStatementAST, context);
+
+            var importDecl = this.semanticInfoChain.getDeclForAST(importStatementAST);
+            var enclosingDecl = this.getEnclosingDecl(importDecl);
+            var importDeclSymbol = importDecl.getSymbol();
+
+            if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) {
+                if (this.compilationSettings.noResolve()) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Import_declaration_cannot_refer_to_external_module_reference_when_noResolve_option_is_set, null));
+                }
+
+                var modPath = importStatementAST.moduleReference.stringLiteral.valueText();
+                if (enclosingDecl.kind === 32 /* DynamicModule */) {
+                    var ast = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(this.getASTForDecl(enclosingDecl));
+                    if (ast && ast.kind() === 130 /* ModuleDeclaration */) {
+                        if (TypeScript.isRelative(modPath)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Import_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name));
+                        }
+                    }
+                }
+            }
+
+            var checkPrivacy;
+            if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) {
+                var containerSymbol = importDeclSymbol.getExportAssignedContainerSymbol();
+                var container = containerSymbol ? containerSymbol.getContainer() : null;
+                if (container && container.kind === 32 /* DynamicModule */) {
+                    checkPrivacy = true;
+                }
+            } else {
+                checkPrivacy = true;
+            }
+
+            if (checkPrivacy) {
+                var typeSymbol = importDeclSymbol.getExportAssignedTypeSymbol();
+                var containerSymbol = importDeclSymbol.getExportAssignedContainerSymbol();
+                var valueSymbol = importDeclSymbol.getExportAssignedValueSymbol();
+
+                this.checkSymbolPrivacy(importDeclSymbol, containerSymbol, function (symbol) {
+                    var messageCode = TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_container_that_is_or_is_using_inaccessible_module_1;
+                    var messageArguments = [importDeclSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null), symbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null, false, false, true)];
+                    context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(importStatementAST, messageCode, messageArguments));
+                });
+
+                if (typeSymbol !== containerSymbol) {
+                    this.checkSymbolPrivacy(importDeclSymbol, typeSymbol, function (symbol) {
+                        var messageCode = symbol.isContainer() && !symbol.isEnum() ? TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_type_that_is_using_inaccessible_module_1 : TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_type_that_has_or_is_using_private_type_1;
+
+                        var messageArguments = [importDeclSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null), symbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null, false, false, true)];
+                        context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(importStatementAST, messageCode, messageArguments));
+                    });
+                }
+
+                if (valueSymbol) {
+                    this.checkSymbolPrivacy(importDeclSymbol, valueSymbol.type, function (symbol) {
+                        var messageCode = symbol.isContainer() && !symbol.isEnum() ? TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_value_with_type_that_is_using_inaccessible_module_1 : TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_value_with_type_that_has_or_is_using_private_type_1;
+                        var messageArguments = [importDeclSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null), symbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null, false, false, true)];
+                        context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(importStatementAST, messageCode, messageArguments));
+                    });
+                }
+            }
+
+            this.checkNameForCompilerGeneratedDeclarationCollision(importStatementAST, true, importStatementAST.identifier, context);
+        };
+
+        PullTypeResolver.prototype.postTypeCheckImportDeclaration = function (importStatementAST, context) {
+            var importDecl = this.semanticInfoChain.getDeclForAST(importStatementAST);
+            var importSymbol = importDecl.getSymbol();
+
+            var isUsedAsValue = importSymbol.isUsedAsValue();
+            var hasAssignedValue = importStatementAST.moduleReference.kind() !== 245 /* ExternalModuleReference */ && importSymbol.getExportAssignedValueSymbol() !== null;
+
+            if (isUsedAsValue || hasAssignedValue) {
+                this.checkThisCaptureVariableCollides(importStatementAST, true, context);
+            }
+        };
+
+        PullTypeResolver.prototype.resolveExportAssignmentStatement = function (exportAssignmentAST, context) {
+            var id = exportAssignmentAST.identifier.valueText();
+            if (id.length === 0) {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var valueSymbol = null;
+            var typeSymbol = null;
+            var containerSymbol = null;
+
+            var enclosingDecl = this.getEnclosingDeclForAST(exportAssignmentAST);
+            var parentSymbol = enclosingDecl.getSymbol();
+
+            if (!parentSymbol.isType() && parentSymbol.isContainer()) {
+                this.semanticInfoChain.addDiagnosticFromAST(exportAssignmentAST, TypeScript.DiagnosticCode.Export_assignments_may_only_be_used_at_the_top_level_of_external_modules);
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var declPath = enclosingDecl !== null ? [enclosingDecl] : [];
+
+            containerSymbol = this.getSymbolFromDeclPath(id, declPath, 164 /* SomeContainer */);
+
+            var acceptableAlias = true;
+
+            if (containerSymbol) {
+                acceptableAlias = (containerSymbol.kind & 59753052 /* AcceptableAlias */) !== 0;
+            }
+
+            if (!acceptableAlias && containerSymbol && containerSymbol.kind === 128 /* TypeAlias */) {
+                this.resolveDeclaredSymbol(containerSymbol, context);
+
+                var aliasSymbol = containerSymbol;
+                var aliasedAssignedValue = aliasSymbol.getExportAssignedValueSymbol();
+                var aliasedAssignedType = aliasSymbol.getExportAssignedTypeSymbol();
+                var aliasedAssignedContainer = aliasSymbol.getExportAssignedContainerSymbol();
+
+                if (aliasedAssignedValue || aliasedAssignedType || aliasedAssignedContainer) {
+                    valueSymbol = aliasedAssignedValue;
+                    typeSymbol = aliasedAssignedType;
+                    containerSymbol = aliasedAssignedContainer;
+                    aliasSymbol.setTypeUsedExternally();
+                    if (valueSymbol) {
+                        aliasSymbol.setIsUsedAsValue();
+                    }
+                    acceptableAlias = true;
+                }
+            }
+
+            if (!acceptableAlias) {
+                this.semanticInfoChain.addDiagnosticFromAST(exportAssignmentAST, TypeScript.DiagnosticCode.Export_assignments_may_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules);
+                return this.semanticInfoChain.voidTypeSymbol;
+            }
+
+            if (!valueSymbol) {
+                valueSymbol = this.getSymbolFromDeclPath(id, declPath, 68147712 /* SomeValue */);
+            }
+            if (!typeSymbol) {
+                typeSymbol = this.getSymbolFromDeclPath(id, declPath, 58728795 /* SomeType */);
+            }
+
+            if (!valueSymbol && !typeSymbol && !containerSymbol) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(exportAssignmentAST, TypeScript.DiagnosticCode.Could_not_find_symbol_0, [id]));
+                return this.semanticInfoChain.voidTypeSymbol;
+            }
+
+            if (valueSymbol) {
+                parentSymbol.setExportAssignedValueSymbol(valueSymbol);
+            }
+            if (typeSymbol) {
+                parentSymbol.setExportAssignedTypeSymbol(typeSymbol);
+            }
+            if (containerSymbol) {
+                parentSymbol.setExportAssignedContainerSymbol(containerSymbol);
+            }
+
+            this.resolveDeclaredSymbol(valueSymbol, context);
+            this.resolveDeclaredSymbol(typeSymbol, context);
+            this.resolveDeclaredSymbol(containerSymbol, context);
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveAnyFunctionTypeSignature = function (funcDeclAST, typeParameters, parameterList, returnTypeAnnotation, context) {
+            var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            TypeScript.Debug.assert(functionDecl);
+
+            var funcDeclSymbol = functionDecl.getSymbol();
+
+            var signature = funcDeclSymbol.kind === 33554432 /* ConstructorType */ ? funcDeclSymbol.getConstructSignatures()[0] : funcDeclSymbol.getCallSignatures()[0];
+
+            if (returnTypeAnnotation) {
+                signature.returnType = this.resolveTypeReference(returnTypeAnnotation, context);
+            }
+
+            if (typeParameters) {
+                for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) {
+                    this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context);
+                }
+            }
+
+            if (parameterList) {
+                for (var i = 0; i < parameterList.parameters.nonSeparatorCount(); i++) {
+                    this.resolveFunctionTypeSignatureParameter(parameterList.parameters.nonSeparatorAt(i), signature, functionDecl, context);
+                }
+            }
+
+            funcDeclSymbol.setResolved();
+
+            if (this.canTypeCheckAST(funcDeclAST, context)) {
+                this.setTypeChecked(funcDeclAST, context);
+                this.typeCheckFunctionOverloads(funcDeclAST, context);
+            }
+
+            return funcDeclSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveFunctionTypeSignatureParameter = function (argDeclAST, signature, enclosingDecl, context) {
+            var paramDecl = this.semanticInfoChain.getDeclForAST(argDeclAST);
+            var paramSymbol = paramDecl.getSymbol();
+
+            if (argDeclAST.typeAnnotation) {
+                var typeRef = this.resolveTypeReference(TypeScript.ASTHelpers.getType(argDeclAST), context);
+
+                if (paramSymbol.isVarArg && !typeRef.isArrayNamedTypeReference()) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Rest_parameters_must_be_array_types));
+                    typeRef = this.getNewErrorTypeSymbol();
+                }
+
+                context.setTypeInContext(paramSymbol, typeRef);
+            } else {
+                if (paramSymbol.isVarArg) {
+                    if (this.cachedArrayInterfaceType()) {
+                        context.setTypeInContext(paramSymbol, this.createInstantiatedType(this.cachedArrayInterfaceType(), [this.semanticInfoChain.anyTypeSymbol]));
+                    } else {
+                        context.setTypeInContext(paramSymbol, this.semanticInfoChain.anyTypeSymbol);
+                    }
+                } else {
+                    context.setTypeInContext(paramSymbol, this.semanticInfoChain.anyTypeSymbol);
+                }
+
+                if (this.compilationSettings.noImplicitAny()) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Parameter_0_of_function_type_implicitly_has_an_any_type, [argDeclAST.identifier.text()]));
+                }
+            }
+
+            if (TypeScript.hasFlag(paramDecl.flags, 128 /* Optional */) && argDeclAST.equalsValueClause && isTypesOnlyLocation(argDeclAST)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Default_arguments_are_only_allowed_in_implementation));
+            }
+
+            paramSymbol.setResolved();
+        };
+
+        PullTypeResolver.prototype.resolveFunctionExpressionParameter = function (argDeclAST, id, typeExpr, equalsValueClause, contextParam, enclosingDecl, context) {
+            var paramDecl = this.semanticInfoChain.getDeclForAST(argDeclAST);
+            var paramSymbol = paramDecl.getSymbol();
+            var contextualType = contextParam && contextParam.type;
+            var isImplicitAny = false;
+
+            if (typeExpr) {
+                var typeRef = this.resolveTypeReference(typeExpr, context);
+
+                if (paramSymbol.isVarArg && !typeRef.isArrayNamedTypeReference()) {
+                    var diagnostic = context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Rest_parameters_must_be_array_types));
+                    typeRef = this.getNewErrorTypeSymbol();
+                }
+
+                contextualType = typeRef || contextualType;
+            }
+            if (contextualType) {
+                if (context.isInferentiallyTyping()) {
+                    contextualType = context.fixAllTypeParametersReferencedByType(contextualType, this);
+                }
+                context.setTypeInContext(paramSymbol, contextualType);
+            } else if (paramSymbol.isVarArg) {
+                if (this.cachedArrayInterfaceType()) {
+                    context.setTypeInContext(paramSymbol, this.createInstantiatedType(this.cachedArrayInterfaceType(), [this.semanticInfoChain.anyTypeSymbol]));
+                } else {
+                    context.setTypeInContext(paramSymbol, this.semanticInfoChain.anyTypeSymbol);
+                }
+                isImplicitAny = true;
+            }
+
+            var canTypeCheckAST = this.canTypeCheckAST(argDeclAST, context);
+            if (equalsValueClause && (canTypeCheckAST || !contextualType)) {
+                if (contextualType) {
+                    context.propagateContextualType(contextualType);
+                }
+
+                var initExprSymbol = this.resolveAST(equalsValueClause, contextualType !== null, context);
+
+                if (contextualType) {
+                    context.popAnyContextualType();
+                }
+
+                if (!initExprSymbol || !initExprSymbol.type) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Unable_to_resolve_type_of_0, [id.text()]));
+
+                    if (!contextualType) {
+                        context.setTypeInContext(paramSymbol, this.getNewErrorTypeSymbol(paramSymbol.name));
+                    }
+                } else {
+                    var initTypeSymbol = this.getInstanceTypeForAssignment(argDeclAST, initExprSymbol.type, context);
+                    if (!contextualType) {
+                        context.setTypeInContext(paramSymbol, initTypeSymbol.widenedType(this, equalsValueClause, context));
+                        isImplicitAny = initTypeSymbol !== paramSymbol.type;
+                    } else {
+                        var comparisonInfo = new TypeComparisonInfo();
+
+                        var isAssignable = this.sourceIsAssignableToTarget(initTypeSymbol, contextualType, argDeclAST, context, comparisonInfo);
+
+                        if (!isAssignable) {
+                            var enclosingSymbol = this.getEnclosingSymbolForAST(argDeclAST);
+                            if (comparisonInfo.message) {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [initTypeSymbol.toString(enclosingSymbol), contextualType.toString(enclosingSymbol), comparisonInfo.message]));
+                            } else {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [initTypeSymbol.toString(enclosingSymbol), contextualType.toString(enclosingSymbol)]));
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (!contextualType && !paramSymbol.isVarArg && !initTypeSymbol) {
+                context.setTypeInContext(paramSymbol, this.semanticInfoChain.anyTypeSymbol);
+                isImplicitAny = true;
+            }
+
+            if (isImplicitAny && this.compilationSettings.noImplicitAny()) {
+                var functionExpressionName = paramDecl.getParentDecl().getFunctionExpressionName();
+                if (functionExpressionName) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Parameter_0_of_1_implicitly_has_an_any_type, [id.text(), functionExpressionName]));
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Parameter_0_of_lambda_function_implicitly_has_an_any_type, [id.text()]));
+                }
+            }
+
+            if (canTypeCheckAST) {
+                this.checkNameForCompilerGeneratedDeclarationCollision(argDeclAST, true, id, context);
+            }
+
+            paramSymbol.setResolved();
+        };
+
+        PullTypeResolver.prototype.checkNameForCompilerGeneratedDeclarationCollision = function (astWithName, isDeclaration, name, context) {
+            var compilerReservedName = getCompilerReservedName(name);
+            switch (compilerReservedName) {
+                case 1 /* _this */:
+                    this.postTypeCheckWorkitems.push(astWithName);
+                    return;
+
+                case 2 /* _super */:
+                    this.checkSuperCaptureVariableCollides(astWithName, isDeclaration, context);
+                    return;
+
+                case 3 /* arguments */:
+                    this.checkArgumentsCollides(astWithName, context);
+                    return;
+
+                case 4 /* _i */:
+                    this.checkIndexOfRestArgumentInitializationCollides(astWithName, isDeclaration, context);
+                    return;
+
+                case 5 /* require */:
+                case 6 /* exports */:
+                    if (isDeclaration) {
+                        this.checkExternalModuleRequireExportsCollides(astWithName, name, context);
+                    }
+                    return;
+            }
+        };
+
+        PullTypeResolver.prototype.hasRestParameterCodeGen = function (someFunctionDecl) {
+            var enclosingAST = this.getASTForDecl(someFunctionDecl);
+            var nodeType = enclosingAST.kind();
+
+            if (nodeType === 129 /* FunctionDeclaration */) {
+                var functionDeclaration = enclosingAST;
+                return !TypeScript.hasFlag(someFunctionDecl.kind === 65536 /* Method */ ? someFunctionDecl.getParentDecl().flags : someFunctionDecl.flags, 8 /* Ambient */) && functionDeclaration.block && TypeScript.lastParameterIsRest(functionDeclaration.callSignature.parameterList);
+            } else if (nodeType === 135 /* MemberFunctionDeclaration */) {
+                var memberFunction = enclosingAST;
+                return !TypeScript.hasFlag(someFunctionDecl.kind === 65536 /* Method */ ? someFunctionDecl.getParentDecl().flags : someFunctionDecl.flags, 8 /* Ambient */) && memberFunction.block && TypeScript.lastParameterIsRest(memberFunction.callSignature.parameterList);
+            } else if (nodeType === 137 /* ConstructorDeclaration */) {
+                var constructorDeclaration = enclosingAST;
+                return !TypeScript.hasFlag(someFunctionDecl.getParentDecl().flags, 8 /* Ambient */) && constructorDeclaration.block && TypeScript.lastParameterIsRest(constructorDeclaration.callSignature.parameterList);
+            } else if (nodeType === 218 /* ParenthesizedArrowFunctionExpression */) {
+                var arrowFunctionExpression = enclosingAST;
+                return TypeScript.lastParameterIsRest(arrowFunctionExpression.callSignature.parameterList);
+            } else if (nodeType === 222 /* FunctionExpression */) {
+                var functionExpression = enclosingAST;
+                return TypeScript.lastParameterIsRest(functionExpression.callSignature.parameterList);
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.checkArgumentsCollides = function (ast, context) {
+            if (ast.kind() === 242 /* Parameter */) {
+                var enclosingDecl = this.getEnclosingDeclForAST(ast);
+                if (TypeScript.hasFlag(enclosingDecl.kind, 1032192 /* SomeFunction */)) {
+                    if (this.hasRestParameterCodeGen(enclosingDecl)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters));
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.checkIndexOfRestArgumentInitializationCollides = function (ast, isDeclaration, context) {
+            if (!isDeclaration || ast.kind() === 242 /* Parameter */) {
+                var enclosingDecl = this.getEnclosingDeclForAST(ast);
+                var declPath = isDeclaration ? [enclosingDecl] : (enclosingDecl ? enclosingDecl.getParentPath() : []);
+                var resolvedSymbol = null;
+                var resolvedSymbolContainer;
+                for (var i = declPath.length - 1; i >= 0; i--) {
+                    var decl = declPath[i];
+                    if (!isDeclaration) {
+                        if (!resolvedSymbol) {
+                            resolvedSymbol = this.resolveNameExpression(ast, context);
+                            if (resolvedSymbol.isError()) {
+                                return;
+                            }
+
+                            resolvedSymbolContainer = resolvedSymbol.getContainer();
+                        }
+
+                        if (resolvedSymbolContainer && TypeScript.ArrayUtilities.contains(resolvedSymbolContainer.getDeclarations(), decl)) {
+                            break;
+                        }
+                    }
+
+                    if (TypeScript.hasFlag(decl.kind, 1032192 /* SomeFunction */)) {
+                        if (this.hasRestParameterCodeGen(decl)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, isDeclaration ? TypeScript.DiagnosticCode.Duplicate_identifier_i_Compiler_uses_i_to_initialize_rest_parameter : TypeScript.DiagnosticCode.Expression_resolves_to_variable_declaration_i_that_compiler_uses_to_initialize_rest_parameter));
+                        }
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.checkExternalModuleRequireExportsCollides = function (ast, name, context) {
+            var enclosingDecl = this.getEnclosingDeclForAST(ast);
+
+            var enclosingModule = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(name);
+            if (TypeScript.ASTHelpers.isAnyNameOfModule(enclosingModule, name)) {
+                enclosingDecl = this.getEnclosingDeclForAST(enclosingModule);
+            }
+
+            if (enclosingDecl && enclosingDecl.kind === 32 /* DynamicModule */) {
+                var decl = this.semanticInfoChain.getDeclForAST(ast);
+
+                if (!TypeScript.hasFlag(decl.flags, 8 /* Ambient */)) {
+                    var nameText = name.valueText();
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module, [nameText, nameText]));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveObjectTypeTypeReference = function (objectType, context) {
+            var interfaceDecl = this.semanticInfoChain.getDeclForAST(objectType);
+            TypeScript.Debug.assert(interfaceDecl);
+
+            var interfaceSymbol = interfaceDecl.getSymbol();
+            TypeScript.Debug.assert(interfaceSymbol);
+
+            if (objectType.typeMembers) {
+                var memberDecl = null;
+                var memberSymbol = null;
+                var memberType = null;
+                var typeMembers = objectType.typeMembers;
+
+                for (var i = 0; i < typeMembers.nonSeparatorCount(); i++) {
+                    memberDecl = this.semanticInfoChain.getDeclForAST(typeMembers.nonSeparatorAt(i));
+                    memberSymbol = (memberDecl.kind & 7340032 /* SomeSignature */) ? memberDecl.getSignatureSymbol() : memberDecl.getSymbol();
+
+                    this.resolveAST(typeMembers.nonSeparatorAt(i), false, context);
+
+                    memberType = memberSymbol.type;
+
+                    if ((memberType && memberType.isGeneric()) || (memberSymbol.isSignature() && memberSymbol.isGeneric())) {
+                        interfaceSymbol.setHasGenericMember();
+                    }
+                }
+            }
+
+            interfaceSymbol.setResolved();
+
+            if (this.canTypeCheckAST(objectType, context)) {
+                this.typeCheckObjectTypeTypeReference(objectType, context);
+            }
+
+            return interfaceSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckObjectTypeTypeReference = function (objectType, context) {
+            this.setTypeChecked(objectType, context);
+            var objectTypeDecl = this.semanticInfoChain.getDeclForAST(objectType);
+            var objectTypeSymbol = objectTypeDecl.getSymbol();
+
+            this.typeCheckMembersAgainstIndexer(objectTypeSymbol, objectTypeDecl, context);
+            this.checkTypeForDuplicateIndexSignatures(objectTypeSymbol);
+        };
+
+        PullTypeResolver.prototype.resolveTypeAnnotation = function (typeAnnotation, context) {
+            return this.resolveTypeReference(typeAnnotation.type, context);
+        };
+
+        PullTypeResolver.prototype.resolveTypeReference = function (typeRef, context) {
+            if (typeRef === null) {
+                return null;
+            }
+
+            TypeScript.Debug.assert(typeRef.kind() !== 244 /* TypeAnnotation */);
+
+            var aliasType = null;
+            var type = this.computeTypeReferenceSymbol(typeRef, context);
+
+            if (type.kind === 4 /* Container */) {
+                var container = type;
+                var instanceSymbol = container.getInstanceSymbol();
+
+                if (instanceSymbol && (instanceSymbol.anyDeclHasFlag(16384 /* ClassConstructorVariable */) || instanceSymbol.kind === 32768 /* ConstructorMethod */)) {
+                    type = instanceSymbol.type.getAssociatedContainerType();
+                }
+            }
+
+            if (type && type.isAlias()) {
+                aliasType = type;
+                type = aliasType.getExportAssignedTypeSymbol();
+            }
+
+            if (type && !type.isGeneric()) {
+                if (aliasType) {
+                    this.semanticInfoChain.setAliasSymbolForAST(typeRef, aliasType);
+                }
+            }
+
+            if (type && !type.isError()) {
+                if ((type.kind & 58728795 /* SomeType */) === 0) {
+                    if (type.kind & 164 /* SomeContainer */) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeRef, TypeScript.DiagnosticCode.Type_reference_cannot_refer_to_container_0, [aliasType ? aliasType.toString() : type.toString()]));
+                    } else {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeRef, TypeScript.DiagnosticCode.Type_reference_must_refer_to_type));
+                    }
+                }
+            }
+
+            if (this.canTypeCheckAST(typeRef, context)) {
+                this.setTypeChecked(typeRef, context);
+            }
+
+            return type;
+        };
+
+        PullTypeResolver.prototype.getArrayType = function (elementType) {
+            var arraySymbol = elementType.getArrayType();
+
+            if (!arraySymbol) {
+                arraySymbol = this.createInstantiatedType(this.cachedArrayInterfaceType(), [elementType]);
+
+                if (!arraySymbol) {
+                    arraySymbol = this.semanticInfoChain.anyTypeSymbol;
+                }
+
+                elementType.setArrayType(arraySymbol);
+            }
+
+            return arraySymbol;
+        };
+
+        PullTypeResolver.prototype.computeTypeReferenceSymbol = function (term, context) {
+            switch (term.kind()) {
+                case 60 /* AnyKeyword */:
+                    return this.semanticInfoChain.anyTypeSymbol;
+                case 61 /* BooleanKeyword */:
+                    return this.semanticInfoChain.booleanTypeSymbol;
+                case 67 /* NumberKeyword */:
+                    return this.semanticInfoChain.numberTypeSymbol;
+                case 69 /* StringKeyword */:
+                    return this.semanticInfoChain.stringTypeSymbol;
+                case 41 /* VoidKeyword */:
+                    return this.semanticInfoChain.voidTypeSymbol;
+            }
+
+            var typeDeclSymbol = null;
+
+            if (term.kind() === 11 /* IdentifierName */) {
+                typeDeclSymbol = this.resolveTypeNameExpression(term, context);
+            } else if (term.kind() === 123 /* FunctionType */) {
+                var functionType = term;
+                typeDeclSymbol = this.resolveAnyFunctionTypeSignature(functionType, functionType.typeParameterList, functionType.parameterList, functionType.type, context);
+            } else if (term.kind() === 125 /* ConstructorType */) {
+                var constructorType = term;
+                typeDeclSymbol = this.resolveAnyFunctionTypeSignature(constructorType, constructorType.typeParameterList, constructorType.parameterList, constructorType.type, context);
+            } else if (term.kind() === 122 /* ObjectType */) {
+                typeDeclSymbol = this.resolveObjectTypeTypeReference(term, context);
+            } else if (term.kind() === 126 /* GenericType */) {
+                typeDeclSymbol = this.resolveGenericTypeReference(term, context);
+            } else if (term.kind() === 121 /* QualifiedName */) {
+                typeDeclSymbol = this.resolveQualifiedName(term, context);
+            } else if (term.kind() === 14 /* StringLiteral */) {
+                var stringConstantAST = term;
+                var enclosingDecl = this.getEnclosingDeclForAST(term);
+                typeDeclSymbol = new TypeScript.PullStringConstantTypeSymbol(stringConstantAST.text());
+                var decl = new TypeScript.PullSynthesizedDecl(stringConstantAST.text(), stringConstantAST.text(), typeDeclSymbol.kind, null, enclosingDecl, enclosingDecl.semanticInfoChain);
+                typeDeclSymbol.addDeclaration(decl);
+            } else if (term.kind() === 127 /* TypeQuery */) {
+                var typeQuery = term;
+
+                var typeQueryTerm = typeQuery.name;
+
+                var valueSymbol = this.resolveAST(typeQueryTerm, false, context);
+
+                if (valueSymbol && valueSymbol.isAlias()) {
+                    if (valueSymbol.assignedValue()) {
+                        valueSymbol = valueSymbol.assignedValue();
+                    } else {
+                        var containerSymbol = valueSymbol.getExportAssignedContainerSymbol();
+                        valueSymbol = (containerSymbol && containerSymbol.isContainer() && !containerSymbol.isEnum()) ? containerSymbol.getInstanceSymbol() : null;
+                    }
+                }
+
+                if (valueSymbol) {
+                    typeDeclSymbol = valueSymbol.type.widenedType(this, typeQueryTerm, context);
+                } else {
+                    typeDeclSymbol = this.getNewErrorTypeSymbol();
+                }
+            } else if (term.kind() === 124 /* ArrayType */) {
+                var arrayType = term;
+                var underlying = this.resolveTypeReference(arrayType.type, context);
+                typeDeclSymbol = this.getArrayType(underlying);
+            } else {
+                throw TypeScript.Errors.invalidOperation("unknown type");
+            }
+
+            if (!typeDeclSymbol) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(term, TypeScript.DiagnosticCode.Unable_to_resolve_type));
+                return this.getNewErrorTypeSymbol();
+            }
+
+            if (typeDeclSymbol.isError()) {
+                return typeDeclSymbol;
+            }
+
+            if (this.genericTypeIsUsedWithoutRequiredTypeArguments(typeDeclSymbol, term, context)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(term, TypeScript.DiagnosticCode.Generic_type_references_must_include_all_type_arguments));
+                typeDeclSymbol = this.instantiateTypeToAny(typeDeclSymbol, context);
+            }
+
+            return typeDeclSymbol;
+        };
+
+        PullTypeResolver.prototype.genericTypeIsUsedWithoutRequiredTypeArguments = function (typeSymbol, term, context) {
+            if (!typeSymbol) {
+                return false;
+            }
+
+            if (typeSymbol.isAlias()) {
+                return this.genericTypeIsUsedWithoutRequiredTypeArguments(typeSymbol.getExportAssignedTypeSymbol(), term, context);
+            }
+
+            return typeSymbol.isNamedTypeSymbol() && typeSymbol.isGeneric() && !typeSymbol.isTypeParameter() && (typeSymbol.isResolved || typeSymbol.inResolution) && !typeSymbol.getIsSpecialized() && typeSymbol.getTypeParameters().length && typeSymbol.getTypeArguments() === null && this.isTypeRefWithoutTypeArgs(term);
+        };
+
+        PullTypeResolver.prototype.resolveMemberVariableDeclaration = function (varDecl, context) {
+            return this.resolveVariableDeclaratorOrParameterOrEnumElement(varDecl, varDecl.modifiers, varDecl.variableDeclarator.propertyName, TypeScript.ASTHelpers.getType(varDecl.variableDeclarator), varDecl.variableDeclarator.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.resolvePropertySignature = function (varDecl, context) {
+            return this.resolveVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.sentinelEmptyArray, varDecl.propertyName, TypeScript.ASTHelpers.getType(varDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.resolveVariableDeclarator = function (varDecl, context) {
+            return this.resolveVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.ASTHelpers.getVariableDeclaratorModifiers(varDecl), varDecl.propertyName, TypeScript.ASTHelpers.getType(varDecl), varDecl.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.resolveParameterList = function (list, context) {
+            return this.resolveSeparatedList(list.parameters, context);
+        };
+
+        PullTypeResolver.prototype.resolveParameter = function (parameter, context) {
+            return this.resolveVariableDeclaratorOrParameterOrEnumElement(parameter, parameter.modifiers, parameter.identifier, TypeScript.ASTHelpers.getType(parameter), parameter.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.getEnumTypeSymbol = function (enumElement, context) {
+            var enumDeclaration = enumElement.parent.parent;
+            var decl = this.semanticInfoChain.getDeclForAST(enumDeclaration);
+            var symbol = decl.getSymbol();
+            this.resolveDeclaredSymbol(symbol, context);
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.resolveEnumElement = function (enumElement, context) {
+            return this.resolveVariableDeclaratorOrParameterOrEnumElement(enumElement, TypeScript.sentinelEmptyArray, enumElement.propertyName, null, enumElement.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckEnumElement = function (enumElement, context) {
+            this.typeCheckVariableDeclaratorOrParameterOrEnumElement(enumElement, TypeScript.sentinelEmptyArray, enumElement.propertyName, null, enumElement.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.resolveEqualsValueClause = function (clause, isContextuallyTyped, context) {
+            if (this.canTypeCheckAST(clause, context)) {
+                this.setTypeChecked(clause, context);
+            }
+
+            return this.resolveAST(clause.value, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.resolveVariableDeclaratorOrParameterOrEnumElement = function (varDeclOrParameter, modifiers, name, typeExpr, init, context) {
+            var hasTypeExpr = typeExpr !== null || varDeclOrParameter.kind() === 243 /* EnumElement */;
+            var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter);
+            var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter);
+
+            if (enclosingDecl && decl.kind === 2048 /* Parameter */) {
+                enclosingDecl.ensureSymbolIsBound();
+            }
+
+            var declSymbol = decl.getSymbol();
+            var declParameterSymbol = decl.getValueDecl() ? decl.getValueDecl().getSymbol() : null;
+
+            if (declSymbol.isResolved) {
+                var declType = declSymbol.type;
+                var valDecl = decl.getValueDecl();
+
+                if (valDecl) {
+                    var valSymbol = valDecl.getSymbol();
+
+                    if (valSymbol && !valSymbol.isResolved) {
+                        valSymbol.type = declType;
+                        valSymbol.setResolved();
+                    }
+                }
+            } else {
+                if (declSymbol.inResolution) {
+                    declSymbol.type = this.semanticInfoChain.anyTypeSymbol;
+                    declSymbol.setResolved();
+                    return declSymbol;
+                }
+
+                if (!declSymbol.type || !declSymbol.type.isError()) {
+                    declSymbol.startResolving();
+
+                    var typeExprSymbol = this.resolveAndTypeCheckVariableDeclarationTypeExpr(varDeclOrParameter, name, typeExpr, context);
+
+                    if (!hasTypeExpr) {
+                        this.resolveAndTypeCheckVariableDeclaratorOrParameterInitExpr(varDeclOrParameter, name, typeExpr, init, context, typeExprSymbol);
+                    }
+
+                    if (!(hasTypeExpr || init)) {
+                        var defaultType = this.semanticInfoChain.anyTypeSymbol;
+
+                        if (declSymbol.isVarArg && this.cachedArrayInterfaceType()) {
+                            defaultType = this.createInstantiatedType(this.cachedArrayInterfaceType(), [defaultType]);
+                        }
+
+                        context.setTypeInContext(declSymbol, defaultType);
+
+                        if (declParameterSymbol) {
+                            declParameterSymbol.type = defaultType;
+                        }
+                    }
+                    declSymbol.setResolved();
+
+                    if (declParameterSymbol) {
+                        declParameterSymbol.setResolved();
+                    }
+                }
+            }
+
+            if (this.canTypeCheckAST(varDeclOrParameter, context)) {
+                this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDeclOrParameter, modifiers, name, typeExpr, init, context);
+            }
+
+            return declSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveAndTypeCheckVariableDeclarationTypeExpr = function (varDeclOrParameter, name, typeExpr, context) {
+            var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter);
+            var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter);
+            var declSymbol = decl.getSymbol();
+            var declParameterSymbol = decl.getValueDecl() ? decl.getValueDecl().getSymbol() : null;
+
+            if (varDeclOrParameter.kind() === 243 /* EnumElement */) {
+                var result = this.getEnumTypeSymbol(varDeclOrParameter, context);
+                declSymbol.type = result;
+                return result;
+            }
+
+            if (!typeExpr) {
+                return null;
+            }
+
+            var wrapperDecl = this.getEnclosingDecl(decl);
+            wrapperDecl = wrapperDecl || enclosingDecl;
+
+            var typeExprSymbol = this.resolveTypeReference(typeExpr, context);
+
+            if (!typeExprSymbol) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Unable_to_resolve_type_of_0, [name.text()]));
+                declSymbol.type = this.getNewErrorTypeSymbol();
+
+                if (declParameterSymbol) {
+                    context.setTypeInContext(declParameterSymbol, this.semanticInfoChain.anyTypeSymbol);
+                }
+            } else if (typeExprSymbol.isError()) {
+                context.setTypeInContext(declSymbol, typeExprSymbol);
+                if (declParameterSymbol) {
+                    context.setTypeInContext(declParameterSymbol, typeExprSymbol);
+                }
+            } else {
+                if (typeExprSymbol === this.semanticInfoChain.anyTypeSymbol) {
+                    decl.setFlag(16777216 /* IsAnnotatedWithAny */);
+                }
+
+                if (typeExprSymbol.isContainer()) {
+                    var exportedTypeSymbol = typeExprSymbol.getExportAssignedTypeSymbol();
+
+                    if (exportedTypeSymbol) {
+                        typeExprSymbol = exportedTypeSymbol;
+                    } else {
+                        typeExprSymbol = typeExprSymbol.type;
+
+                        if (typeExprSymbol.isAlias()) {
+                            typeExprSymbol = typeExprSymbol.getExportAssignedTypeSymbol();
+                        }
+
+                        if (typeExprSymbol && typeExprSymbol.isContainer() && !typeExprSymbol.isEnum()) {
+                            var instanceSymbol = typeExprSymbol.getInstanceSymbol();
+
+                            if (!instanceSymbol || !TypeScript.PullHelpers.symbolIsEnum(instanceSymbol)) {
+                                typeExprSymbol = this.getNewErrorTypeSymbol();
+                            } else {
+                                typeExprSymbol = instanceSymbol.type;
+                            }
+                        }
+                    }
+                } else if (declSymbol.isVarArg && !(typeExprSymbol.isArrayNamedTypeReference() || typeExprSymbol === this.cachedArrayInterfaceType())) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Rest_parameters_must_be_array_types));
+                    typeExprSymbol = this.getNewErrorTypeSymbol();
+                }
+
+                context.setTypeInContext(declSymbol, typeExprSymbol);
+
+                if (declParameterSymbol) {
+                    declParameterSymbol.type = typeExprSymbol;
+                }
+
+                if (typeExprSymbol.kind === 16777216 /* FunctionType */ && !typeExprSymbol.getFunctionSymbol()) {
+                    typeExprSymbol.setFunctionSymbol(declSymbol);
+                }
+            }
+
+            return typeExprSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveAndTypeCheckVariableDeclaratorOrParameterInitExpr = function (varDeclOrParameter, name, typeExpr, init, context, typeExprSymbol) {
+            if (!init) {
+                return null;
+            }
+
+            var hasTypeExpr = typeExpr !== null || varDeclOrParameter.kind() === 243 /* EnumElement */;
+            if (typeExprSymbol) {
+                context.pushNewContextualType(typeExprSymbol);
+            }
+
+            var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter);
+            var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter);
+            var declSymbol = decl.getSymbol();
+            var declParameterSymbol = decl.getValueDecl() ? decl.getValueDecl().getSymbol() : null;
+
+            var wrapperDecl = this.getEnclosingDecl(decl);
+            wrapperDecl = wrapperDecl || enclosingDecl;
+
+            var initExprSymbol = this.resolveAST(init, typeExprSymbol !== null, context);
+
+            if (typeExprSymbol) {
+                context.popAnyContextualType();
+            }
+
+            if (!initExprSymbol) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Unable_to_resolve_type_of_0, [name.text()]));
+
+                if (!hasTypeExpr) {
+                    context.setTypeInContext(declSymbol, this.getNewErrorTypeSymbol());
+
+                    if (declParameterSymbol) {
+                        context.setTypeInContext(declParameterSymbol, this.semanticInfoChain.anyTypeSymbol);
+                    }
+                }
+            } else {
+                var initTypeSymbol = initExprSymbol.type;
+
+                if (!hasTypeExpr) {
+                    var widenedInitTypeSymbol = initTypeSymbol.widenedType(this, init.value, context);
+                    context.setTypeInContext(declSymbol, widenedInitTypeSymbol);
+
+                    if (declParameterSymbol) {
+                        context.setTypeInContext(declParameterSymbol, widenedInitTypeSymbol);
+                    }
+
+                    if (this.compilationSettings.noImplicitAny()) {
+                        if ((widenedInitTypeSymbol !== initTypeSymbol) && (widenedInitTypeSymbol === this.semanticInfoChain.anyTypeSymbol)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Variable_0_implicitly_has_an_any_type, [name.text()]));
+                        }
+                    }
+
+                    return widenedInitTypeSymbol;
+                }
+            }
+
+            return initTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckPropertySignature = function (varDecl, context) {
+            this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.sentinelEmptyArray, varDecl.propertyName, TypeScript.ASTHelpers.getType(varDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckMemberVariableDeclaration = function (varDecl, context) {
+            this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDecl, varDecl.modifiers, varDecl.variableDeclarator.propertyName, TypeScript.ASTHelpers.getType(varDecl), varDecl.variableDeclarator.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckVariableDeclarator = function (varDecl, context) {
+            this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.ASTHelpers.getVariableDeclaratorModifiers(varDecl), varDecl.propertyName, TypeScript.ASTHelpers.getType(varDecl), varDecl.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckParameter = function (parameter, context) {
+            this.typeCheckVariableDeclaratorOrParameterOrEnumElement(parameter, parameter.modifiers, parameter.identifier, TypeScript.ASTHelpers.getType(parameter), parameter.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckVariableDeclaratorOrParameterOrEnumElement = function (varDeclOrParameter, modifiers, name, typeExpr, init, context) {
+            var _this = this;
+            this.setTypeChecked(varDeclOrParameter, context);
+
+            var hasTypeExpr = typeExpr !== null || varDeclOrParameter.kind() === 243 /* EnumElement */;
+            var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter);
+            var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter);
+            var declSymbol = decl.getSymbol();
+
+            var typeExprSymbol = this.resolveAndTypeCheckVariableDeclarationTypeExpr(varDeclOrParameter, name, typeExpr, context);
+
+            var initTypeSymbol = this.resolveAndTypeCheckVariableDeclaratorOrParameterInitExpr(varDeclOrParameter, name, typeExpr, init, context, typeExprSymbol);
+
+            if (hasTypeExpr || init) {
+                if (typeExprSymbol && typeExprSymbol.isAlias()) {
+                    typeExprSymbol = typeExprSymbol.getExportAssignedTypeSymbol();
+                }
+
+                if (typeExprSymbol && typeExprSymbol.kind === 32 /* DynamicModule */) {
+                    var exportedTypeSymbol = typeExprSymbol.getExportAssignedTypeSymbol();
+
+                    if (exportedTypeSymbol) {
+                        typeExprSymbol = exportedTypeSymbol;
+                    } else {
+                        var instanceTypeSymbol = typeExprSymbol.getInstanceType();
+
+                        if (!instanceTypeSymbol) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Tried_to_set_variable_type_to_uninitialized_module_type_0, [typeExprSymbol.toString()]));
+                            typeExprSymbol = null;
+                        } else {
+                            typeExprSymbol = instanceTypeSymbol;
+                        }
+                    }
+                }
+
+                initTypeSymbol = this.getInstanceTypeForAssignment(varDeclOrParameter, initTypeSymbol, context);
+
+                if (initTypeSymbol && typeExprSymbol) {
+                    var comparisonInfo = new TypeComparisonInfo();
+
+                    var isAssignable = this.sourceIsAssignableToTarget(initTypeSymbol, typeExprSymbol, varDeclOrParameter, context, comparisonInfo);
+
+                    if (!isAssignable) {
+                        var enclosingSymbol = this.getEnclosingSymbolForAST(varDeclOrParameter);
+                        if (comparisonInfo.message) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [initTypeSymbol.toString(enclosingSymbol), typeExprSymbol.toString(enclosingSymbol), comparisonInfo.message]));
+                        } else {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [initTypeSymbol.toString(enclosingSymbol), typeExprSymbol.toString(enclosingSymbol)]));
+                        }
+                    }
+                }
+            } else if (varDeclOrParameter.kind() !== 243 /* EnumElement */ && this.compilationSettings.noImplicitAny() && !this.isForInVariableDeclarator(varDeclOrParameter)) {
+                var wrapperDecl = this.getEnclosingDecl(decl);
+                wrapperDecl = wrapperDecl || enclosingDecl;
+
+                var needReportError = function (containerDecl, selfDecl) {
+                    if (!TypeScript.hasFlag(containerDecl.flags, 8 /* Ambient */)) {
+                        return true;
+                    }
+
+                    return selfDecl && !TypeScript.hasFlag(selfDecl.flags, 2 /* Private */);
+                };
+
+                if ((wrapperDecl.kind === 16384 /* Function */ || wrapperDecl.kind === 32768 /* ConstructorMethod */ || wrapperDecl.kind === 2097152 /* ConstructSignature */)) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Parameter_0_of_1_implicitly_has_an_any_type, [name.text(), enclosingDecl.name]));
+                } else if (wrapperDecl.kind === 65536 /* Method */) {
+                    var parentDecl = wrapperDecl.getParentDecl();
+
+                    if (needReportError(parentDecl, wrapperDecl)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Parameter_0_of_1_implicitly_has_an_any_type, [name.text(), enclosingDecl.name]));
+                    }
+                } else if (decl.kind === 4096 /* Property */ && !declSymbol.getContainer().isNamedTypeSymbol()) {
+                    if (needReportError(wrapperDecl, decl)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Member_0_of_object_type_implicitly_has_an_any_type, [name.text()]));
+                    }
+                } else if (wrapperDecl.kind !== 268435456 /* CatchBlock */) {
+                    if (needReportError(wrapperDecl) || !TypeScript.hasModifier(modifiers, 2 /* Private */)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Variable_0_implicitly_has_an_any_type, [name.text()]));
+                    }
+                }
+            }
+
+            if (init && varDeclOrParameter.kind() === 242 /* Parameter */) {
+                var containerSignature = enclosingDecl.getSignatureSymbol();
+                if (containerSignature && !containerSignature.isDefinition()) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Default_arguments_are_only_allowed_in_implementation));
+                }
+            }
+            if (declSymbol.kind !== 2048 /* Parameter */ && (declSymbol.kind !== 4096 /* Property */ || declSymbol.getContainer().isNamedTypeSymbol())) {
+                this.checkSymbolPrivacy(declSymbol, declSymbol.type, function (symbol) {
+                    return _this.variablePrivacyErrorReporter(varDeclOrParameter, declSymbol, symbol, context);
+                });
+            }
+
+            if ((declSymbol.kind !== 4096 /* Property */ && declSymbol.kind !== 67108864 /* EnumMember */) || declSymbol.anyDeclHasFlag(8388608 /* PropertyParameter */)) {
+                this.checkNameForCompilerGeneratedDeclarationCollision(varDeclOrParameter, true, name, context);
+            }
+        };
+
+        PullTypeResolver.prototype.isForInVariableDeclarator = function (ast) {
+            return ast.kind() === 225 /* VariableDeclarator */ && ast.parent && ast.parent.parent && ast.parent.parent.parent && ast.parent.kind() === 2 /* SeparatedList */ && ast.parent.parent.kind() === 224 /* VariableDeclaration */ && ast.parent.parent.parent.kind() === 155 /* ForInStatement */ && ast.parent.parent.parent.variableDeclaration === ast.parent.parent;
+        };
+
+        PullTypeResolver.prototype.checkSuperCaptureVariableCollides = function (superAST, isDeclaration, context) {
+            var enclosingDecl = this.getEnclosingDeclForAST(superAST);
+
+            var classSymbol = this.getContextualClassSymbolForEnclosingDecl(superAST, enclosingDecl);
+
+            if (classSymbol && !classSymbol.anyDeclHasFlag(8 /* Ambient */)) {
+                if (superAST.kind() === 242 /* Parameter */) {
+                    var enclosingAST = this.getASTForDecl(enclosingDecl);
+                    if (enclosingAST.kind() !== 218 /* ParenthesizedArrowFunctionExpression */ && enclosingAST.kind() !== 219 /* SimpleArrowFunctionExpression */) {
+                        var block = enclosingDecl.kind === 65536 /* Method */ ? enclosingAST.block : enclosingAST.block;
+                        if (!block) {
+                            return;
+                        }
+                    }
+                }
+
+                this.resolveDeclaredSymbol(classSymbol, context);
+
+                var parents = classSymbol.getExtendedTypes();
+                if (parents.length) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(superAST, isDeclaration ? TypeScript.DiagnosticCode.Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference : TypeScript.DiagnosticCode.Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.checkThisCaptureVariableCollides = function (_thisAST, isDeclaration, context) {
+            if (isDeclaration) {
+                var decl = this.semanticInfoChain.getDeclForAST(_thisAST);
+                if (TypeScript.hasFlag(decl.flags, 8 /* Ambient */)) {
+                    return;
+                }
+            }
+
+            var enclosingDecl = this.getEnclosingDeclForAST(_thisAST);
+
+            var enclosingModule = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(_thisAST);
+            if (TypeScript.ASTHelpers.isAnyNameOfModule(enclosingModule, _thisAST)) {
+                enclosingDecl = this.getEnclosingDeclForAST(enclosingModule);
+            }
+
+            var declPath = enclosingDecl.getParentPath();
+
+            for (var i = declPath.length - 1; i >= 0; i--) {
+                var decl = declPath[i];
+                var declKind = decl.kind;
+                if (declKind === 131072 /* FunctionExpression */ && TypeScript.hasFlag(decl.flags, 8192 /* ArrowFunction */)) {
+                    continue;
+                }
+
+                if (declKind === 16384 /* Function */ || declKind === 65536 /* Method */ || declKind === 32768 /* ConstructorMethod */ || declKind === 262144 /* GetAccessor */ || declKind === 524288 /* SetAccessor */ || declKind === 131072 /* FunctionExpression */ || declKind === 8 /* Class */ || declKind === 4 /* Container */ || declKind === 32 /* DynamicModule */ || declKind === 1 /* Script */) {
+                    if (TypeScript.hasFlag(decl.flags, 262144 /* MustCaptureThis */)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(_thisAST, isDeclaration ? TypeScript.DiagnosticCode.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference : TypeScript.DiagnosticCode.Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference));
+                    }
+                    break;
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.postTypeCheckVariableDeclaratorOrParameter = function (varDeclOrParameter, context) {
+            this.checkThisCaptureVariableCollides(varDeclOrParameter, true, context);
+        };
+
+        PullTypeResolver.prototype.resolveTypeParameterDeclaration = function (typeParameterAST, context) {
+            var typeParameterDecl = this.semanticInfoChain.getDeclForAST(typeParameterAST);
+            var typeParameterSymbol = typeParameterDecl.getSymbol();
+
+            this.resolveFirstTypeParameterDeclaration(typeParameterSymbol, context);
+
+            if (typeParameterSymbol.isResolved && this.canTypeCheckAST(typeParameterAST, context)) {
+                this.typeCheckTypeParameterDeclaration(typeParameterAST, context);
+            }
+
+            return typeParameterSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveFirstTypeParameterDeclaration = function (typeParameterSymbol, context) {
+            var typeParameterDecl = typeParameterSymbol.getDeclarations()[0];
+            var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameterDecl);
+
+            if (typeParameterSymbol.isResolved || typeParameterSymbol.inResolution) {
+                return;
+            }
+
+            typeParameterSymbol.startResolving();
+
+            if (typeParameterAST.constraint) {
+                var constraintTypeSymbol = this.resolveTypeReference(typeParameterAST.constraint.type, context);
+
+                if (constraintTypeSymbol) {
+                    typeParameterSymbol.setConstraint(constraintTypeSymbol);
+                }
+            }
+
+            typeParameterSymbol.setResolved();
+        };
+
+        PullTypeResolver.prototype.typeCheckTypeParameterDeclaration = function (typeParameterAST, context) {
+            this.setTypeChecked(typeParameterAST, context);
+
+            var constraint = this.resolveAST(typeParameterAST.constraint, false, context);
+
+            if (constraint) {
+                var typeParametersAST = typeParameterAST.parent;
+                var typeParameters = [];
+                for (var i = 0; i < typeParametersAST.nonSeparatorCount(); i++) {
+                    var currentTypeParameterAST = typeParametersAST.nonSeparatorAt(i);
+                    var currentTypeParameterDecl = this.semanticInfoChain.getDeclForAST(currentTypeParameterAST);
+                    var currentTypeParameter = this.semanticInfoChain.getSymbolForDecl(currentTypeParameterDecl);
+                    typeParameters[currentTypeParameter.pullSymbolID] = currentTypeParameter;
+                }
+
+                if (constraint.wrapsSomeTypeParameter(typeParameters)) {
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Constraint_of_a_type_parameter_cannot_reference_any_type_parameter_from_the_same_type_parameter_list);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveConstraint = function (constraint, context) {
+            if (this.canTypeCheckAST(constraint, context)) {
+                this.setTypeChecked(constraint, context);
+            }
+
+            return this.resolveTypeReference(constraint.type, context);
+        };
+
+        PullTypeResolver.prototype.resolveFunctionBodyReturnTypes = function (funcDeclAST, block, bodyExpression, signature, useContextualType, enclosingDecl, context) {
+            var _this = this;
+            var returnStatementsExpressions = [];
+
+            var enclosingDeclStack = [enclosingDecl];
+
+            var preFindReturnExpressionTypes = function (ast, walker) {
+                var go = true;
+
+                switch (ast.kind()) {
+                    case 129 /* FunctionDeclaration */:
+                    case 219 /* SimpleArrowFunctionExpression */:
+                    case 218 /* ParenthesizedArrowFunctionExpression */:
+                    case 222 /* FunctionExpression */:
+                    case 215 /* ObjectLiteralExpression */:
+                        go = false;
+                        break;
+
+                    case 150 /* ReturnStatement */:
+                        var returnStatement = ast;
+                        enclosingDecl.setFlag(4194304 /* HasReturnStatement */);
+                        returnStatementsExpressions.push({ expression: returnStatement.expression, enclosingDecl: enclosingDeclStack[enclosingDeclStack.length - 1] });
+                        go = false;
+                        break;
+
+                    case 236 /* CatchClause */:
+                    case 163 /* WithStatement */:
+                        enclosingDeclStack[enclosingDeclStack.length] = _this.semanticInfoChain.getDeclForAST(ast);
+                        break;
+
+                    default:
+                        break;
+                }
+
+                walker.options.goChildren = go;
+
+                return ast;
+            };
+
+            var postFindReturnExpressionEnclosingDecls = function (ast, walker) {
+                switch (ast.kind()) {
+                    case 236 /* CatchClause */:
+                    case 163 /* WithStatement */:
+                        enclosingDeclStack.length--;
+                        break;
+                    default:
+                        break;
+                }
+
+                walker.options.goChildren = true;
+
+                return ast;
+            };
+
+            if (block) {
+                TypeScript.getAstWalkerFactory().walk(block, preFindReturnExpressionTypes, postFindReturnExpressionEnclosingDecls);
+            } else {
+                returnStatementsExpressions.push({ expression: bodyExpression, enclosingDecl: enclosingDecl });
+                enclosingDecl.setFlag(4194304 /* HasReturnStatement */);
+            }
+
+            if (!returnStatementsExpressions.length) {
+                signature.returnType = this.semanticInfoChain.voidTypeSymbol;
+            } else {
+                var returnExpressionSymbols = [];
+                var returnExpressions = [];
+
+                for (var i = 0; i < returnStatementsExpressions.length; i++) {
+                    var returnExpression = returnStatementsExpressions[i].expression;
+                    if (returnExpression) {
+                        var returnType = this.resolveAST(returnExpression, useContextualType, context).type;
+
+                        if (returnType.isError()) {
+                            signature.returnType = returnType;
+                            return;
+                        } else {
+                            if (returnExpression.parent.kind() === 150 /* ReturnStatement */) {
+                                this.setSymbolForAST(returnExpression.parent, returnType, context);
+                            }
+                        }
+
+                        returnExpressionSymbols.push(returnType);
+                        returnExpressions.push(returnExpression);
+                    }
+                }
+
+                if (!returnExpressionSymbols.length) {
+                    signature.returnType = this.semanticInfoChain.voidTypeSymbol;
+                } else {
+                    var collection = {
+                        getLength: function () {
+                            return returnExpressionSymbols.length;
+                        },
+                        getTypeAtIndex: function (index) {
+                            return returnExpressionSymbols[index].type;
+                        }
+                    };
+
+                    var bestCommonReturnType = this.findBestCommonType(collection, context, new TypeComparisonInfo());
+                    var returnType = bestCommonReturnType;
+                    var returnExpression = returnExpressions[returnExpressionSymbols.indexOf(returnType)];
+
+                    var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+                    var functionSymbol = functionDecl.getSymbol();
+
+                    if (returnType) {
+                        var previousReturnType = returnType;
+                        var newReturnType = returnType.widenedType(this, returnExpression, context);
+                        signature.returnType = newReturnType;
+
+                        if (!TypeScript.ArrayUtilities.contains(returnExpressionSymbols, bestCommonReturnType)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Could_not_find_the_best_common_type_of_types_of_all_return_statement_expressions));
+                        }
+
+                        if (this.compilationSettings.noImplicitAny()) {
+                            if (previousReturnType !== newReturnType && newReturnType === this.semanticInfoChain.anyTypeSymbol) {
+                                var functionName = enclosingDecl.name;
+                                if (functionName === "") {
+                                    functionName = enclosingDecl.getFunctionExpressionName();
+                                }
+
+                                if (functionName != "") {
+                                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type, [functionName]));
+                                } else {
+                                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_any_return_type));
+                                }
+                            }
+                        }
+                    }
+
+                    if (!functionSymbol.type && functionSymbol.isAccessor()) {
+                        functionSymbol.type = signature.returnType;
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckConstructorDeclaration = function (funcDeclAST, context) {
+            var _this = this;
+            this.setTypeChecked(funcDeclAST, context);
+
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            for (var i = 0; i < funcDeclAST.callSignature.parameterList.parameters.nonSeparatorCount(); i++) {
+                this.resolveAST(funcDeclAST.callSignature.parameterList.parameters.nonSeparatorAt(i), false, context);
+            }
+
+            this.resolveAST(funcDeclAST.block, false, context);
+
+            if (funcDecl.getSignatureSymbol() && funcDecl.getSignatureSymbol().isDefinition() && this.enclosingClassIsDerived(funcDecl.getParentDecl())) {
+                if (!this.constructorHasSuperCall(funcDeclAST)) {
+                    context.postDiagnostic(new TypeScript.Diagnostic(funcDeclAST.fileName(), this.semanticInfoChain.lineMap(funcDeclAST.fileName()), funcDeclAST.start(), "constructor".length, TypeScript.DiagnosticCode.Constructors_for_derived_classes_must_contain_a_super_call));
+                } else if (this.superCallMustBeFirstStatementInConstructor(funcDecl)) {
+                    var firstStatement = this.getFirstStatementOfBlockOrNull(funcDeclAST.block);
+                    if (!firstStatement || !this.isSuperInvocationExpressionStatement(firstStatement)) {
+                        context.postDiagnostic(new TypeScript.Diagnostic(funcDeclAST.fileName(), this.semanticInfoChain.lineMap(funcDeclAST.fileName()), funcDeclAST.start(), "constructor".length, TypeScript.DiagnosticCode.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties));
+                    }
+                }
+            }
+
+            this.validateVariableDeclarationGroups(funcDecl, context);
+
+            this.checkFunctionTypePrivacy(funcDeclAST, false, null, TypeScript.ASTHelpers.parametersFromParameterList(funcDeclAST.callSignature.parameterList), null, funcDeclAST.block, context);
+
+            this.typeCheckCallBacks.push(function (context) {
+                _this.typeCheckFunctionOverloads(funcDeclAST, context);
+            });
+        };
+
+        PullTypeResolver.prototype.constructorHasSuperCall = function (constructorDecl) {
+            var _this = this;
+            if (constructorDecl.block) {
+                var foundSuperCall = false;
+                var pre = function (ast, walker) {
+                    switch (ast.kind()) {
+                        case 129 /* FunctionDeclaration */:
+                        case 219 /* SimpleArrowFunctionExpression */:
+                        case 218 /* ParenthesizedArrowFunctionExpression */:
+                        case 222 /* FunctionExpression */:
+                        case 215 /* ObjectLiteralExpression */:
+                            walker.options.goChildren = false;
+                        default:
+                            if (_this.isSuperInvocationExpression(ast)) {
+                                foundSuperCall = true;
+                                walker.options.stopWalking = true;
+                            }
+                    }
+                };
+
+                TypeScript.getAstWalkerFactory().walk(constructorDecl.block, pre);
+                return foundSuperCall;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.typeCheckFunctionExpression = function (funcDecl, isContextuallyTyped, context) {
+            this.typeCheckAnyFunctionExpression(funcDecl, funcDecl.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList), funcDecl.callSignature.typeAnnotation, funcDecl.block, null, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckCallSignature = function (funcDecl, context) {
+            this.typeCheckAnyFunctionDeclaration(funcDecl, false, null, funcDecl.typeParameterList, funcDecl.parameterList, TypeScript.ASTHelpers.getType(funcDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckConstructSignature = function (funcDecl, context) {
+            this.typeCheckAnyFunctionDeclaration(funcDecl, false, null, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckMethodSignature = function (funcDecl, context) {
+            this.typeCheckAnyFunctionDeclaration(funcDecl, false, funcDecl.propertyName, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckMemberFunctionDeclaration = function (funcDecl, context) {
+            this.typeCheckAnyFunctionDeclaration(funcDecl, TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */), funcDecl.propertyName, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), funcDecl.block, context);
+        };
+
+        PullTypeResolver.prototype.containsSingleThrowStatement = function (block) {
+            return block !== null && block.statements.childCount() === 1 && block.statements.childAt(0).kind() === 157 /* ThrowStatement */;
+        };
+
+        PullTypeResolver.prototype.typeCheckAnyFunctionDeclaration = function (funcDeclAST, isStatic, name, typeParameters, parameters, returnTypeAnnotation, block, context) {
+            var _this = this;
+            this.setTypeChecked(funcDeclAST, context);
+
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            if (typeParameters) {
+                for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) {
+                    this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context);
+                }
+            }
+
+            this.resolveAST(parameters, false, context);
+
+            this.resolveAST(block, false, context);
+            var enclosingDecl = this.getEnclosingDecl(funcDecl);
+
+            this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, returnTypeAnnotation, context);
+            this.validateVariableDeclarationGroups(funcDecl, context);
+
+            this.checkFunctionTypePrivacy(funcDeclAST, isStatic, typeParameters, TypeScript.ASTHelpers.parametersFromParameterList(parameters), returnTypeAnnotation, block, context);
+
+            this.checkThatNonVoidFunctionHasReturnExpressionOrThrowStatement(funcDecl, returnTypeAnnotation, funcDecl.getSignatureSymbol().returnType, block, context);
+
+            if (funcDecl.kind === 16384 /* Function */) {
+                this.checkNameForCompilerGeneratedDeclarationCollision(funcDeclAST, true, name, context);
+            }
+
+            this.typeCheckCallBacks.push(function (context) {
+                _this.typeCheckFunctionOverloads(funcDeclAST, context);
+            });
+        };
+
+        PullTypeResolver.prototype.checkThatNonVoidFunctionHasReturnExpressionOrThrowStatement = function (functionDecl, returnTypeAnnotation, returnTypeSymbol, block, context) {
+            var hasReturn = TypeScript.hasFlag(functionDecl.flags, 4194304 /* HasReturnStatement */);
+
+            if (block !== null && returnTypeAnnotation !== null && !hasReturn) {
+                var isVoidOrAny = this.isAnyOrEquivalent(returnTypeSymbol) || returnTypeSymbol === this.semanticInfoChain.voidTypeSymbol;
+
+                if (!isVoidOrAny && !this.containsSingleThrowStatement(block)) {
+                    var funcName = functionDecl.getDisplayName() || TypeScript.getLocalizedText(TypeScript.DiagnosticCode.expression, null);
+
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, TypeScript.DiagnosticCode.Function_declared_a_non_void_return_type_but_has_no_return_expression));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckIndexSignature = function (funcDeclAST, context) {
+            var _this = this;
+            this.setTypeChecked(funcDeclAST, context);
+
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            this.resolveAST(funcDeclAST.parameter, false, context);
+
+            var enclosingDecl = this.getEnclosingDecl(funcDecl);
+
+            this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, TypeScript.ASTHelpers.getType(funcDeclAST), context);
+            this.validateVariableDeclarationGroups(funcDecl, context);
+
+            this.checkFunctionTypePrivacy(funcDeclAST, false, null, TypeScript.ASTHelpers.parametersFromParameter(funcDeclAST.parameter), TypeScript.ASTHelpers.getType(funcDeclAST), null, context);
+
+            var signature = funcDecl.getSignatureSymbol();
+
+            this.typeCheckCallBacks.push(function (context) {
+                var parentSymbol = funcDecl.getSignatureSymbol().getContainer();
+                var allIndexSignatures = _this.getBothKindsOfIndexSignaturesExcludingAugmentedType(parentSymbol, context);
+                var stringIndexSignature = allIndexSignatures.stringSignature;
+                var numberIndexSignature = allIndexSignatures.numericSignature;
+                var isNumericIndexer = numberIndexSignature === signature;
+
+                if (numberIndexSignature && stringIndexSignature && (isNumericIndexer || stringIndexSignature.getDeclarations()[0].getParentDecl() !== numberIndexSignature.getDeclarations()[0].getParentDecl())) {
+                    var comparisonInfo = new TypeComparisonInfo();
+
+                    if (!_this.sourceIsAssignableToTarget(numberIndexSignature.returnType, stringIndexSignature.returnType, funcDeclAST, context, comparisonInfo)) {
+                        var enclosingSymbol = _this.getEnclosingSymbolForAST(funcDeclAST);
+                        if (comparisonInfo.message) {
+                            context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Numeric_indexer_type_0_must_be_assignable_to_string_indexer_type_1_NL_2, [numberIndexSignature.returnType.toString(enclosingSymbol), stringIndexSignature.returnType.toString(enclosingSymbol), comparisonInfo.message]));
+                        } else {
+                            context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Numeric_indexer_type_0_must_be_assignable_to_string_indexer_type_1, [numberIndexSignature.returnType.toString(enclosingSymbol), stringIndexSignature.returnType.toString(enclosingSymbol)]));
+                        }
+                    }
+                }
+
+                var allMembers = parentSymbol.type.getAllMembers(536869887 /* All */, 0 /* all */);
+                for (var i = 0; i < allMembers.length; i++) {
+                    var member = allMembers[i];
+                    var name = member.name;
+                    if (name || (member.kind === 4096 /* Property */ && name === "")) {
+                        if (!allMembers[i].isResolved) {
+                            _this.resolveDeclaredSymbol(allMembers[i], context);
+                        }
+
+                        if (parentSymbol !== allMembers[i].getContainer()) {
+                            var isMemberNumeric = TypeScript.PullHelpers.isNameNumeric(name);
+                            var indexerKindMatchesMemberNameKind = isNumericIndexer === isMemberNumeric;
+                            var onlyStringIndexerIsPresent = !numberIndexSignature;
+
+                            if (indexerKindMatchesMemberNameKind || onlyStringIndexerIsPresent) {
+                                var comparisonInfo = new TypeComparisonInfo();
+                                if (!_this.sourceIsAssignableToTarget(allMembers[i].type, signature.returnType, funcDeclAST, context, comparisonInfo, false)) {
+                                    _this.reportErrorThatMemberIsNotSubtypeOfIndexer(allMembers[i], signature, funcDeclAST, context, comparisonInfo);
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+        };
+
+        PullTypeResolver.prototype.postTypeCheckFunctionDeclaration = function (funcDeclAST, context) {
+            this.checkThisCaptureVariableCollides(funcDeclAST, true, context);
+        };
+
+        PullTypeResolver.prototype.resolveReturnTypeAnnotationOfFunctionDeclaration = function (funcDeclAST, returnTypeAnnotation, context) {
+            var returnTypeSymbol = null;
+
+            if (returnTypeAnnotation) {
+                var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+                returnTypeSymbol = this.resolveTypeReference(returnTypeAnnotation, context);
+
+                if (!returnTypeSymbol) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, TypeScript.DiagnosticCode.Cannot_resolve_return_type_reference));
+                } else {
+                    var isConstructor = funcDeclAST.kind() === 137 /* ConstructorDeclaration */ || funcDeclAST.kind() === 143 /* ConstructSignature */;
+                    if (isConstructor && returnTypeSymbol === this.semanticInfoChain.voidTypeSymbol) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Constructors_cannot_have_a_return_type_of_void));
+                    }
+                }
+            }
+
+            return returnTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveMemberFunctionDeclaration = function (funcDecl, context) {
+            return this.resolveFunctionDeclaration(funcDecl, TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */), funcDecl.propertyName, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), funcDecl.block, context);
+        };
+
+        PullTypeResolver.prototype.resolveCallSignature = function (funcDecl, context) {
+            return this.resolveFunctionDeclaration(funcDecl, false, null, funcDecl.typeParameterList, funcDecl.parameterList, TypeScript.ASTHelpers.getType(funcDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.resolveConstructSignature = function (funcDecl, context) {
+            return this.resolveFunctionDeclaration(funcDecl, false, null, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.resolveMethodSignature = function (funcDecl, context) {
+            return this.resolveFunctionDeclaration(funcDecl, false, funcDecl.propertyName, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.resolveAnyFunctionDeclaration = function (funcDecl, context) {
+            return this.resolveFunctionDeclaration(funcDecl, TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */), funcDecl.identifier, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), funcDecl.block, context);
+        };
+
+        PullTypeResolver.prototype.resolveFunctionExpression = function (funcDecl, isContextuallyTyped, context) {
+            return this.resolveAnyFunctionExpression(funcDecl, funcDecl.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList), TypeScript.ASTHelpers.getType(funcDecl), funcDecl.block, null, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.resolveSimpleArrowFunctionExpression = function (funcDecl, isContextuallyTyped, context) {
+            return this.resolveAnyFunctionExpression(funcDecl, null, TypeScript.ASTHelpers.parametersFromIdentifier(funcDecl.identifier), null, funcDecl.block, funcDecl.expression, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.resolveParenthesizedArrowFunctionExpression = function (funcDecl, isContextuallyTyped, context) {
+            return this.resolveAnyFunctionExpression(funcDecl, funcDecl.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList), TypeScript.ASTHelpers.getType(funcDecl), funcDecl.block, funcDecl.expression, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.getEnclosingClassDeclaration = function (ast) {
+            while (ast) {
+                if (ast.kind() === 131 /* ClassDeclaration */) {
+                    return ast;
+                }
+
+                ast = ast.parent;
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.resolveConstructorDeclaration = function (funcDeclAST, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            var funcSymbol = funcDecl.getSymbol();
+
+            var signature = funcDecl.getSignatureSymbol();
+
+            var hadError = false;
+
+            if (signature) {
+                if (signature.isResolved) {
+                    if (this.canTypeCheckAST(funcDeclAST, context)) {
+                        this.typeCheckConstructorDeclaration(funcDeclAST, context);
+                    }
+                    return funcSymbol;
+                }
+
+                if (!signature.inResolution) {
+                    var classAST = this.getEnclosingClassDeclaration(funcDeclAST);
+
+                    if (classAST) {
+                        var classDecl = this.semanticInfoChain.getDeclForAST(classAST);
+                        var classSymbol = classDecl.getSymbol();
+
+                        if (!classSymbol.isResolved && !classSymbol.inResolution) {
+                            this.resolveDeclaredSymbol(classSymbol, context);
+                        }
+                    }
+                }
+
+                var functionTypeSymbol = funcSymbol && funcSymbol.type;
+
+                if (signature.inResolution) {
+                    signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+
+                    if (funcSymbol) {
+                        funcSymbol.setUnresolved();
+                        if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) {
+                            funcSymbol.type = functionTypeSymbol;
+                        }
+                    }
+                    signature.setResolved();
+                    return funcSymbol;
+                }
+
+                if (funcSymbol) {
+                    funcSymbol.startResolving();
+                }
+                signature.startResolving();
+
+                var prevInTypeCheck = context.inTypeCheck;
+
+                context.inTypeCheck = false;
+
+                for (var i = 0; i < funcDeclAST.callSignature.parameterList.parameters.nonSeparatorCount(); i++) {
+                    this.resolveParameter(funcDeclAST.callSignature.parameterList.parameters.nonSeparatorAt(i), context);
+                }
+
+                context.inTypeCheck = prevInTypeCheck;
+
+                if (signature.isGeneric()) {
+                    if (funcSymbol) {
+                        funcSymbol.type.setHasGenericSignature();
+                    }
+                }
+
+                if (!hadError) {
+                    if (funcSymbol) {
+                        funcSymbol.setUnresolved();
+                        if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) {
+                            funcSymbol.type = functionTypeSymbol;
+                        }
+                    }
+                    signature.setResolved();
+                }
+            }
+
+            if (funcSymbol) {
+                this.resolveOtherDeclarations(funcDeclAST, context);
+            }
+
+            if (this.canTypeCheckAST(funcDeclAST, context)) {
+                this.typeCheckConstructorDeclaration(funcDeclAST, context);
+            }
+
+            return funcSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveIndexMemberDeclaration = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+            }
+
+            return this.resolveIndexSignature(ast.indexSignature, context);
+        };
+
+        PullTypeResolver.prototype.resolveIndexSignature = function (funcDeclAST, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            var funcSymbol = funcDecl.getSymbol();
+
+            var signature = funcDecl.getSignatureSymbol();
+
+            var hadError = false;
+
+            if (signature) {
+                if (signature.isResolved) {
+                    if (this.canTypeCheckAST(funcDeclAST, context)) {
+                        this.typeCheckIndexSignature(funcDeclAST, context);
+                    }
+                    return funcSymbol;
+                }
+
+                var functionTypeSymbol = funcSymbol && funcSymbol.type;
+
+                if (signature.inResolution) {
+                    if (funcDeclAST.typeAnnotation) {
+                        var returnTypeSymbol = this.resolveTypeReference(TypeScript.ASTHelpers.getType(funcDeclAST), context);
+                        if (!returnTypeSymbol) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(TypeScript.ASTHelpers.getType(funcDeclAST), TypeScript.DiagnosticCode.Cannot_resolve_return_type_reference));
+                            signature.returnType = this.getNewErrorTypeSymbol();
+                            hadError = true;
+                        } else {
+                            signature.returnType = returnTypeSymbol;
+                        }
+                    } else {
+                        signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+                    }
+
+                    if (funcSymbol) {
+                        funcSymbol.setUnresolved();
+                        if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) {
+                            funcSymbol.type = functionTypeSymbol;
+                        }
+                    }
+                    signature.setResolved();
+                    return funcSymbol;
+                }
+
+                if (funcSymbol) {
+                    funcSymbol.startResolving();
+                }
+                signature.startResolving();
+
+                if (funcDeclAST.parameter) {
+                    var prevInTypeCheck = context.inTypeCheck;
+
+                    context.inTypeCheck = false;
+                    this.resolveParameter(funcDeclAST.parameter, context);
+                    context.inTypeCheck = prevInTypeCheck;
+                }
+
+                if (funcDeclAST.typeAnnotation) {
+                    returnTypeSymbol = this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, TypeScript.ASTHelpers.getType(funcDeclAST), context);
+
+                    if (!returnTypeSymbol) {
+                        signature.returnType = this.getNewErrorTypeSymbol();
+                        hadError = true;
+                    } else {
+                        signature.returnType = returnTypeSymbol;
+                    }
+                } else {
+                    signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+                }
+
+                if (!hadError) {
+                    if (funcSymbol) {
+                        funcSymbol.setUnresolved();
+                        if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) {
+                            funcSymbol.type = functionTypeSymbol;
+                        }
+                    }
+                    signature.setResolved();
+                }
+            }
+
+            if (funcSymbol) {
+                this.resolveOtherDeclarations(funcDeclAST, context);
+            }
+
+            if (this.canTypeCheckAST(funcDeclAST, context)) {
+                this.typeCheckIndexSignature(funcDeclAST, context);
+            }
+
+            return funcSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveFunctionDeclaration = function (funcDeclAST, isStatic, name, typeParameters, parameterList, returnTypeAnnotation, block, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            var funcSymbol = funcDecl.getSymbol();
+
+            var signature = funcDecl.getSignatureSymbol();
+
+            var hadError = false;
+
+            var isConstructor = funcDeclAST.kind() === 143 /* ConstructSignature */;
+
+            if (signature) {
+                if (signature.isResolved) {
+                    if (this.canTypeCheckAST(funcDeclAST, context)) {
+                        this.typeCheckAnyFunctionDeclaration(funcDeclAST, isStatic, name, typeParameters, parameterList, returnTypeAnnotation, block, context);
+                    }
+                    return funcSymbol;
+                }
+
+                if (isConstructor && !signature.inResolution) {
+                    var classAST = this.getEnclosingClassDeclaration(funcDeclAST);
+
+                    if (classAST) {
+                        var classDecl = this.semanticInfoChain.getDeclForAST(classAST);
+                        var classSymbol = classDecl.getSymbol();
+
+                        if (!classSymbol.isResolved && !classSymbol.inResolution) {
+                            this.resolveDeclaredSymbol(classSymbol, context);
+                        }
+                    }
+                }
+
+                var functionTypeSymbol = funcSymbol && funcSymbol.type;
+
+                if (signature.inResolution) {
+                    if (returnTypeAnnotation) {
+                        var returnTypeSymbol = this.resolveTypeReference(returnTypeAnnotation, context);
+                        if (!returnTypeSymbol) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, TypeScript.DiagnosticCode.Cannot_resolve_return_type_reference));
+                            signature.returnType = this.getNewErrorTypeSymbol();
+                            hadError = true;
+                        } else {
+                            signature.returnType = returnTypeSymbol;
+
+                            if (isConstructor && returnTypeSymbol === this.semanticInfoChain.voidTypeSymbol) {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Constructors_cannot_have_a_return_type_of_void));
+                            }
+                        }
+                    } else {
+                        signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+                    }
+
+                    if (funcSymbol) {
+                        funcSymbol.setUnresolved();
+                        if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) {
+                            funcSymbol.type = functionTypeSymbol;
+                        }
+                    }
+                    signature.setResolved();
+                    return funcSymbol;
+                }
+
+                if (funcSymbol) {
+                    funcSymbol.startResolving();
+                }
+                signature.startResolving();
+
+                if (typeParameters) {
+                    for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) {
+                        this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context);
+                    }
+                }
+
+                if (parameterList) {
+                    var prevInTypeCheck = context.inTypeCheck;
+
+                    context.inTypeCheck = false;
+
+                    for (var i = 0; i < parameterList.parameters.nonSeparatorCount(); i++) {
+                        this.resolveParameter(parameterList.parameters.nonSeparatorAt(i), context);
+                    }
+
+                    context.inTypeCheck = prevInTypeCheck;
+                }
+
+                if (returnTypeAnnotation) {
+                    returnTypeSymbol = this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, returnTypeAnnotation, context);
+
+                    if (!returnTypeSymbol) {
+                        signature.returnType = this.getNewErrorTypeSymbol();
+                        hadError = true;
+                    } else {
+                        signature.returnType = returnTypeSymbol;
+                    }
+                } else if (funcDecl.kind !== 2097152 /* ConstructSignature */) {
+                    if (TypeScript.hasFlag(funcDecl.flags, 2048 /* Signature */)) {
+                        signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+                        var parentDeclFlags = 0 /* None */;
+                        if (TypeScript.hasFlag(funcDecl.kind, 65536 /* Method */) || TypeScript.hasFlag(funcDecl.kind, 32768 /* ConstructorMethod */)) {
+                            var parentDecl = funcDecl.getParentDecl();
+                            parentDeclFlags = parentDecl.flags;
+                        }
+
+                        if (this.compilationSettings.noImplicitAny() && (!TypeScript.hasFlag(parentDeclFlags, 8 /* Ambient */) || (TypeScript.hasFlag(parentDeclFlags, 8 /* Ambient */) && !TypeScript.hasFlag(funcDecl.flags, 2 /* Private */)))) {
+                            var funcDeclASTName = name;
+                            if (funcDeclASTName) {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type, [funcDeclASTName.text()]));
+                            } else {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Lambda_Function_which_lacks_return_type_annotation_implicitly_has_an_any_return_type));
+                            }
+                        }
+                    } else {
+                        this.resolveFunctionBodyReturnTypes(funcDeclAST, block, null, signature, false, funcDecl, context);
+                    }
+                } else if (funcDecl.kind === 2097152 /* ConstructSignature */) {
+                    signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+
+                    if (this.compilationSettings.noImplicitAny()) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Constructor_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type));
+                    }
+                }
+
+                if (!hadError) {
+                    if (funcSymbol) {
+                        funcSymbol.setUnresolved();
+                        if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) {
+                            funcSymbol.type = functionTypeSymbol;
+                        }
+                    }
+                    signature.setResolved();
+                }
+            }
+
+            if (funcSymbol) {
+                this.resolveOtherDeclarations(funcDeclAST, context);
+            }
+
+            if (this.canTypeCheckAST(funcDeclAST, context)) {
+                this.typeCheckAnyFunctionDeclaration(funcDeclAST, isStatic, name, typeParameters, parameterList, returnTypeAnnotation, block, context);
+            }
+
+            return funcSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveGetterReturnTypeAnnotation = function (getterFunctionDeclarationAst, enclosingDecl, context) {
+            if (getterFunctionDeclarationAst && getterFunctionDeclarationAst.typeAnnotation) {
+                return this.resolveTypeReference(TypeScript.ASTHelpers.getType(getterFunctionDeclarationAst), context);
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.resolveSetterArgumentTypeAnnotation = function (setterFunctionDeclarationAst, enclosingDecl, context) {
+            if (setterFunctionDeclarationAst && setterFunctionDeclarationAst.parameterList && setterFunctionDeclarationAst.parameterList.parameters.nonSeparatorCount() > 0) {
+                var parameter = setterFunctionDeclarationAst.parameterList.parameters.nonSeparatorAt(0);
+                return this.resolveTypeReference(TypeScript.ASTHelpers.getType(parameter), context);
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.resolveAccessorDeclaration = function (funcDeclAst, context) {
+            var functionDeclaration = this.semanticInfoChain.getDeclForAST(funcDeclAst);
+            var accessorSymbol = functionDeclaration.getSymbol();
+
+            if (accessorSymbol.inResolution) {
+                accessorSymbol.type = this.semanticInfoChain.anyTypeSymbol;
+                accessorSymbol.setResolved();
+
+                return accessorSymbol;
+            }
+
+            if (accessorSymbol.isResolved) {
+                if (!accessorSymbol.type) {
+                    accessorSymbol.type = this.semanticInfoChain.anyTypeSymbol;
+                }
+            } else {
+                var getterSymbol = accessorSymbol.getGetter();
+                var getterFunctionDeclarationAst = getterSymbol ? getterSymbol.getDeclarations()[0].ast() : null;
+                var hasGetter = getterSymbol !== null;
+
+                var setterSymbol = accessorSymbol.getSetter();
+                var setterFunctionDeclarationAst = setterSymbol ? setterSymbol.getDeclarations()[0].ast() : null;
+                var hasSetter = setterSymbol !== null;
+
+                var getterAnnotatedType = this.resolveGetterReturnTypeAnnotation(getterFunctionDeclarationAst, functionDeclaration, context);
+                var getterHasTypeAnnotation = getterAnnotatedType !== null;
+
+                var setterAnnotatedType = this.resolveSetterArgumentTypeAnnotation(setterFunctionDeclarationAst, functionDeclaration, context);
+                var setterHasTypeAnnotation = setterAnnotatedType !== null;
+
+                accessorSymbol.startResolving();
+
+                if (hasGetter) {
+                    getterSymbol = this.resolveGetAccessorDeclaration(getterFunctionDeclarationAst, getterFunctionDeclarationAst.parameterList, TypeScript.ASTHelpers.getType(getterFunctionDeclarationAst), getterFunctionDeclarationAst.block, setterAnnotatedType, context);
+                }
+
+                if (hasSetter) {
+                    setterSymbol = this.resolveSetAccessorDeclaration(setterFunctionDeclarationAst, setterFunctionDeclarationAst.parameterList, context);
+                }
+
+                if (hasGetter && hasSetter) {
+                    var setterSig = setterSymbol.type.getCallSignatures()[0];
+                    var setterParameters = setterSig.parameters;
+                    var setterHasParameters = setterParameters.length > 0;
+                    var getterSig = getterSymbol.type.getCallSignatures()[0];
+
+                    var setterSuppliedTypeSymbol = setterHasParameters ? setterParameters[0].type : null;
+                    var getterSuppliedTypeSymbol = getterSig.returnType;
+
+                    if (setterHasTypeAnnotation && !getterHasTypeAnnotation) {
+                        getterSuppliedTypeSymbol = setterSuppliedTypeSymbol;
+                        getterSig.returnType = setterSuppliedTypeSymbol;
+                    } else if ((getterHasTypeAnnotation && !setterHasTypeAnnotation) || (!getterHasTypeAnnotation && !setterHasTypeAnnotation)) {
+                        setterSuppliedTypeSymbol = getterSuppliedTypeSymbol;
+
+                        if (setterHasParameters) {
+                            setterParameters[0].type = getterSuppliedTypeSymbol;
+                        }
+                    }
+
+                    if (!this.typesAreIdentical(setterSuppliedTypeSymbol, getterSuppliedTypeSymbol, context)) {
+                        accessorSymbol.type = this.getNewErrorTypeSymbol();
+                    } else {
+                        accessorSymbol.type = getterSuppliedTypeSymbol;
+                    }
+                } else if (hasSetter) {
+                    var setterSig = setterSymbol.type.getCallSignatures()[0];
+                    var setterParameters = setterSig.parameters;
+                    var setterHasParameters = setterParameters.length > 0;
+
+                    accessorSymbol.type = setterHasParameters ? setterParameters[0].type : this.semanticInfoChain.anyTypeSymbol;
+                } else {
+                    var getterSig = getterSymbol.type.getCallSignatures()[0];
+                    accessorSymbol.type = getterSig.returnType;
+                }
+
+                accessorSymbol.setResolved();
+            }
+
+            if (this.canTypeCheckAST(funcDeclAst, context)) {
+                this.typeCheckAccessorDeclaration(funcDeclAst, context);
+            }
+
+            return accessorSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckAccessorDeclaration = function (funcDeclAst, context) {
+            this.setTypeChecked(funcDeclAst, context);
+            var functionDeclaration = this.semanticInfoChain.getDeclForAST(funcDeclAst);
+            var accessorSymbol = functionDeclaration.getSymbol();
+            var getterSymbol = accessorSymbol.getGetter();
+            var setterSymbol = accessorSymbol.getSetter();
+
+            var isGetter = funcDeclAst.kind() === 139 /* GetAccessor */;
+            if (isGetter) {
+                var getterFunctionDeclarationAst = funcDeclAst;
+                context.pushNewContextualType(getterSymbol.type);
+                this.typeCheckGetAccessorDeclaration(getterFunctionDeclarationAst, context);
+                context.popAnyContextualType();
+            } else {
+                var setterFunctionDeclarationAst = funcDeclAst;
+                this.typeCheckSetAccessorDeclaration(setterFunctionDeclarationAst, context);
+            }
+        };
+
+        PullTypeResolver.prototype.resolveGetAccessorDeclaration = function (funcDeclAST, parameters, returnTypeAnnotation, block, setterAnnotatedType, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            var accessorSymbol = funcDecl.getSymbol();
+
+            var getterSymbol = accessorSymbol.getGetter();
+            var getterTypeSymbol = getterSymbol.type;
+
+            var signature = getterTypeSymbol.getCallSignatures()[0];
+
+            var hadError = false;
+
+            if (signature) {
+                if (signature.isResolved) {
+                    return getterSymbol;
+                }
+
+                if (signature.inResolution) {
+                    signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+                    signature.setResolved();
+
+                    return getterSymbol;
+                }
+
+                signature.startResolving();
+
+                if (returnTypeAnnotation) {
+                    var returnTypeSymbol = this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, returnTypeAnnotation, context);
+
+                    if (!returnTypeSymbol) {
+                        signature.returnType = this.getNewErrorTypeSymbol();
+
+                        hadError = true;
+                    } else {
+                        signature.returnType = returnTypeSymbol;
+                    }
+                } else {
+                    if (!setterAnnotatedType) {
+                        this.resolveFunctionBodyReturnTypes(funcDeclAST, block, null, signature, false, funcDecl, context);
+                    } else {
+                        signature.returnType = setterAnnotatedType;
+                    }
+                }
+
+                if (!hadError) {
+                    signature.setResolved();
+                }
+            }
+
+            return getterSymbol;
+        };
+
+        PullTypeResolver.prototype.checkIfGetterAndSetterTypeMatch = function (funcDeclAST, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            var accessorSymbol = funcDecl.getSymbol();
+            var getter = accessorSymbol.getGetter();
+            var setter = accessorSymbol.getSetter();
+
+            if (getter && setter) {
+                var getterAST = getter.getDeclarations()[0].ast();
+                var setterAST = setter.getDeclarations()[0].ast();
+
+                if (getterAST.typeAnnotation && PullTypeResolver.hasSetAccessorParameterTypeAnnotation(setterAST)) {
+                    var setterSig = setter.type.getCallSignatures()[0];
+                    var setterParameters = setterSig.parameters;
+
+                    var getter = accessorSymbol.getGetter();
+                    var getterSig = getter.type.getCallSignatures()[0];
+
+                    var setterSuppliedTypeSymbol = setterParameters[0].type;
+                    var getterSuppliedTypeSymbol = getterSig.returnType;
+
+                    if (!this.typesAreIdentical(setterSuppliedTypeSymbol, getterSuppliedTypeSymbol, context)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.get_and_set_accessor_must_have_the_same_type));
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckGetAccessorDeclaration = function (funcDeclAST, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            var accessorSymbol = funcDecl.getSymbol();
+
+            this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, TypeScript.ASTHelpers.getType(funcDeclAST), context);
+
+            this.resolveAST(funcDeclAST.block, false, context);
+
+            this.validateVariableDeclarationGroups(funcDecl, context);
+
+            var enclosingDecl = this.getEnclosingDecl(funcDecl);
+
+            var hasReturn = (funcDecl.flags & (2048 /* Signature */ | 4194304 /* HasReturnStatement */)) !== 0;
+            var funcNameAST = funcDeclAST.propertyName;
+
+            if (!hasReturn && !this.containsSingleThrowStatement(funcDeclAST.block)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcNameAST, TypeScript.DiagnosticCode.Getters_must_return_a_value));
+            }
+
+            var setter = accessorSymbol.getSetter();
+            if (setter) {
+                var setterDecl = setter.getDeclarations()[0];
+                var setterIsPrivate = TypeScript.hasFlag(setterDecl.flags, 2 /* Private */);
+                var getterIsPrivate = TypeScript.hasModifier(funcDeclAST.modifiers, 2 /* Private */);
+
+                if (getterIsPrivate !== setterIsPrivate) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcNameAST, TypeScript.DiagnosticCode.Getter_and_setter_accessors_do_not_agree_in_visibility));
+                }
+
+                this.checkIfGetterAndSetterTypeMatch(funcDeclAST, context);
+            }
+
+            this.checkFunctionTypePrivacy(funcDeclAST, TypeScript.hasModifier(funcDeclAST.modifiers, 16 /* Static */), null, TypeScript.ASTHelpers.parametersFromParameterList(funcDeclAST.parameterList), TypeScript.ASTHelpers.getType(funcDeclAST), funcDeclAST.block, context);
+        };
+
+        PullTypeResolver.hasSetAccessorParameterTypeAnnotation = function (setAccessor) {
+            return setAccessor.parameterList && setAccessor.parameterList.parameters.nonSeparatorCount() > 0 && setAccessor.parameterList.parameters.nonSeparatorAt(0).typeAnnotation !== null;
+        };
+
+        PullTypeResolver.prototype.resolveSetAccessorDeclaration = function (funcDeclAST, parameterList, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            var accessorSymbol = funcDecl.getSymbol();
+
+            var setterSymbol = accessorSymbol.getSetter();
+            var setterTypeSymbol = setterSymbol.type;
+
+            var signature = funcDecl.getSignatureSymbol();
+
+            var hadError = false;
+
+            if (signature) {
+                if (signature.isResolved) {
+                    return setterSymbol;
+                }
+
+                if (signature.inResolution) {
+                    signature.returnType = this.semanticInfoChain.voidTypeSymbol;
+                    signature.setResolved();
+                    return setterSymbol;
+                }
+
+                signature.startResolving();
+
+                if (parameterList) {
+                    for (var i = 0; i < parameterList.parameters.nonSeparatorCount(); i++) {
+                        this.resolveParameter(parameterList.parameters.nonSeparatorAt(i), context);
+                    }
+                }
+
+                signature.returnType = this.semanticInfoChain.voidTypeSymbol;
+
+                if (!hadError) {
+                    signature.setResolved();
+                }
+            }
+
+            return setterSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckSetAccessorDeclaration = function (funcDeclAST, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            var accessorSymbol = funcDecl.getSymbol();
+
+            if (funcDeclAST.parameterList) {
+                for (var i = 0; i < funcDeclAST.parameterList.parameters.nonSeparatorCount(); i++) {
+                    this.resolveParameter(funcDeclAST.parameterList.parameters.nonSeparatorAt(i), context);
+                }
+            }
+
+            this.resolveAST(funcDeclAST.block, false, context);
+
+            this.validateVariableDeclarationGroups(funcDecl, context);
+
+            var hasReturn = (funcDecl.flags & (2048 /* Signature */ | 4194304 /* HasReturnStatement */)) !== 0;
+
+            var getter = accessorSymbol.getGetter();
+
+            var funcNameAST = funcDeclAST.propertyName;
+
+            if (getter) {
+                var getterDecl = getter.getDeclarations()[0];
+                var getterIsPrivate = TypeScript.hasFlag(getterDecl.flags, 2 /* Private */);
+                var setterIsPrivate = TypeScript.hasModifier(funcDeclAST.modifiers, 2 /* Private */);
+
+                if (getterIsPrivate !== setterIsPrivate) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcNameAST, TypeScript.DiagnosticCode.Getter_and_setter_accessors_do_not_agree_in_visibility));
+                }
+
+                this.checkIfGetterAndSetterTypeMatch(funcDeclAST, context);
+            } else {
+                if (this.compilationSettings.noImplicitAny()) {
+                    var setterFunctionDeclarationAst = funcDeclAST;
+                    if (!PullTypeResolver.hasSetAccessorParameterTypeAnnotation(setterFunctionDeclarationAst) && accessorSymbol.type === this.semanticInfoChain.anyTypeSymbol) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_get_accessor_and_parameter_type_annotation_on_set_accessor_implicitly_has_an_any_type, [setterFunctionDeclarationAst.propertyName.text()]));
+                    }
+                }
+            }
+
+            this.checkFunctionTypePrivacy(funcDeclAST, TypeScript.hasModifier(funcDeclAST.modifiers, 16 /* Static */), null, TypeScript.ASTHelpers.parametersFromParameterList(funcDeclAST.parameterList), null, funcDeclAST.block, context);
+        };
+
+        PullTypeResolver.prototype.resolveList = function (list, context) {
+            if (this.canTypeCheckAST(list, context)) {
+                this.setTypeChecked(list, context);
+
+                for (var i = 0, n = list.childCount(); i < n; i++) {
+                    this.resolveAST(list.childAt(i), false, context);
+                }
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveSeparatedList = function (list, context) {
+            if (this.canTypeCheckAST(list, context)) {
+                this.setTypeChecked(list, context);
+
+                for (var i = 0, n = list.nonSeparatorCount(); i < n; i++) {
+                    this.resolveAST(list.nonSeparatorAt(i), false, context);
+                }
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveVoidExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+
+                this.resolveAST(ast.expression, false, context);
+            }
+
+            return this.semanticInfoChain.undefinedTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveLogicalOperation = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckLogicalOperation(ast, context);
+            }
+
+            return this.semanticInfoChain.booleanTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckLogicalOperation = function (binex, context) {
+            this.setTypeChecked(binex, context);
+
+            var leftType = this.resolveAST(binex.left, false, context).type;
+            var rightType = this.resolveAST(binex.right, false, context).type;
+
+            var comparisonInfo = new TypeComparisonInfo();
+            if (!this.sourceIsAssignableToTarget(leftType, rightType, binex, context, comparisonInfo) && !this.sourceIsAssignableToTarget(rightType, leftType, binex, context, comparisonInfo)) {
+                var enclosingSymbol = this.getEnclosingSymbolForAST(binex);
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binex, TypeScript.DiagnosticCode.Operator_0_cannot_be_applied_to_types_1_and_2, [
+                    TypeScript.SyntaxFacts.getText(TypeScript.SyntaxFacts.getOperatorTokenFromBinaryExpression(binex.kind())),
+                    leftType.toString(enclosingSymbol), rightType.toString(enclosingSymbol)]));
+            }
+        };
+
+        PullTypeResolver.prototype.resolveLogicalNotExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+
+                this.resolveAST(ast.operand, false, context);
+            }
+
+            return this.semanticInfoChain.booleanTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveUnaryArithmeticOperation = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckUnaryArithmeticOperation(ast, context);
+            }
+
+            return this.semanticInfoChain.numberTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolvePostfixUnaryExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckPostfixUnaryExpression(ast, context);
+            }
+
+            return this.semanticInfoChain.numberTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.isAnyOrNumberOrEnum = function (type) {
+            return this.isAnyOrEquivalent(type) || type === this.semanticInfoChain.numberTypeSymbol || TypeScript.PullHelpers.symbolIsEnum(type);
+        };
+
+        PullTypeResolver.prototype.typeCheckUnaryArithmeticOperation = function (unaryExpression, context) {
+            this.setTypeChecked(unaryExpression, context);
+
+            var nodeType = unaryExpression.kind();
+            var expression = this.resolveAST(unaryExpression.operand, false, context);
+
+            if (nodeType === 164 /* PlusExpression */ || nodeType == 165 /* NegateExpression */ || nodeType == 166 /* BitwiseNotExpression */) {
+                return;
+            }
+
+            TypeScript.Debug.assert(nodeType === 168 /* PreIncrementExpression */ || nodeType === 169 /* PreDecrementExpression */);
+
+            var operandType = expression.type;
+            if (!this.isAnyOrNumberOrEnum(operandType)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_type_of_a_unary_arithmetic_operation_operand_must_be_of_type_any_number_or_an_enum_type));
+            }
+
+            if (!this.isReference(unaryExpression.operand, expression)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer));
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckPostfixUnaryExpression = function (unaryExpression, context) {
+            this.setTypeChecked(unaryExpression, context);
+
+            var nodeType = unaryExpression.kind();
+            var expression = this.resolveAST(unaryExpression.operand, false, context);
+
+            TypeScript.Debug.assert(nodeType === 210 /* PostIncrementExpression */ || nodeType === 211 /* PostDecrementExpression */);
+
+            var operandType = expression.type;
+            if (!this.isAnyOrNumberOrEnum(operandType)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_type_of_a_unary_arithmetic_operation_operand_must_be_of_type_any_number_or_an_enum_type));
+            }
+
+            if (!this.isReference(unaryExpression.operand, expression)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer));
+            }
+        };
+
+        PullTypeResolver.prototype.resolveBinaryArithmeticExpression = function (binaryExpression, context) {
+            if (this.canTypeCheckAST(binaryExpression, context)) {
+                this.typeCheckBinaryArithmeticExpression(binaryExpression, context);
+            }
+
+            return this.semanticInfoChain.numberTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckBinaryArithmeticExpression = function (binaryExpression, context) {
+            this.setTypeChecked(binaryExpression, context);
+
+            var lhsSymbol = this.resolveAST(binaryExpression.left, false, context);
+
+            var lhsType = lhsSymbol.type;
+            var rhsType = this.resolveAST(binaryExpression.right, false, context).type;
+
+            if (lhsType === this.semanticInfoChain.nullTypeSymbol || lhsType === this.semanticInfoChain.undefinedTypeSymbol) {
+                lhsType = rhsType;
+            }
+
+            if (rhsType === this.semanticInfoChain.nullTypeSymbol || rhsType === this.semanticInfoChain.undefinedTypeSymbol) {
+                rhsType = lhsType;
+            }
+
+            var lhsIsFit = this.isAnyOrNumberOrEnum(lhsType);
+            var rhsIsFit = this.isAnyOrNumberOrEnum(rhsType);
+
+            if (!rhsIsFit) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.right, TypeScript.DiagnosticCode.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type));
+            }
+
+            if (!lhsIsFit) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type));
+            }
+
+            if (lhsIsFit && rhsIsFit) {
+                switch (binaryExpression.kind()) {
+                    case 183 /* LeftShiftAssignmentExpression */:
+                    case 184 /* SignedRightShiftAssignmentExpression */:
+                    case 185 /* UnsignedRightShiftAssignmentExpression */:
+                    case 176 /* SubtractAssignmentExpression */:
+                    case 177 /* MultiplyAssignmentExpression */:
+                    case 178 /* DivideAssignmentExpression */:
+                    case 179 /* ModuloAssignmentExpression */:
+                    case 182 /* OrAssignmentExpression */:
+                    case 180 /* AndAssignmentExpression */:
+                    case 181 /* ExclusiveOrAssignmentExpression */:
+                        if (!this.isReference(binaryExpression.left, lhsSymbol)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_left_hand_side_of_assignment_expression));
+                        }
+
+                        this.checkAssignability(binaryExpression.left, rhsType, lhsType, context);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveTypeOfExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+
+                this.resolveAST(ast.expression, false, context);
+            }
+
+            return this.semanticInfoChain.stringTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveThrowStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+
+                this.resolveAST(ast.expression, false, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveDeleteExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+                this.resolveAST(ast.expression, false, context);
+            }
+
+            return this.semanticInfoChain.booleanTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveInstanceOfExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckInstanceOfExpression(ast, context);
+            }
+
+            return this.semanticInfoChain.booleanTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckInstanceOfExpression = function (binaryExpression, context) {
+            this.setTypeChecked(binaryExpression, context);
+
+            var lhsType = this.resolveAST(binaryExpression.left, false, context).type;
+            var rhsType = this.resolveAST(binaryExpression.right, false, context).type;
+
+            var enclosingSymbol = this.getEnclosingSymbolForAST(binaryExpression);
+            var isValidLHS = this.isAnyOrEquivalent(lhsType) || lhsType.isObject() || lhsType.isTypeParameter();
+            var isValidRHS = this.isAnyOrEquivalent(rhsType) || this.typeIsAssignableToFunction(rhsType, binaryExpression, context);
+
+            if (!isValidLHS) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter));
+            }
+
+            if (!isValidRHS) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.right, TypeScript.DiagnosticCode.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type));
+            }
+        };
+
+        PullTypeResolver.prototype.resolveCommaExpression = function (commaExpression, context) {
+            if (this.canTypeCheckAST(commaExpression, context)) {
+                this.setTypeChecked(commaExpression, context);
+
+                this.resolveAST(commaExpression.left, false, context);
+            }
+
+            return this.resolveAST(commaExpression.right, false, context).type;
+        };
+
+        PullTypeResolver.prototype.resolveInExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckInExpression(ast, context);
+            }
+
+            return this.semanticInfoChain.booleanTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckInExpression = function (binaryExpression, context) {
+            this.setTypeChecked(binaryExpression, context);
+
+            var lhsType = this.resolveAST(binaryExpression.left, false, context).type;
+            var rhsType = this.resolveAST(binaryExpression.right, false, context).type;
+
+            var isValidLHS = this.isAnyOrEquivalent(lhsType.type) || lhsType.type === this.semanticInfoChain.stringTypeSymbol || lhsType.type === this.semanticInfoChain.numberTypeSymbol;
+
+            var isValidRHS = this.isAnyOrEquivalent(rhsType) || rhsType.isObject() || rhsType.isTypeParameter();
+
+            if (!isValidLHS) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.The_left_hand_side_of_an_in_expression_must_be_of_types_any_string_or_number));
+            }
+
+            if (!isValidRHS) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.right, TypeScript.DiagnosticCode.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter));
+            }
+        };
+
+        PullTypeResolver.prototype.resolveForStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+
+                this.resolveAST(ast.variableDeclaration, false, context);
+                this.resolveAST(ast.initializer, false, context);
+                this.resolveAST(ast.condition, false, context);
+                this.resolveAST(ast.incrementor, false, context);
+                this.resolveAST(ast.statement, false, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveForInStatement = function (forInStatement, context) {
+            if (this.canTypeCheckAST(forInStatement, context)) {
+                this.typeCheckForInStatement(forInStatement, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckForInStatement = function (forInStatement, context) {
+            this.setTypeChecked(forInStatement, context);
+
+            if (forInStatement.variableDeclaration) {
+                var declaration = forInStatement.variableDeclaration;
+
+                if (declaration.declarators.nonSeparatorCount() === 1) {
+                    var varDecl = declaration.declarators.nonSeparatorAt(0);
+
+                    if (varDecl.typeAnnotation) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(declaration, TypeScript.DiagnosticCode.Variable_declarations_of_a_for_statement_cannot_use_a_type_annotation));
+                    }
+                }
+            } else {
+                var varSym = this.resolveAST(forInStatement.left, false, context);
+                var isStringOrNumber = varSym.type === this.semanticInfoChain.stringTypeSymbol || this.isAnyOrEquivalent(varSym.type);
+
+                if (!isStringOrNumber) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(forInStatement.left, TypeScript.DiagnosticCode.Variable_declarations_of_a_for_statement_must_be_of_types_string_or_any));
+                }
+            }
+
+            var rhsType = this.resolveAST(forInStatement.expression, false, context).type;
+            var isValidRHS = rhsType && (this.isAnyOrEquivalent(rhsType) || rhsType.isObject() || rhsType.isTypeParameter());
+
+            if (!isValidRHS) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(forInStatement.expression, TypeScript.DiagnosticCode.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter));
+            }
+
+            this.resolveAST(forInStatement.statement, false, context);
+        };
+
+        PullTypeResolver.prototype.resolveWhileStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckWhileStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckWhileStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            this.resolveAST(ast.condition, false, context);
+            this.resolveAST(ast.statement, false, context);
+        };
+
+        PullTypeResolver.prototype.resolveDoStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckDoStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckDoStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            this.resolveAST(ast.condition, false, context);
+            this.resolveAST(ast.statement, false, context);
+        };
+
+        PullTypeResolver.prototype.resolveIfStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckIfStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckIfStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            this.resolveAST(ast.condition, false, context);
+            this.resolveAST(ast.statement, false, context);
+            this.resolveAST(ast.elseClause, false, context);
+        };
+
+        PullTypeResolver.prototype.resolveElseClause = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckElseClause(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckElseClause = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            this.resolveAST(ast.statement, false, context);
+        };
+
+        PullTypeResolver.prototype.resolveBlock = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+                this.resolveAST(ast.statements, false, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveVariableStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+                this.resolveAST(ast.declaration, false, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveVariableDeclarationList = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+                this.resolveAST(ast.declarators, false, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveWithStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckWithStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckWithStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+            var withStatement = ast;
+            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(withStatement.condition, TypeScript.DiagnosticCode.All_symbols_within_a_with_block_will_be_resolved_to_any));
+        };
+
+        PullTypeResolver.prototype.resolveTryStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckTryStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckTryStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+            var tryStatement = ast;
+
+            this.resolveAST(tryStatement.block, false, context);
+            this.resolveAST(tryStatement.catchClause, false, context);
+            this.resolveAST(tryStatement.finallyClause, false, context);
+        };
+
+        PullTypeResolver.prototype.resolveCatchClause = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckCatchClause(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckCatchClause = function (ast, context) {
+            this.setTypeChecked(ast, context);
+            this.resolveAST(ast.block, false, context);
+
+            var catchDecl = this.semanticInfoChain.getDeclForAST(ast);
+            this.validateVariableDeclarationGroups(catchDecl, context);
+        };
+
+        PullTypeResolver.prototype.resolveFinallyClause = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckFinallyClause(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckFinallyClause = function (ast, context) {
+            this.setTypeChecked(ast, context);
+            this.resolveAST(ast.block, false, context);
+        };
+
+        PullTypeResolver.prototype.getEnclosingFunctionDeclaration = function (ast) {
+            var enclosingDecl = this.getEnclosingDeclForAST(ast);
+
+            while (enclosingDecl) {
+                if (enclosingDecl.kind & 1032192 /* SomeFunction */) {
+                    return enclosingDecl;
+                }
+
+                enclosingDecl = enclosingDecl.getParentDecl();
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.resolveReturnExpression = function (expression, enclosingFunction, context) {
+            if (enclosingFunction) {
+                enclosingFunction.setFlag(4194304 /* HasReturnStatement */);
+            }
+
+            var isContextuallyTyped = false;
+
+            if (enclosingFunction) {
+                var enclosingDeclAST = this.getASTForDecl(enclosingFunction);
+                var typeAnnotation = TypeScript.ASTHelpers.getType(enclosingDeclAST);
+                if (typeAnnotation) {
+                    var returnTypeAnnotationSymbol = this.resolveTypeReference(typeAnnotation, context);
+                    if (returnTypeAnnotationSymbol) {
+                        isContextuallyTyped = true;
+                        context.pushNewContextualType(returnTypeAnnotationSymbol);
+                    }
+                } else {
+                    var currentContextualType = context.getContextualType();
+                    if (currentContextualType && currentContextualType.isFunction()) {
+                        var contextualSignatures = currentContextualType.kind == 33554432 /* ConstructorType */ ? currentContextualType.getConstructSignatures() : currentContextualType.getCallSignatures();
+                        var currentContextualTypeSignatureSymbol = contextualSignatures[0];
+
+                        var currentContextualTypeReturnTypeSymbol = currentContextualTypeSignatureSymbol.returnType;
+                        if (currentContextualTypeReturnTypeSymbol) {
+                            isContextuallyTyped = true;
+                            context.propagateContextualType(currentContextualTypeReturnTypeSymbol);
+                        }
+                    }
+                }
+            }
+
+            var result = this.resolveAST(expression, isContextuallyTyped, context).type;
+            if (isContextuallyTyped) {
+                context.popAnyContextualType();
+            }
+
+            return result;
+        };
+
+        PullTypeResolver.prototype.typeCheckReturnExpression = function (expression, expressionType, enclosingFunction, context) {
+            if (enclosingFunction && enclosingFunction.kind === 32768 /* ConstructorMethod */) {
+                var classDecl = enclosingFunction.getParentDecl();
+                if (classDecl) {
+                    var classSymbol = classDecl.getSymbol();
+                    this.resolveDeclaredSymbol(classSymbol, context);
+
+                    var comparisonInfo = new TypeComparisonInfo();
+                    var isAssignable = this.sourceIsAssignableToTarget(expressionType, classSymbol.type, expression, context, comparisonInfo);
+                    if (!isAssignable) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class));
+                    }
+                }
+            }
+
+            if (enclosingFunction && enclosingFunction.kind === 524288 /* SetAccessor */) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Setters_cannot_return_a_value));
+            }
+
+            if (enclosingFunction) {
+                var enclosingDeclAST = this.getASTForDecl(enclosingFunction);
+                var typeAnnotation = TypeScript.ASTHelpers.getType(enclosingDeclAST);
+                if (typeAnnotation || enclosingFunction.kind === 262144 /* GetAccessor */) {
+                    var signatureSymbol = enclosingFunction.getSignatureSymbol();
+                    var sigReturnType = signatureSymbol.returnType;
+
+                    if (expressionType && sigReturnType) {
+                        var comparisonInfo = new TypeComparisonInfo();
+                        var upperBound = null;
+
+                        this.resolveDeclaredSymbol(expressionType, context);
+                        this.resolveDeclaredSymbol(sigReturnType, context);
+
+                        var isAssignable = this.sourceIsAssignableToTarget(expressionType, sigReturnType, expression, context, comparisonInfo);
+
+                        if (!isAssignable) {
+                            var enclosingSymbol = this.getEnclosingSymbolForAST(expression);
+                            if (comparisonInfo.message) {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [expressionType.toString(enclosingSymbol), sigReturnType.toString(enclosingSymbol), comparisonInfo.message]));
+                            } else {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [expressionType.toString(enclosingSymbol), sigReturnType.toString(enclosingSymbol)]));
+                            }
+                        }
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveReturnStatement = function (returnAST, context) {
+            var enclosingFunction = this.getEnclosingFunctionDeclaration(returnAST);
+            if (enclosingFunction) {
+                enclosingFunction.setFlag(4194304 /* HasReturnStatement */);
+            }
+
+            var returnType = this.getSymbolForAST(returnAST, context);
+            var canTypeCheckAST = this.canTypeCheckAST(returnAST, context);
+            if (!returnType || canTypeCheckAST) {
+                var returnExpr = returnAST.expression;
+
+                var resolvedReturnType = returnExpr === null ? this.semanticInfoChain.voidTypeSymbol : this.resolveReturnExpression(returnExpr, enclosingFunction, context);
+
+                if (!returnType) {
+                    returnType = resolvedReturnType;
+                    this.setSymbolForAST(returnAST, resolvedReturnType, context);
+                }
+
+                if (returnExpr && canTypeCheckAST) {
+                    this.setTypeChecked(returnExpr, context);
+                    this.typeCheckReturnExpression(returnExpr, resolvedReturnType, enclosingFunction, context);
+                }
+            }
+
+            return returnType;
+        };
+
+        PullTypeResolver.prototype.resolveSwitchStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckSwitchStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckSwitchStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            var expressionType = this.resolveAST(ast.expression, false, context).type;
+
+            for (var i = 0, n = ast.switchClauses.childCount(); i < n; i++) {
+                var switchClause = ast.switchClauses.childAt(i);
+                if (switchClause.kind() === 233 /* CaseSwitchClause */) {
+                    var caseSwitchClause = switchClause;
+
+                    var caseClauseExpressionType = this.resolveAST(caseSwitchClause.expression, false, context).type;
+                    this.resolveAST(caseSwitchClause.statements, false, context);
+
+                    var comparisonInfo = new TypeComparisonInfo();
+                    if (!this.sourceIsAssignableToTarget(expressionType, caseClauseExpressionType, caseSwitchClause.expression, context, comparisonInfo) && !this.sourceIsAssignableToTarget(caseClauseExpressionType, expressionType, caseSwitchClause.expression, context, comparisonInfo)) {
+                        var enclosingSymbol = this.getEnclosingSymbolForAST(caseSwitchClause.expression);
+                        if (comparisonInfo.message) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(caseSwitchClause.expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [caseClauseExpressionType.toString(enclosingSymbol), expressionType.toString(enclosingSymbol), comparisonInfo.message]));
+                        } else {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(caseSwitchClause.expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [caseClauseExpressionType.toString(enclosingSymbol), expressionType.toString(enclosingSymbol)]));
+                        }
+                    }
+                } else {
+                    var defaultSwitchClause = switchClause;
+                    this.resolveAST(defaultSwitchClause.statements, false, context);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveLabeledStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckLabeledStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckLabeledStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            var labelIdentifier = ast.identifier.valueText();
+
+            var breakableLabels = this.getEnclosingLabels(ast, true, false);
+
+            var matchingLabel = TypeScript.ArrayUtilities.firstOrDefault(breakableLabels, function (s) {
+                return s.identifier.valueText() === labelIdentifier;
+            });
+            if (matchingLabel) {
+                context.postDiagnostic(this.semanticInfoChain.duplicateIdentifierDiagnosticFromAST(ast.identifier, labelIdentifier, matchingLabel));
+            }
+
+            this.resolveAST(ast.statement, false, context);
+        };
+
+        PullTypeResolver.prototype.labelIsOnContinuableConstruct = function (statement) {
+            switch (statement.kind()) {
+                case 160 /* LabeledStatement */:
+                    return this.labelIsOnContinuableConstruct(statement.statement);
+
+                case 158 /* WhileStatement */:
+                case 154 /* ForStatement */:
+                case 155 /* ForInStatement */:
+                case 161 /* DoStatement */:
+                    return true;
+
+                default:
+                    return false;
+            }
+        };
+
+        PullTypeResolver.prototype.resolveContinueStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckContinueStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.isIterationStatement = function (ast) {
+            switch (ast.kind()) {
+                case 154 /* ForStatement */:
+                case 155 /* ForInStatement */:
+                case 158 /* WhileStatement */:
+                case 161 /* DoStatement */:
+                    return true;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.isAnyFunctionExpressionOrDeclaration = function (ast) {
+            switch (ast.kind()) {
+                case 219 /* SimpleArrowFunctionExpression */:
+                case 218 /* ParenthesizedArrowFunctionExpression */:
+                case 222 /* FunctionExpression */:
+                case 129 /* FunctionDeclaration */:
+                case 135 /* MemberFunctionDeclaration */:
+                case 241 /* FunctionPropertyAssignment */:
+                case 137 /* ConstructorDeclaration */:
+                case 139 /* GetAccessor */:
+                case 140 /* SetAccessor */:
+                    return true;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.inSwitchStatement = function (ast) {
+            while (ast) {
+                if (ast.kind() === 151 /* SwitchStatement */) {
+                    return true;
+                }
+
+                if (this.isAnyFunctionExpressionOrDeclaration(ast)) {
+                    return false;
+                }
+
+                ast = ast.parent;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.inIterationStatement = function (ast, crossFunctions) {
+            while (ast) {
+                if (this.isIterationStatement(ast)) {
+                    return true;
+                }
+
+                if (!crossFunctions && this.isAnyFunctionExpressionOrDeclaration(ast)) {
+                    return false;
+                }
+
+                ast = ast.parent;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.getEnclosingLabels = function (ast, breakable, crossFunctions) {
+            var result = [];
+
+            ast = ast.parent;
+            while (ast) {
+                if (ast.kind() === 160 /* LabeledStatement */) {
+                    var labeledStatement = ast;
+                    if (breakable) {
+                        result.push(labeledStatement);
+                    } else {
+                        if (this.labelIsOnContinuableConstruct(labeledStatement.statement)) {
+                            result.push(labeledStatement);
+                        }
+                    }
+                }
+
+                if (!crossFunctions && this.isAnyFunctionExpressionOrDeclaration(ast)) {
+                    break;
+                }
+
+                ast = ast.parent;
+            }
+
+            return result;
+        };
+
+        PullTypeResolver.prototype.typeCheckContinueStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            if (!this.inIterationStatement(ast, false)) {
+                if (this.inIterationStatement(ast, true)) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_cannot_cross_function_boundary));
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.continue_statement_can_only_be_used_within_an_enclosing_iteration_statement));
+                }
+            } else if (ast.identifier) {
+                var continuableLabels = this.getEnclosingLabels(ast, false, false);
+
+                if (!TypeScript.ArrayUtilities.any(continuableLabels, function (s) {
+                    return s.identifier.valueText() === ast.identifier.valueText();
+                })) {
+                    var continuableLabels = this.getEnclosingLabels(ast, false, true);
+
+                    if (TypeScript.ArrayUtilities.any(continuableLabels, function (s) {
+                        return s.identifier.valueText() === ast.identifier.valueText();
+                    })) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_cannot_cross_function_boundary));
+                    } else {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_not_found));
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveBreakStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckBreakStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckBreakStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            if (ast.identifier) {
+                var breakableLabels = this.getEnclosingLabels(ast, true, false);
+
+                if (!TypeScript.ArrayUtilities.any(breakableLabels, function (s) {
+                    return s.identifier.valueText() === ast.identifier.valueText();
+                })) {
+                    var breakableLabels = this.getEnclosingLabels(ast, true, true);
+                    if (TypeScript.ArrayUtilities.any(breakableLabels, function (s) {
+                        return s.identifier.valueText() === ast.identifier.valueText();
+                    })) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_cannot_cross_function_boundary));
+                    } else {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_not_found));
+                    }
+                }
+            } else if (!this.inIterationStatement(ast, false) && !this.inSwitchStatement(ast)) {
+                if (this.inIterationStatement(ast, true)) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_cannot_cross_function_boundary));
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveAST = function (ast, isContextuallyTyped, context) {
+            if (!ast) {
+                return;
+            }
+
+            var symbol = this.getSymbolForAST(ast, context);
+            if (symbol && symbol.isResolved) {
+                this.typeCheckAST(ast, isContextuallyTyped, context);
+                return symbol;
+            }
+
+            if (ast.isExpression() && !isTypesOnlyLocation(ast)) {
+                return this.resolveExpressionAST(ast, isContextuallyTyped, context);
+            }
+
+            var nodeType = ast.kind();
+
+            switch (nodeType) {
+                case 124 /* ArrayType */:
+                case 126 /* GenericType */:
+                case 122 /* ObjectType */:
+                case 127 /* TypeQuery */:
+                case 125 /* ConstructorType */:
+                case 123 /* FunctionType */:
+                    return this.resolveTypeReference(ast, context);
+
+                case 1 /* List */:
+                    return this.resolveList(ast, context);
+
+                case 2 /* SeparatedList */:
+                    return this.resolveSeparatedList(ast, context);
+
+                case 120 /* SourceUnit */:
+                    return this.resolveSourceUnit(ast, context);
+
+                case 132 /* EnumDeclaration */:
+                    return this.resolveEnumDeclaration(ast, context);
+
+                case 130 /* ModuleDeclaration */:
+                    return this.resolveModuleDeclaration(ast, context);
+
+                case 128 /* InterfaceDeclaration */:
+                    return this.resolveInterfaceDeclaration(ast, context);
+
+                case 131 /* ClassDeclaration */:
+                    return this.resolveClassDeclaration(ast, context);
+
+                case 224 /* VariableDeclaration */:
+                    return this.resolveVariableDeclarationList(ast, context);
+
+                case 136 /* MemberVariableDeclaration */:
+                    return this.resolveMemberVariableDeclaration(ast, context);
+
+                case 225 /* VariableDeclarator */:
+                    return this.resolveVariableDeclarator(ast, context);
+
+                case 141 /* PropertySignature */:
+                    return this.resolvePropertySignature(ast, context);
+
+                case 227 /* ParameterList */:
+                    return this.resolveParameterList(ast, context);
+
+                case 242 /* Parameter */:
+                    return this.resolveParameter(ast, context);
+
+                case 243 /* EnumElement */:
+                    return this.resolveEnumElement(ast, context);
+
+                case 232 /* EqualsValueClause */:
+                    return this.resolveEqualsValueClause(ast, isContextuallyTyped, context);
+
+                case 238 /* TypeParameter */:
+                    return this.resolveTypeParameterDeclaration(ast, context);
+
+                case 239 /* Constraint */:
+                    return this.resolveConstraint(ast, context);
+
+                case 133 /* ImportDeclaration */:
+                    return this.resolveImportDeclaration(ast, context);
+
+                case 240 /* SimplePropertyAssignment */:
+                    return this.resolveSimplePropertyAssignment(ast, isContextuallyTyped, context);
+
+                case 241 /* FunctionPropertyAssignment */:
+                    return this.resolveFunctionPropertyAssignment(ast, isContextuallyTyped, context);
+
+                case 11 /* IdentifierName */:
+                    TypeScript.Debug.assert(isTypesOnlyLocation(ast));
+                    return this.resolveTypeNameExpression(ast, context);
+
+                case 121 /* QualifiedName */:
+                    return this.resolveQualifiedName(ast, context);
+
+                case 137 /* ConstructorDeclaration */:
+                    return this.resolveConstructorDeclaration(ast, context);
+
+                case 139 /* GetAccessor */:
+                case 140 /* SetAccessor */:
+                    return this.resolveAccessorDeclaration(ast, context);
+
+                case 138 /* IndexMemberDeclaration */:
+                    return this.resolveIndexMemberDeclaration(ast, context);
+
+                case 144 /* IndexSignature */:
+                    return this.resolveIndexSignature(ast, context);
+
+                case 135 /* MemberFunctionDeclaration */:
+                    return this.resolveMemberFunctionDeclaration(ast, context);
+
+                case 142 /* CallSignature */:
+                    return this.resolveCallSignature(ast, context);
+
+                case 143 /* ConstructSignature */:
+                    return this.resolveConstructSignature(ast, context);
+
+                case 145 /* MethodSignature */:
+                    return this.resolveMethodSignature(ast, context);
+
+                case 129 /* FunctionDeclaration */:
+                    return this.resolveAnyFunctionDeclaration(ast, context);
+
+                case 244 /* TypeAnnotation */:
+                    return this.resolveTypeAnnotation(ast, context);
+
+                case 134 /* ExportAssignment */:
+                    return this.resolveExportAssignmentStatement(ast, context);
+
+                case 157 /* ThrowStatement */:
+                    return this.resolveThrowStatement(ast, context);
+
+                case 149 /* ExpressionStatement */:
+                    return this.resolveExpressionStatement(ast, context);
+
+                case 154 /* ForStatement */:
+                    return this.resolveForStatement(ast, context);
+
+                case 155 /* ForInStatement */:
+                    return this.resolveForInStatement(ast, context);
+
+                case 158 /* WhileStatement */:
+                    return this.resolveWhileStatement(ast, context);
+
+                case 161 /* DoStatement */:
+                    return this.resolveDoStatement(ast, context);
+
+                case 147 /* IfStatement */:
+                    return this.resolveIfStatement(ast, context);
+
+                case 235 /* ElseClause */:
+                    return this.resolveElseClause(ast, context);
+
+                case 146 /* Block */:
+                    return this.resolveBlock(ast, context);
+
+                case 148 /* VariableStatement */:
+                    return this.resolveVariableStatement(ast, context);
+
+                case 163 /* WithStatement */:
+                    return this.resolveWithStatement(ast, context);
+
+                case 159 /* TryStatement */:
+                    return this.resolveTryStatement(ast, context);
+
+                case 236 /* CatchClause */:
+                    return this.resolveCatchClause(ast, context);
+
+                case 237 /* FinallyClause */:
+                    return this.resolveFinallyClause(ast, context);
+
+                case 150 /* ReturnStatement */:
+                    return this.resolveReturnStatement(ast, context);
+
+                case 151 /* SwitchStatement */:
+                    return this.resolveSwitchStatement(ast, context);
+
+                case 153 /* ContinueStatement */:
+                    return this.resolveContinueStatement(ast, context);
+
+                case 152 /* BreakStatement */:
+                    return this.resolveBreakStatement(ast, context);
+
+                case 160 /* LabeledStatement */:
+                    return this.resolveLabeledStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.anyTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveExpressionAST = function (ast, isContextuallyOrInferentiallyTyped, context) {
+            var expressionSymbol = this.resolveExpressionWorker(ast, isContextuallyOrInferentiallyTyped, context);
+
+            if (isContextuallyOrInferentiallyTyped && context.isInferentiallyTyping()) {
+                return this.alterPotentialGenericFunctionTypeToInstantiatedFunctionTypeForTypeArgumentInference(expressionSymbol, context);
+            } else {
+                return expressionSymbol;
+            }
+        };
+
+        PullTypeResolver.prototype.resolveExpressionWorker = function (ast, isContextuallyTyped, context) {
+            switch (ast.kind()) {
+                case 215 /* ObjectLiteralExpression */:
+                    return this.resolveObjectLiteralExpression(ast, isContextuallyTyped, context);
+
+                case 11 /* IdentifierName */:
+                    return this.resolveNameExpression(ast, context);
+
+                case 212 /* MemberAccessExpression */:
+                    return this.resolveMemberAccessExpression(ast, context);
+
+                case 222 /* FunctionExpression */:
+                    return this.resolveFunctionExpression(ast, isContextuallyTyped, context);
+
+                case 219 /* SimpleArrowFunctionExpression */:
+                    return this.resolveSimpleArrowFunctionExpression(ast, isContextuallyTyped, context);
+
+                case 218 /* ParenthesizedArrowFunctionExpression */:
+                    return this.resolveParenthesizedArrowFunctionExpression(ast, isContextuallyTyped, context);
+
+                case 214 /* ArrayLiteralExpression */:
+                    return this.resolveArrayLiteralExpression(ast, isContextuallyTyped, context);
+
+                case 35 /* ThisKeyword */:
+                    return this.resolveThisExpression(ast, context);
+
+                case 50 /* SuperKeyword */:
+                    return this.resolveSuperExpression(ast, context);
+
+                case 213 /* InvocationExpression */:
+                    return this.resolveInvocationExpression(ast, context);
+
+                case 216 /* ObjectCreationExpression */:
+                    return this.resolveObjectCreationExpression(ast, context);
+
+                case 220 /* CastExpression */:
+                    return this.resolveCastExpression(ast, context);
+
+                case 13 /* NumericLiteral */:
+                    return this.semanticInfoChain.numberTypeSymbol;
+
+                case 14 /* StringLiteral */:
+                    return this.semanticInfoChain.stringTypeSymbol;
+
+                case 32 /* NullKeyword */:
+                    return this.semanticInfoChain.nullTypeSymbol;
+
+                case 37 /* TrueKeyword */:
+                case 24 /* FalseKeyword */:
+                    return this.semanticInfoChain.booleanTypeSymbol;
+
+                case 172 /* VoidExpression */:
+                    return this.resolveVoidExpression(ast, context);
+
+                case 174 /* AssignmentExpression */:
+                    return this.resolveAssignmentExpression(ast, context);
+
+                case 167 /* LogicalNotExpression */:
+                    return this.resolveLogicalNotExpression(ast, context);
+
+                case 193 /* NotEqualsWithTypeConversionExpression */:
+                case 192 /* EqualsWithTypeConversionExpression */:
+                case 194 /* EqualsExpression */:
+                case 195 /* NotEqualsExpression */:
+                case 196 /* LessThanExpression */:
+                case 198 /* LessThanOrEqualExpression */:
+                case 199 /* GreaterThanOrEqualExpression */:
+                case 197 /* GreaterThanExpression */:
+                    return this.resolveLogicalOperation(ast, context);
+
+                case 208 /* AddExpression */:
+                case 175 /* AddAssignmentExpression */:
+                    return this.resolveBinaryAdditionOperation(ast, context);
+
+                case 164 /* PlusExpression */:
+                case 165 /* NegateExpression */:
+                case 166 /* BitwiseNotExpression */:
+                case 168 /* PreIncrementExpression */:
+                case 169 /* PreDecrementExpression */:
+                    return this.resolveUnaryArithmeticOperation(ast, context);
+
+                case 210 /* PostIncrementExpression */:
+                case 211 /* PostDecrementExpression */:
+                    return this.resolvePostfixUnaryExpression(ast, context);
+
+                case 209 /* SubtractExpression */:
+                case 205 /* MultiplyExpression */:
+                case 206 /* DivideExpression */:
+                case 207 /* ModuloExpression */:
+                case 189 /* BitwiseOrExpression */:
+                case 191 /* BitwiseAndExpression */:
+                case 202 /* LeftShiftExpression */:
+                case 203 /* SignedRightShiftExpression */:
+                case 204 /* UnsignedRightShiftExpression */:
+                case 190 /* BitwiseExclusiveOrExpression */:
+                case 181 /* ExclusiveOrAssignmentExpression */:
+                case 183 /* LeftShiftAssignmentExpression */:
+                case 184 /* SignedRightShiftAssignmentExpression */:
+                case 185 /* UnsignedRightShiftAssignmentExpression */:
+                case 176 /* SubtractAssignmentExpression */:
+                case 177 /* MultiplyAssignmentExpression */:
+                case 178 /* DivideAssignmentExpression */:
+                case 179 /* ModuloAssignmentExpression */:
+                case 182 /* OrAssignmentExpression */:
+                case 180 /* AndAssignmentExpression */:
+                    return this.resolveBinaryArithmeticExpression(ast, context);
+
+                case 221 /* ElementAccessExpression */:
+                    return this.resolveElementAccessExpression(ast, context);
+
+                case 187 /* LogicalOrExpression */:
+                    return this.resolveLogicalOrExpression(ast, isContextuallyTyped, context);
+
+                case 188 /* LogicalAndExpression */:
+                    return this.resolveLogicalAndExpression(ast, context);
+
+                case 171 /* TypeOfExpression */:
+                    return this.resolveTypeOfExpression(ast, context);
+
+                case 170 /* DeleteExpression */:
+                    return this.resolveDeleteExpression(ast, context);
+
+                case 186 /* ConditionalExpression */:
+                    return this.resolveConditionalExpression(ast, isContextuallyTyped, context);
+
+                case 12 /* RegularExpressionLiteral */:
+                    return this.resolveRegularExpressionLiteral();
+
+                case 217 /* ParenthesizedExpression */:
+                    return this.resolveParenthesizedExpression(ast, context);
+
+                case 200 /* InstanceOfExpression */:
+                    return this.resolveInstanceOfExpression(ast, context);
+
+                case 173 /* CommaExpression */:
+                    return this.resolveCommaExpression(ast, context);
+
+                case 201 /* InExpression */:
+                    return this.resolveInExpression(ast, context);
+
+                case 223 /* OmittedExpression */:
+                    return this.semanticInfoChain.undefinedTypeSymbol;
+            }
+
+            TypeScript.Debug.fail("resolveExpressionASTWorker: Missing expression kind: " + TypeScript.SyntaxKind[ast.kind()]);
+        };
+
+        PullTypeResolver.prototype.typeCheckAST = function (ast, isContextuallyTyped, context) {
+            if (!this.canTypeCheckAST(ast, context)) {
+                return;
+            }
+
+            var nodeType = ast.kind();
+            switch (nodeType) {
+                case 120 /* SourceUnit */:
+                    this.typeCheckSourceUnit(ast, context);
+                    return;
+
+                case 132 /* EnumDeclaration */:
+                    this.typeCheckEnumDeclaration(ast, context);
+                    return;
+
+                case 130 /* ModuleDeclaration */:
+                    this.typeCheckModuleDeclaration(ast, context);
+                    return;
+
+                case 128 /* InterfaceDeclaration */:
+                    this.typeCheckInterfaceDeclaration(ast, context);
+                    return;
+
+                case 131 /* ClassDeclaration */:
+                    this.typeCheckClassDeclaration(ast, context);
+                    return;
+
+                case 243 /* EnumElement */:
+                    this.typeCheckEnumElement(ast, context);
+                    return;
+
+                case 136 /* MemberVariableDeclaration */:
+                    this.typeCheckMemberVariableDeclaration(ast, context);
+                    return;
+
+                case 225 /* VariableDeclarator */:
+                    this.typeCheckVariableDeclarator(ast, context);
+                    return;
+
+                case 141 /* PropertySignature */:
+                    this.typeCheckPropertySignature(ast, context);
+                    return;
+
+                case 242 /* Parameter */:
+                    this.typeCheckParameter(ast, context);
+                    return;
+
+                case 133 /* ImportDeclaration */:
+                    this.typeCheckImportDeclaration(ast, context);
+                    return;
+
+                case 215 /* ObjectLiteralExpression */:
+                    this.resolveObjectLiteralExpression(ast, isContextuallyTyped, context);
+                    return;
+
+                case 241 /* FunctionPropertyAssignment */:
+                    this.typeCheckFunctionPropertyAssignment(ast, isContextuallyTyped, context);
+                    return;
+
+                case 11 /* IdentifierName */:
+                    if (isTypesOnlyLocation(ast)) {
+                        this.resolveTypeNameExpression(ast, context);
+                    } else {
+                        this.resolveNameExpression(ast, context);
+                    }
+                    return;
+
+                case 212 /* MemberAccessExpression */:
+                    this.resolveMemberAccessExpression(ast, context);
+                    return;
+
+                case 121 /* QualifiedName */:
+                    this.resolveQualifiedName(ast, context);
+                    return;
+
+                case 222 /* FunctionExpression */:
+                    this.typeCheckFunctionExpression(ast, isContextuallyTyped, context);
+                    return;
+
+                case 137 /* ConstructorDeclaration */:
+                    this.typeCheckConstructorDeclaration(ast, context);
+                    return;
+
+                case 139 /* GetAccessor */:
+                case 140 /* SetAccessor */:
+                    this.typeCheckAccessorDeclaration(ast, context);
+                    return;
+
+                case 135 /* MemberFunctionDeclaration */:
+                    this.typeCheckMemberFunctionDeclaration(ast, context);
+                    return;
+
+                case 145 /* MethodSignature */:
+                    this.typeCheckMethodSignature(ast, context);
+                    return;
+
+                case 144 /* IndexSignature */:
+                    this.typeCheckIndexSignature(ast, context);
+                    break;
+
+                case 142 /* CallSignature */:
+                    this.typeCheckCallSignature(ast, context);
+                    return;
+
+                case 143 /* ConstructSignature */:
+                    this.typeCheckConstructSignature(ast, context);
+                    return;
+
+                case 129 /* FunctionDeclaration */: {
+                    var funcDecl = ast;
+                    this.typeCheckAnyFunctionDeclaration(funcDecl, TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */), funcDecl.identifier, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), funcDecl.block, context);
+                    return;
+                }
+
+                case 219 /* SimpleArrowFunctionExpression */:
+                    this.typeCheckSimpleArrowFunctionExpression(ast, isContextuallyTyped, context);
+                    return;
+
+                case 218 /* ParenthesizedArrowFunctionExpression */:
+                    this.typeCheckParenthesizedArrowFunctionExpression(ast, isContextuallyTyped, context);
+                    return;
+
+                case 214 /* ArrayLiteralExpression */:
+                    this.resolveArrayLiteralExpression(ast, isContextuallyTyped, context);
+                    return;
+
+                case 213 /* InvocationExpression */:
+                    this.typeCheckInvocationExpression(ast, context);
+                    return;
+
+                case 216 /* ObjectCreationExpression */:
+                    this.typeCheckObjectCreationExpression(ast, context);
+                    return;
+
+                case 150 /* ReturnStatement */:
+                    this.resolveReturnStatement(ast, context);
+                    return;
+
+                default:
+                    TypeScript.Debug.assert(false, "Failure nodeType: " + TypeScript.SyntaxKind[ast.kind()] + ". Implement typeCheck when symbol is set for the ast as part of resolution.");
+            }
+        };
+
+        PullTypeResolver.prototype.processPostTypeCheckWorkItems = function (context) {
+            while (this.postTypeCheckWorkitems.length) {
+                var ast = this.postTypeCheckWorkitems.pop();
+                this.postTypeCheck(ast, context);
+            }
+        };
+
+        PullTypeResolver.prototype.postTypeCheck = function (ast, context) {
+            var nodeType = ast.kind();
+
+            switch (nodeType) {
+                case 242 /* Parameter */:
+                case 225 /* VariableDeclarator */:
+                    this.postTypeCheckVariableDeclaratorOrParameter(ast, context);
+                    return;
+
+                case 131 /* ClassDeclaration */:
+                    this.postTypeCheckClassDeclaration(ast, context);
+                    return;
+
+                case 129 /* FunctionDeclaration */:
+                    this.postTypeCheckFunctionDeclaration(ast, context);
+                    return;
+
+                case 130 /* ModuleDeclaration */:
+                    this.postTypeCheckModuleDeclaration(ast, context);
+                    return;
+
+                case 132 /* EnumDeclaration */:
+                    this.postTypeCheckEnumDeclaration(ast, context);
+                    return;
+
+                case 133 /* ImportDeclaration */:
+                    this.postTypeCheckImportDeclaration(ast, context);
+                    return;
+
+                case 11 /* IdentifierName */:
+                    this.postTypeCheckNameExpression(ast, context);
+                    return;
+
+                default:
+                    TypeScript.Debug.assert(false, "Implement postTypeCheck clause to handle the postTypeCheck work, nodeType: " + TypeScript.SyntaxKind[ast.kind()]);
+            }
+        };
+
+        PullTypeResolver.prototype.resolveRegularExpressionLiteral = function () {
+            if (this.cachedRegExpInterfaceType()) {
+                return this.cachedRegExpInterfaceType();
+            } else {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+        };
+
+        PullTypeResolver.prototype.postTypeCheckNameExpression = function (nameAST, context) {
+            this.checkThisCaptureVariableCollides(nameAST, false, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckNameExpression = function (nameAST, context) {
+            this.setTypeChecked(nameAST, context);
+            this.checkNameForCompilerGeneratedDeclarationCollision(nameAST, false, nameAST, context);
+        };
+
+        PullTypeResolver.prototype.resolveNameExpression = function (nameAST, context) {
+            var nameSymbol = this.getSymbolForAST(nameAST, context);
+            var foundCached = nameSymbol !== null;
+
+            if (!foundCached || this.canTypeCheckAST(nameAST, context)) {
+                if (this.canTypeCheckAST(nameAST, context)) {
+                    this.typeCheckNameExpression(nameAST, context);
+                }
+                nameSymbol = this.computeNameExpression(nameAST, context);
+            }
+
+            this.resolveDeclaredSymbol(nameSymbol, context);
+
+            if (nameSymbol && (nameSymbol.type !== this.semanticInfoChain.anyTypeSymbol || nameSymbol.anyDeclHasFlag(16777216 /* IsAnnotatedWithAny */ | 1 /* Exported */))) {
+                this.setSymbolForAST(nameAST, nameSymbol, context);
+            }
+
+            return nameSymbol;
+        };
+
+        PullTypeResolver.prototype.isInEnumDecl = function (decl) {
+            if (decl.kind & 64 /* Enum */) {
+                return true;
+            }
+
+            var declPath = decl.getParentPath();
+
+            var disallowedKinds = 164 /* SomeContainer */ | 58728795 /* SomeType */;
+            for (var i = declPath.length - 1; i >= 0; i--) {
+                var decl = declPath[i];
+
+                if (decl.kind & 64 /* Enum */) {
+                    return true;
+                }
+
+                if (decl.kind & disallowedKinds) {
+                    return false;
+                }
+            }
+            return false;
+        };
+
+        PullTypeResolver.prototype.getSomeInnermostFunctionScopeDecl = function (declPath) {
+            for (var i = declPath.length - 1; i >= 0; i--) {
+                var decl = declPath[i];
+                if (decl.kind & 1032192 /* SomeFunction */) {
+                    return decl;
+                }
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.isFromFunctionScope = function (nameSymbol, functionScopeDecl) {
+            var _this = this;
+            return TypeScript.ArrayUtilities.any(nameSymbol.getDeclarations(), function (nameSymbolDecl) {
+                return _this.getSomeInnermostFunctionScopeDecl(nameSymbolDecl.getParentPath()) === functionScopeDecl;
+            });
+        };
+
+        PullTypeResolver.prototype.findConstructorDeclOfEnclosingType = function (decl) {
+            var current = decl;
+            while (current) {
+                if (TypeScript.hasFlag(current.kind, 4096 /* Property */)) {
+                    var parentDecl = current.getParentDecl();
+                    if (TypeScript.hasFlag(parentDecl.kind, 8 /* Class */)) {
+                        return TypeScript.ArrayUtilities.lastOrDefault(parentDecl.getChildDecls(), function (decl) {
+                            return TypeScript.hasFlag(decl.kind, 32768 /* ConstructorMethod */);
+                        });
+                    }
+                }
+
+                if (TypeScript.hasFlag(current.kind, 164 /* SomeContainer */)) {
+                    return null;
+                }
+
+                current = current.getParentDecl();
+            }
+            return null;
+        };
+
+        PullTypeResolver.prototype.checkNameAsPartOfInitializerExpressionForInstanceMemberVariable = function (nameAST, nameSymbol, context) {
+            var id = nameAST.valueText();
+            if (id.length === 0) {
+                return false;
+            }
+
+            var memberVariableDeclarationAST = TypeScript.ASTHelpers.getEnclosingMemberVariableDeclaration(nameAST);
+            if (memberVariableDeclarationAST) {
+                var memberVariableDecl = this.semanticInfoChain.getDeclForAST(memberVariableDeclarationAST);
+                if (!TypeScript.hasFlag(memberVariableDecl.flags, 16 /* Static */)) {
+                    var constructorDecl = this.findConstructorDeclOfEnclosingType(memberVariableDecl);
+
+                    if (constructorDecl) {
+                        var childDecls = constructorDecl.searchChildDecls(id, 68147712 /* SomeValue */);
+                        if (childDecls.length) {
+                            if (TypeScript.PullHelpers.isSymbolDeclaredInScopeChain(nameSymbol, constructorDecl.getSymbol().getContainer())) {
+                                var memberVariableSymbol = memberVariableDecl.getSymbol();
+
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, [memberVariableSymbol.getScopedName(constructorDecl.getSymbol()), nameAST.text()]));
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+            return false;
+        };
+
+        PullTypeResolver.prototype.computeNameExpression = function (nameAST, context) {
+            var id = nameAST.valueText();
+            if (id.length === 0) {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var nameSymbol = null;
+            var enclosingDecl = this.getEnclosingDeclForAST(nameAST);
+
+            if (TypeScript.hasFlag(enclosingDecl.flags, 8388608 /* PropertyParameter */)) {
+                var valueDecl = enclosingDecl.getValueDecl();
+                if (valueDecl && TypeScript.hasFlag(valueDecl.kind, 2048 /* Parameter */)) {
+                    enclosingDecl = valueDecl;
+                }
+            }
+
+            var isDeclarationASTOrDeclarationNameAST = TypeScript.ASTHelpers.isDeclarationASTOrDeclarationNameAST(nameAST);
+            if (isDeclarationASTOrDeclarationNameAST) {
+                nameSymbol = this.semanticInfoChain.getDeclForAST(nameAST.parent).getSymbol();
+            }
+
+            var declPath = enclosingDecl.getParentPath();
+
+            if (!nameSymbol) {
+                var searchKind = 68147712 /* SomeValue */;
+
+                if (!this.isInEnumDecl(enclosingDecl)) {
+                    searchKind = searchKind & ~(67108864 /* EnumMember */);
+                }
+
+                var nameSymbol = this.getSymbolFromDeclPath(id, declPath, searchKind);
+            }
+
+            if (id === "arguments") {
+                var functionScopeDecl = this.getSomeInnermostFunctionScopeDecl(declPath);
+                if (functionScopeDecl) {
+                    if (!nameSymbol || !this.isFromFunctionScope(nameSymbol, functionScopeDecl)) {
+                        nameSymbol = this.cachedFunctionArgumentsSymbol();
+                        this.resolveDeclaredSymbol(this.cachedIArgumentsInterfaceType(), context);
+                    }
+                }
+            }
+
+            var aliasSymbol = null;
+            if (nameSymbol && nameSymbol.isAlias() && !isDeclarationASTOrDeclarationNameAST) {
+                aliasSymbol = nameSymbol;
+                if (!this.inTypeQuery(nameAST)) {
+                    aliasSymbol.setIsUsedAsValue();
+                }
+
+                this.resolveDeclaredSymbol(nameSymbol, context);
+
+                this.resolveDeclaredSymbol(aliasSymbol.assignedValue(), context);
+                this.resolveDeclaredSymbol(aliasSymbol.assignedContainer(), context);
+
+                nameSymbol = aliasSymbol.getExportAssignedValueSymbol();
+                if (!nameSymbol) {
+                    aliasSymbol = null;
+                }
+            }
+
+            if (!nameSymbol) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Could_not_find_symbol_0, [nameAST.text()]));
+                return this.getNewErrorTypeSymbol(id);
+            } else if (this.checkNameAsPartOfInitializerExpressionForInstanceMemberVariable(nameAST, nameSymbol, context)) {
+                return this.getNewErrorTypeSymbol(id);
+            }
+
+            var nameDeclaration = nameSymbol.getDeclarations()[0];
+            var nameParentDecl = nameDeclaration.getParentDecl();
+            if (nameParentDecl && (nameParentDecl.kind & 1032192 /* SomeFunction */) && (nameParentDecl.flags & 33554432 /* HasDefaultArgs */)) {
+                var enclosingFunctionAST = this.semanticInfoChain.getASTForDecl(nameParentDecl);
+                var currentParameterIndex = this.getCurrentParameterIndexForFunction(nameAST, enclosingFunctionAST);
+
+                var parameterList = TypeScript.ASTHelpers.getParameterList(enclosingFunctionAST);
+
+                if (currentParameterIndex >= 0) {
+                    var matchingParameter;
+                    if (parameterList) {
+                        for (var i = 0; i <= currentParameterIndex; i++) {
+                            var candidateParameter = parameterList.parameters.nonSeparatorAt(i);
+                            if (candidateParameter && candidateParameter.identifier.valueText() === id) {
+                                matchingParameter = candidateParameter;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (!matchingParameter) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it, [parameterList.parameters.nonSeparatorAt(currentParameterIndex).identifier.text(), nameAST.text()]));
+                        return this.getNewErrorTypeSymbol(id);
+                    } else if (matchingParameter === TypeScript.ASTHelpers.getEnclosingParameterForInitializer(nameAST)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Parameter_0_cannot_be_referenced_in_its_initializer, [parameterList.parameters.nonSeparatorAt(currentParameterIndex).identifier.text()]));
+                        return this.getNewErrorTypeSymbol(id);
+                    }
+                }
+            }
+
+            if (aliasSymbol) {
+                this.semanticInfoChain.setAliasSymbolForAST(nameAST, aliasSymbol);
+            }
+
+            return nameSymbol;
+        };
+
+        PullTypeResolver.prototype.getCurrentParameterIndexForFunction = function (parameter, funcDecl) {
+            var parameterList = TypeScript.ASTHelpers.getParameterList(funcDecl);
+            if (parameterList) {
+                while (parameter && parameter.parent) {
+                    if (parameter.parent.parent === parameterList) {
+                        return parameterList.parameters.nonSeparatorIndexOf(parameter);
+                    }
+
+                    parameter = parameter.parent;
+                }
+            }
+
+            return -1;
+        };
+
+        PullTypeResolver.prototype.resolveMemberAccessExpression = function (dottedNameAST, context) {
+            return this.resolveDottedNameExpression(dottedNameAST, dottedNameAST.expression, dottedNameAST.name, context);
+        };
+
+        PullTypeResolver.prototype.resolveDottedNameExpression = function (dottedNameAST, expression, name, context) {
+            var symbol = this.getSymbolForAST(dottedNameAST, context);
+            var foundCached = symbol !== null;
+
+            if (!foundCached || this.canTypeCheckAST(dottedNameAST, context)) {
+                var canTypeCheckDottedNameAST = this.canTypeCheckAST(dottedNameAST, context);
+                if (canTypeCheckDottedNameAST) {
+                    this.setTypeChecked(dottedNameAST, context);
+                }
+
+                symbol = this.computeDottedNameExpression(expression, name, context, canTypeCheckDottedNameAST);
+            }
+
+            this.resolveDeclaredSymbol(symbol, context);
+
+            if (symbol && (symbol.type !== this.semanticInfoChain.anyTypeSymbol || symbol.anyDeclHasFlag(16777216 /* IsAnnotatedWithAny */ | 1 /* Exported */))) {
+                this.setSymbolForAST(dottedNameAST, symbol, context);
+                this.setSymbolForAST(name, symbol, context);
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.computeDottedNameExpression = function (expression, name, context, checkSuperPrivateAndStaticAccess) {
+            var rhsName = name.valueText();
+            if (rhsName.length === 0) {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var lhs = this.resolveAST(expression, false, context);
+            return this.computeDottedNameExpressionFromLHS(lhs, expression, name, context, checkSuperPrivateAndStaticAccess);
+        };
+
+        PullTypeResolver.prototype.computeDottedNameExpressionFromLHS = function (lhs, expression, name, context, checkSuperPrivateAndStaticAccess) {
+            var rhsName = name.valueText();
+            if (rhsName.length === 0) {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var lhsType = lhs.type;
+
+            if (lhs.isAlias()) {
+                var lhsAlias = lhs;
+                if (!this.inTypeQuery(expression)) {
+                    lhsAlias.setIsUsedAsValue();
+                }
+                lhsType = lhsAlias.getExportAssignedTypeSymbol();
+            }
+
+            if (lhsType.isAlias()) {
+                lhsType = lhsType.getExportAssignedTypeSymbol();
+            }
+
+            if (!lhsType) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode.Could_not_find_enclosing_symbol_for_dotted_name_0, [name.text()]));
+                return this.getNewErrorTypeSymbol();
+            }
+
+            if (!lhsType.isResolved) {
+                var potentiallySpecializedType = this.resolveDeclaredSymbol(lhsType, context);
+
+                if (potentiallySpecializedType !== lhsType) {
+                    if (!lhs.isType()) {
+                        context.setTypeInContext(lhs, potentiallySpecializedType);
+                    }
+
+                    lhsType = potentiallySpecializedType;
+                }
+            }
+
+            if (lhsType.isContainer() && !lhsType.isAlias() && !lhsType.isEnum()) {
+                var instanceSymbol = lhsType.getInstanceSymbol();
+
+                if (instanceSymbol) {
+                    lhsType = instanceSymbol.type;
+                }
+            }
+
+            var originalLhsTypeForErrorReporting = lhsType;
+
+            lhsType = this.getApparentType(lhsType).widenedType(this, expression, context);
+
+            if (this.isAnyOrEquivalent(lhsType)) {
+                return lhsType;
+            }
+
+            var nameSymbol = this._getNamedPropertySymbolOfAugmentedType(rhsName, lhsType);
+
+            if (!nameSymbol) {
+                if (lhsType.kind === 32 /* DynamicModule */) {
+                    var container = lhsType;
+                    var associatedInstance = container.getInstanceSymbol();
+
+                    if (associatedInstance) {
+                        var instanceType = associatedInstance.type;
+
+                        nameSymbol = this.getNamedPropertySymbol(rhsName, 68147712 /* SomeValue */, instanceType);
+                    }
+                } else {
+                    var associatedType = lhsType.getAssociatedContainerType();
+
+                    if (associatedType && !associatedType.isClass()) {
+                        nameSymbol = this.getNamedPropertySymbol(rhsName, 68147712 /* SomeValue */, associatedType);
+                    }
+                }
+
+                if (!nameSymbol) {
+                    var enclosingDecl = this.getEnclosingDeclForAST(expression);
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode.The_property_0_does_not_exist_on_value_of_type_1, [name.text(), originalLhsTypeForErrorReporting.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)]));
+                    return this.getNewErrorTypeSymbol(rhsName);
+                }
+            }
+
+            if (checkSuperPrivateAndStaticAccess) {
+                this.checkForSuperMemberAccess(expression, name, nameSymbol, context) || this.checkForPrivateMemberAccess(name, lhsType, nameSymbol, context);
+            }
+
+            return nameSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveTypeNameExpression = function (nameAST, context) {
+            var typeNameSymbol = this.getSymbolForAST(nameAST, context);
+
+            if (!typeNameSymbol || !typeNameSymbol.isType() || this.canTypeCheckAST(nameAST, context)) {
+                if (this.canTypeCheckAST(nameAST, context)) {
+                    this.setTypeChecked(nameAST, context);
+                }
+                typeNameSymbol = this.computeTypeNameExpression(nameAST, context);
+                this.setSymbolForAST(nameAST, typeNameSymbol, context);
+            }
+
+            this.resolveDeclaredSymbol(typeNameSymbol, context);
+
+            return typeNameSymbol;
+        };
+
+        PullTypeResolver.prototype.computeTypeNameExpression = function (nameAST, context) {
+            var id = nameAST.valueText();
+            if (id.length === 0) {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var enclosingDecl = this.getEnclosingDeclForAST(nameAST);
+
+            var declPath = enclosingDecl.getParentPath();
+
+            var onLeftOfDot = this.isLeftSideOfQualifiedName(nameAST);
+
+            var kindToCheckFirst = onLeftOfDot ? 164 /* SomeContainer */ : 58728795 /* SomeType */;
+            var kindToCheckSecond = onLeftOfDot ? 58728795 /* SomeType */ : 164 /* SomeContainer */;
+
+            var typeNameSymbol = this.getSymbolFromDeclPath(id, declPath, kindToCheckFirst);
+
+            if (!typeNameSymbol) {
+                typeNameSymbol = this.getSymbolFromDeclPath(id, declPath, kindToCheckSecond);
+            }
+
+            if (!typeNameSymbol) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Could_not_find_symbol_0, [nameAST.text()]));
+                return this.getNewErrorTypeSymbol(id);
+            }
+
+            var typeNameSymbolAlias = null;
+            if (typeNameSymbol.isAlias()) {
+                typeNameSymbolAlias = typeNameSymbol;
+                this.resolveDeclaredSymbol(typeNameSymbol, context);
+
+                var aliasedType = typeNameSymbolAlias.getExportAssignedTypeSymbol();
+
+                this.resolveDeclaredSymbol(aliasedType, context);
+            }
+
+            if (typeNameSymbol.isTypeParameter()) {
+                if (this.isInStaticMemberContext(enclosingDecl)) {
+                    var parentDecl = typeNameSymbol.getDeclarations()[0].getParentDecl();
+
+                    if (parentDecl.kind === 8 /* Class */) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Static_members_cannot_reference_class_type_parameters));
+                        return this.getNewErrorTypeSymbol();
+                    }
+                }
+            }
+
+            if (!typeNameSymbol.isGeneric() && (typeNameSymbol.isClass() || typeNameSymbol.isInterface())) {
+                typeNameSymbol = TypeScript.PullTypeReferenceSymbol.createTypeReference(typeNameSymbol);
+            }
+
+            return typeNameSymbol;
+        };
+
+        PullTypeResolver.prototype.isInStaticMemberContext = function (decl) {
+            while (decl) {
+                if (TypeScript.hasFlag(decl.kind, 1032192 /* SomeFunction */ | 4096 /* Property */) && TypeScript.hasFlag(decl.flags, 16 /* Static */)) {
+                    return true;
+                }
+
+                if (TypeScript.hasFlag(decl.kind, 164 /* SomeContainer */)) {
+                    return false;
+                }
+
+                decl = decl.getParentDecl();
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.isLeftSideOfQualifiedName = function (ast) {
+            return ast && ast.parent && ast.parent.kind() === 121 /* QualifiedName */ && ast.parent.left === ast;
+        };
+
+        PullTypeResolver.prototype.resolveGenericTypeReference = function (genericTypeAST, context) {
+            var _this = this;
+            var genericTypeSymbol = this.resolveAST(genericTypeAST.name, false, context).type;
+
+            if (genericTypeSymbol.isError()) {
+                return genericTypeSymbol;
+            }
+
+            if (!genericTypeSymbol.inResolution && !genericTypeSymbol.isResolved) {
+                this.resolveDeclaredSymbol(genericTypeSymbol, context);
+            }
+
+            if (genericTypeSymbol.isAlias()) {
+                if (this.inClassExtendsHeritageClause(genericTypeAST) && !this.inTypeArgumentList(genericTypeAST)) {
+                    genericTypeSymbol.setIsUsedAsValue();
+                }
+                genericTypeSymbol = genericTypeSymbol.getExportAssignedTypeSymbol();
+            }
+
+            var typeParameters = genericTypeSymbol.getTypeParameters();
+            if (typeParameters.length === 0) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(genericTypeAST, TypeScript.DiagnosticCode.Type_0_does_not_have_type_parameters, [genericTypeSymbol.toString()]));
+                return this.getNewErrorTypeSymbol();
+            }
+
+            var typeArgs = [];
+
+            if (genericTypeAST.typeArgumentList && genericTypeAST.typeArgumentList.typeArguments.nonSeparatorCount()) {
+                for (var i = 0; i < genericTypeAST.typeArgumentList.typeArguments.nonSeparatorCount(); i++) {
+                    typeArgs[i] = this.resolveTypeReference(genericTypeAST.typeArgumentList.typeArguments.nonSeparatorAt(i), context);
+
+                    if (typeArgs[i].isError()) {
+                        typeArgs[i] = this.semanticInfoChain.anyTypeSymbol;
+                    }
+                }
+            }
+
+            if (typeArgs.length && typeArgs.length !== typeParameters.length) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(genericTypeAST, TypeScript.DiagnosticCode.Generic_type_0_requires_1_type_argument_s, [genericTypeSymbol.toString(), genericTypeSymbol.getTypeParameters().length]));
+                return this.getNewErrorTypeSymbol();
+            }
+
+            if (!genericTypeSymbol.isResolved) {
+                var typeDecls = genericTypeSymbol.getDeclarations();
+                var childDecls = null;
+
+                for (var i = 0; i < typeDecls.length; i++) {
+                    childDecls = typeDecls[i].getChildDecls();
+
+                    for (var j = 0; j < childDecls.length; j++) {
+                        childDecls[j].ensureSymbolIsBound();
+                    }
+                }
+            }
+
+            var specializedSymbol = this.createInstantiatedType(genericTypeSymbol, typeArgs);
+
+            var upperBound = null;
+
+            typeParameters = specializedSymbol.getTypeParameters();
+
+            var typeConstraintSubstitutionMap = [];
+
+            var instantiatedSubstitutionMap = specializedSymbol.getTypeParameterArgumentMap();
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeConstraintSubstitutionMap[typeParameters[i].pullSymbolID] = typeParameters[i];
+            }
+
+            for (var id in instantiatedSubstitutionMap) {
+                typeConstraintSubstitutionMap[id] = instantiatedSubstitutionMap[id];
+            }
+
+            for (var iArg = 0; (iArg < typeArgs.length) && (iArg < typeParameters.length); iArg++) {
+                var typeArg = typeArgs[iArg];
+                var typeParameter = typeParameters[iArg];
+                var typeConstraint = typeParameter.getConstraint();
+
+                typeConstraintSubstitutionMap[typeParameter.pullSymbolID] = typeArg;
+
+                if (typeConstraint) {
+                    if (typeConstraint.isTypeParameter()) {
+                        for (var j = 0; j < typeParameters.length && j < typeArgs.length; j++) {
+                            if (typeParameters[j] === typeConstraint) {
+                                typeConstraint = typeArgs[j];
+                            }
+                        }
+                    } else if (typeConstraint.isGeneric()) {
+                        typeConstraint = this.instantiateType(typeConstraint, typeConstraintSubstitutionMap);
+                    }
+
+                    if (typeArg.isTypeParameter()) {
+                        upperBound = typeArg.getConstraint();
+
+                        if (upperBound) {
+                            typeArg = upperBound;
+                        }
+                    }
+
+                    if (typeArg.inResolution || (typeArg.isTypeReference() && typeArg.referencedTypeSymbol.inResolution)) {
+                        return specializedSymbol;
+                    }
+
+                    if (context.canTypeCheckAST(genericTypeAST)) {
+                        this.typeCheckCallBacks.push(function (context) {
+                            if (!_this.sourceIsAssignableToTarget(typeArg, typeConstraint, genericTypeAST, context)) {
+                                var enclosingSymbol = _this.getEnclosingSymbolForAST(genericTypeAST);
+                                context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(genericTypeAST, TypeScript.DiagnosticCode.Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2, [typeArg.toString(enclosingSymbol, true), typeConstraint.toString(enclosingSymbol, true), typeParameter.toString(enclosingSymbol, true)]));
+                            }
+                        });
+                    }
+                }
+            }
+
+            return specializedSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveQualifiedName = function (dottedNameAST, context) {
+            if (this.inTypeQuery(dottedNameAST)) {
+                return this.resolveDottedNameExpression(dottedNameAST, dottedNameAST.left, dottedNameAST.right, context).type;
+            }
+
+            var symbol = this.getSymbolForAST(dottedNameAST, context);
+            if (!symbol || this.canTypeCheckAST(dottedNameAST, context)) {
+                var canTypeCheck = this.canTypeCheckAST(dottedNameAST, context);
+                if (canTypeCheck) {
+                    this.setTypeChecked(dottedNameAST, context);
+                }
+
+                symbol = this.computeQualifiedName(dottedNameAST, context);
+                this.setSymbolForAST(dottedNameAST, symbol, context);
+            }
+
+            this.resolveDeclaredSymbol(symbol, context);
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.isLastNameOfModuleNameModuleReference = function (ast) {
+            return ast.kind() === 11 /* IdentifierName */ && ast.parent && ast.parent.kind() === 121 /* QualifiedName */ && ast.parent.right === ast && ast.parent.parent && ast.parent.parent.kind() === 246 /* ModuleNameModuleReference */;
+        };
+
+        PullTypeResolver.prototype.computeQualifiedName = function (dottedNameAST, context) {
+            var rhsName = dottedNameAST.right.valueText();
+            if (rhsName.length === 0) {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var enclosingDecl = this.getEnclosingDeclForAST(dottedNameAST);
+            var lhs = this.resolveAST(dottedNameAST.left, false, context);
+
+            var lhsType = lhs.isAlias() ? lhs.getExportAssignedContainerSymbol() : lhs.type;
+
+            if (this.inClassExtendsHeritageClause(dottedNameAST) && !this.inTypeArgumentList(dottedNameAST)) {
+                if (lhs.isAlias()) {
+                    lhs.setIsUsedAsValue();
+                }
+            }
+
+            if (!lhsType) {
+                return this.getNewErrorTypeSymbol();
+            }
+
+            if (this.isAnyOrEquivalent(lhsType)) {
+                return lhsType;
+            }
+
+            var onLeftOfDot = this.isLeftSideOfQualifiedName(dottedNameAST);
+            var isNameOfModule = dottedNameAST.parent.kind() === 130 /* ModuleDeclaration */ && dottedNameAST.parent.name === dottedNameAST;
+
+            var memberKind = (onLeftOfDot || isNameOfModule) ? 164 /* SomeContainer */ : 58728795 /* SomeType */;
+
+            var childTypeSymbol = this.getNamedPropertySymbol(rhsName, memberKind, lhsType);
+
+            if (!childTypeSymbol && !isNameOfModule && this.isLastNameOfModuleNameModuleReference(dottedNameAST.right)) {
+                childTypeSymbol = this.getNamedPropertySymbol(rhsName, 68147712 /* SomeValue */, lhsType);
+            }
+
+            if (!childTypeSymbol && lhsType.isContainer()) {
+                var exportedContainer = lhsType.getExportAssignedContainerSymbol();
+
+                if (exportedContainer) {
+                    childTypeSymbol = this.getNamedPropertySymbol(rhsName, memberKind, exportedContainer);
+                }
+            }
+
+            if (!childTypeSymbol && enclosingDecl) {
+                var parentDecl = enclosingDecl;
+
+                while (parentDecl) {
+                    if (parentDecl.kind & 164 /* SomeContainer */) {
+                        break;
+                    }
+
+                    parentDecl = parentDecl.getParentDecl();
+                }
+
+                if (parentDecl) {
+                    var enclosingSymbolType = parentDecl.getSymbol().type;
+
+                    if (enclosingSymbolType === lhsType) {
+                        childTypeSymbol = this.getNamedPropertySymbol(rhsName, memberKind, lhsType);
+                    }
+                }
+            }
+
+            if (!childTypeSymbol) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(dottedNameAST.right, TypeScript.DiagnosticCode.The_property_0_does_not_exist_on_value_of_type_1, [dottedNameAST.right.text(), lhsType.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)]));
+                return this.getNewErrorTypeSymbol(rhsName);
+            }
+
+            return childTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.shouldContextuallyTypeAnyFunctionExpression = function (functionExpressionAST, typeParameters, parameters, returnTypeAnnotation, context) {
+            if (typeParameters && typeParameters.typeParameters.nonSeparatorCount() > 0) {
+                return false;
+            }
+
+            if (returnTypeAnnotation) {
+                return false;
+            }
+
+            if (parameters) {
+                for (var i = 0, n = parameters.length; i < n; i++) {
+                    if (parameters.typeAt(i)) {
+                        return false;
+                    }
+                }
+            }
+
+            var contextualFunctionTypeSymbol = context.getContextualType();
+
+            if (contextualFunctionTypeSymbol) {
+                this.resolveDeclaredSymbol(contextualFunctionTypeSymbol, context);
+                var callSignatures = contextualFunctionTypeSymbol.getCallSignatures();
+                var exactlyOneCallSignature = callSignatures && callSignatures.length === 1;
+                if (!exactlyOneCallSignature) {
+                    return false;
+                }
+
+                var callSignatureIsGeneric = callSignatures[0].getTypeParameters().length > 0;
+                return !callSignatureIsGeneric;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.resolveAnyFunctionExpression = function (funcDeclAST, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, isContextuallyTyped, context) {
+            var funcDeclSymbol = null;
+            var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            TypeScript.Debug.assert(functionDecl);
+
+            if (functionDecl && functionDecl.hasSymbol()) {
+                funcDeclSymbol = functionDecl.getSymbol();
+                if (funcDeclSymbol.isResolved || funcDeclSymbol.inResolution) {
+                    return funcDeclSymbol;
+                }
+            }
+
+            funcDeclSymbol = functionDecl.getSymbol();
+            TypeScript.Debug.assert(funcDeclSymbol);
+
+            var funcDeclType = funcDeclSymbol.type;
+            var signature = funcDeclType.getCallSignatures()[0];
+            funcDeclSymbol.startResolving();
+
+            if (typeParameters) {
+                for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) {
+                    this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context);
+                }
+            }
+
+            var assigningFunctionSignature = null;
+            if (isContextuallyTyped && this.shouldContextuallyTypeAnyFunctionExpression(funcDeclAST, typeParameters, parameters, returnTypeAnnotation, context)) {
+                assigningFunctionSignature = context.getContextualType().getCallSignatures()[0];
+            }
+
+            this.resolveAnyFunctionExpressionParameters(funcDeclAST, typeParameters, parameters, returnTypeAnnotation, isContextuallyTyped, context);
+
+            if (returnTypeAnnotation) {
+                signature.returnType = this.resolveTypeReference(returnTypeAnnotation, context);
+            } else {
+                if (assigningFunctionSignature) {
+                    var returnType = assigningFunctionSignature.returnType;
+
+                    if (returnType) {
+                        context.propagateContextualType(returnType);
+                        this.resolveFunctionBodyReturnTypes(funcDeclAST, block, bodyExpression, signature, true, functionDecl, context);
+                        context.popAnyContextualType();
+                    } else {
+                        signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+
+                        if (this.compilationSettings.noImplicitAny()) {
+                            var functionExpressionName = functionDecl.getFunctionExpressionName();
+
+                            if (functionExpressionName != "") {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type, [functionExpressionName]));
+                            } else {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_any_return_type));
+                            }
+                        }
+                    }
+                } else {
+                    this.resolveFunctionBodyReturnTypes(funcDeclAST, block, bodyExpression, signature, false, functionDecl, context);
+                }
+            }
+
+            context.setTypeInContext(funcDeclSymbol, funcDeclType);
+            funcDeclSymbol.setResolved();
+
+            if (this.canTypeCheckAST(funcDeclAST, context)) {
+                this.typeCheckAnyFunctionExpression(funcDeclAST, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, isContextuallyTyped, context);
+            }
+
+            return funcDeclSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveAnyFunctionExpressionParameters = function (funcDeclAST, typeParameters, parameters, returnTypeAnnotation, isContextuallyTyped, context) {
+            if (!parameters) {
+                return;
+            }
+
+            var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            var contextParams = [];
+
+            var assigningFunctionSignature = null;
+            if (isContextuallyTyped && this.shouldContextuallyTypeAnyFunctionExpression(funcDeclAST, typeParameters, parameters, returnTypeAnnotation, context)) {
+                assigningFunctionSignature = context.getContextualType().getCallSignatures()[0];
+            }
+
+            if (assigningFunctionSignature) {
+                contextParams = assigningFunctionSignature.parameters;
+            }
+
+            var contextualParametersCount = contextParams.length;
+            for (var i = 0, n = parameters.length; i < n; i++) {
+                var actualParameterIsVarArgParameter = (i === (n - 1)) && parameters.lastParameterIsRest();
+                var correspondingContextualParameter = null;
+                var contextualParameterType = null;
+
+                if (i < contextualParametersCount) {
+                    correspondingContextualParameter = contextParams[i];
+                } else if (contextualParametersCount && contextParams[contextualParametersCount - 1].isVarArg) {
+                    correspondingContextualParameter = contextParams[contextualParametersCount - 1];
+                }
+
+                if (correspondingContextualParameter) {
+                    if (correspondingContextualParameter.isVarArg === actualParameterIsVarArgParameter) {
+                        contextualParameterType = correspondingContextualParameter.type;
+                    } else if (correspondingContextualParameter.isVarArg) {
+                        contextualParameterType = correspondingContextualParameter.type.getElementType();
+                    }
+                }
+
+                this.resolveFunctionExpressionParameter(parameters.astAt(i), parameters.identifierAt(i), parameters.typeAt(i), parameters.initializerAt(i), contextualParameterType, functionDecl, context);
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckSimpleArrowFunctionExpression = function (arrowFunction, isContextuallyTyped, context) {
+            return this.typeCheckAnyFunctionExpression(arrowFunction, null, TypeScript.ASTHelpers.parametersFromIdentifier(arrowFunction.identifier), null, arrowFunction.block, arrowFunction.expression, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckParenthesizedArrowFunctionExpression = function (arrowFunction, isContextuallyTyped, context) {
+            return this.typeCheckAnyFunctionExpression(arrowFunction, arrowFunction.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(arrowFunction.callSignature.parameterList), TypeScript.ASTHelpers.getType(arrowFunction), arrowFunction.block, arrowFunction.expression, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckAnyFunctionExpression = function (funcDeclAST, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, isContextuallyTyped, context) {
+            var _this = this;
+            this.setTypeChecked(funcDeclAST, context);
+
+            var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            var funcDeclSymbol = functionDecl.getSymbol();
+            var funcDeclType = funcDeclSymbol.type;
+            var signature = funcDeclType.getCallSignatures()[0];
+            var returnTypeSymbol = signature.returnType;
+
+            if (typeParameters) {
+                for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) {
+                    this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context);
+                }
+            }
+
+            this.resolveAnyFunctionExpressionParameters(funcDeclAST, typeParameters, parameters, returnTypeAnnotation, isContextuallyTyped, context);
+
+            context.pushNewContextualType(null);
+            if (block) {
+                this.resolveAST(block, false, context);
+            } else {
+                var bodyExpressionType = this.resolveReturnExpression(bodyExpression, functionDecl, context);
+                this.typeCheckReturnExpression(bodyExpression, bodyExpressionType, functionDecl, context);
+            }
+
+            context.popAnyContextualType();
+
+            this.checkThatNonVoidFunctionHasReturnExpressionOrThrowStatement(functionDecl, returnTypeAnnotation, returnTypeSymbol, block, context);
+
+            this.validateVariableDeclarationGroups(functionDecl, context);
+
+            this.typeCheckCallBacks.push(function (context) {
+                _this.typeCheckFunctionOverloads(funcDeclAST, context);
+            });
+        };
+
+        PullTypeResolver.prototype.resolveThisExpression = function (thisExpression, context) {
+            var enclosingDecl = this.getEnclosingDeclForAST(thisExpression);
+            var thisTypeSymbol = this.getContextualClassSymbolForEnclosingDecl(thisExpression, enclosingDecl) || this.semanticInfoChain.anyTypeSymbol;
+
+            if (this.canTypeCheckAST(thisExpression, context)) {
+                this.typeCheckThisExpression(thisExpression, context, enclosingDecl);
+            }
+
+            return thisTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.inTypeArgumentList = function (ast) {
+            var previous = null;
+            var current = ast;
+
+            while (current) {
+                switch (current.kind()) {
+                    case 126 /* GenericType */:
+                        var genericType = current;
+                        if (genericType.typeArgumentList === previous) {
+                            return true;
+                        }
+                        break;
+
+                    case 226 /* ArgumentList */:
+                        var argumentList = current;
+                        return argumentList.typeArgumentList === previous;
+                }
+
+                previous = current;
+                current = current.parent;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.inClassExtendsHeritageClause = function (ast) {
+            while (ast) {
+                switch (ast.kind()) {
+                    case 230 /* ExtendsHeritageClause */:
+                        var heritageClause = ast;
+
+                        return heritageClause.parent.parent.kind() === 131 /* ClassDeclaration */;
+
+                    case 137 /* ConstructorDeclaration */:
+                    case 131 /* ClassDeclaration */:
+                    case 130 /* ModuleDeclaration */:
+                        return false;
+                }
+
+                ast = ast.parent;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.inTypeQuery = function (ast) {
+            while (ast) {
+                switch (ast.kind()) {
+                    case 127 /* TypeQuery */:
+                        return true;
+                    case 129 /* FunctionDeclaration */:
+                    case 213 /* InvocationExpression */:
+                    case 137 /* ConstructorDeclaration */:
+                    case 131 /* ClassDeclaration */:
+                    case 130 /* ModuleDeclaration */:
+                        return false;
+                }
+
+                ast = ast.parent;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.inArgumentListOfSuperInvocation = function (ast) {
+            var previous = null;
+            var current = ast;
+            while (current) {
+                switch (current.kind()) {
+                    case 213 /* InvocationExpression */:
+                        var invocationExpression = current;
+                        if (previous === invocationExpression.argumentList && invocationExpression.expression.kind() === 50 /* SuperKeyword */) {
+                            return true;
+                        }
+                        break;
+
+                    case 137 /* ConstructorDeclaration */:
+                    case 131 /* ClassDeclaration */:
+                    case 130 /* ModuleDeclaration */:
+                        return false;
+                }
+
+                previous = current;
+                current = current.parent;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.inConstructorParameterList = function (ast) {
+            var previous = null;
+            var current = ast;
+            while (current) {
+                switch (current.kind()) {
+                    case 142 /* CallSignature */:
+                        var callSignature = current;
+                        if (previous === callSignature.parameterList && callSignature.parent.kind() === 137 /* ConstructorDeclaration */) {
+                            return true;
+                        }
+
+                    case 131 /* ClassDeclaration */:
+                    case 130 /* ModuleDeclaration */:
+                        return false;
+                }
+
+                previous = current;
+                current = current.parent;
+            }
+
+            return false;
+        };
+        PullTypeResolver.prototype.isFunctionAccessorOrNonArrowFunctionExpression = function (decl) {
+            if (decl.kind === 262144 /* GetAccessor */ || decl.kind === 524288 /* SetAccessor */) {
+                return true;
+            }
+
+            return this.isFunctionOrNonArrowFunctionExpression(decl);
+        };
+
+        PullTypeResolver.prototype.isFunctionOrNonArrowFunctionExpression = function (decl) {
+            if (decl.kind === 16384 /* Function */) {
+                return true;
+            } else if (decl.kind === 131072 /* FunctionExpression */ && !TypeScript.hasFlag(decl.flags, 8192 /* ArrowFunction */)) {
+                return true;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.typeCheckThisExpression = function (thisExpression, context, enclosingDecl) {
+            this.checkForThisCaptureInArrowFunction(thisExpression);
+
+            if (this.inConstructorParameterList(thisExpression)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_in_constructor_arguments));
+                return;
+            }
+
+            for (var currentDecl = enclosingDecl; currentDecl !== null; currentDecl = currentDecl.getParentDecl()) {
+                if (this.isFunctionAccessorOrNonArrowFunctionExpression(currentDecl)) {
+                    return;
+                } else if (currentDecl.kind === 4 /* Container */ || currentDecl.kind === 32 /* DynamicModule */) {
+                    if (currentDecl.getParentDecl() === null) {
+                        return;
+                    } else {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_within_module_bodies));
+                        return;
+                    }
+                } else if (currentDecl.kind === 64 /* Enum */) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_in_current_location));
+                    return;
+                } else if (currentDecl.kind === 32768 /* ConstructorMethod */) {
+                    if (this.inArgumentListOfSuperInvocation(thisExpression) && this.superCallMustBeFirstStatementInConstructor(currentDecl)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_in_current_location));
+                    }
+
+                    return;
+                } else if (currentDecl.kind === 8 /* Class */) {
+                    if (this.inStaticMemberVariableDeclaration(thisExpression)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_in_static_initializers_in_a_class_body));
+                    }
+
+                    return;
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.getContextualClassSymbolForEnclosingDecl = function (ast, enclosingDecl) {
+            var declPath = enclosingDecl.getParentPath();
+
+            if (declPath.length) {
+                var isStaticContext = false;
+
+                for (var i = declPath.length - 1; i >= 0; i--) {
+                    var decl = declPath[i];
+                    var declKind = decl.kind;
+                    var declFlags = decl.flags;
+
+                    if (declFlags & 16 /* Static */) {
+                        isStaticContext = true;
+                    } else if (declKind === 131072 /* FunctionExpression */ && !TypeScript.hasFlag(declFlags, 8192 /* ArrowFunction */)) {
+                        return null;
+                    } else if (declKind === 16384 /* Function */) {
+                        return null;
+                    } else if (declKind === 8 /* Class */) {
+                        if (this.inStaticMemberVariableDeclaration(ast)) {
+                            return this.getNewErrorTypeSymbol();
+                        } else {
+                            var classSymbol = decl.getSymbol();
+                            if (isStaticContext) {
+                                var constructorSymbol = classSymbol.getConstructorMethod();
+                                return constructorSymbol.type;
+                            } else {
+                                return classSymbol;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.inStaticMemberVariableDeclaration = function (ast) {
+            while (ast) {
+                if (ast.kind() === 136 /* MemberVariableDeclaration */ && TypeScript.hasModifier(ast.modifiers, 16 /* Static */)) {
+                    return true;
+                }
+
+                ast = ast.parent;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.resolveSuperExpression = function (ast, context) {
+            var enclosingDecl = this.getEnclosingDeclForAST(ast);
+            var superType = this.semanticInfoChain.anyTypeSymbol;
+
+            var classSymbol = this.getContextualClassSymbolForEnclosingDecl(ast, enclosingDecl);
+
+            if (classSymbol) {
+                this.resolveDeclaredSymbol(classSymbol, context);
+
+                var parents = classSymbol.getExtendedTypes();
+
+                if (parents.length) {
+                    superType = parents[0];
+                }
+            }
+
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckSuperExpression(ast, context, enclosingDecl);
+            }
+
+            return superType;
+        };
+
+        PullTypeResolver.prototype.typeCheckSuperExpression = function (ast, context, enclosingDecl) {
+            this.setTypeChecked(ast, context);
+
+            this.checkForThisCaptureInArrowFunction(ast);
+
+            var isSuperCall = ast.parent.kind() === 213 /* InvocationExpression */;
+            var isSuperPropertyAccess = ast.parent.kind() === 212 /* MemberAccessExpression */;
+            TypeScript.Debug.assert(isSuperCall || isSuperPropertyAccess);
+
+            if (isSuperPropertyAccess) {
+                for (var currentDecl = enclosingDecl; currentDecl !== null; currentDecl = currentDecl.getParentDecl()) {
+                    if (this.isFunctionOrNonArrowFunctionExpression(currentDecl)) {
+                        break;
+                    } else if (currentDecl.kind === 8 /* Class */) {
+                        if (!this.enclosingClassIsDerived(currentDecl)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_non_derived_classes));
+                            return;
+                        } else if (this.inConstructorParameterList(ast)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_constructor_arguments));
+                            return;
+                        } else if (this.inStaticMemberVariableDeclaration(ast)) {
+                            break;
+                        }
+
+                        return;
+                    }
+                }
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class));
+                return;
+            } else {
+                if (enclosingDecl.kind === 32768 /* ConstructorMethod */) {
+                    var classDecl = enclosingDecl.getParentDecl();
+
+                    if (!this.enclosingClassIsDerived(classDecl)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_non_derived_classes));
+                        return;
+                    } else if (this.inConstructorParameterList(ast)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_constructor_arguments));
+                        return;
+                    }
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveSimplePropertyAssignment = function (propertyAssignment, isContextuallyTyped, context) {
+            return this.resolveAST(propertyAssignment.expression, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.resolveFunctionPropertyAssignment = function (funcProp, isContextuallyTyped, context) {
+            return this.resolveAnyFunctionExpression(funcProp, funcProp.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(funcProp.callSignature.parameterList), TypeScript.ASTHelpers.getType(funcProp), funcProp.block, null, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckFunctionPropertyAssignment = function (funcProp, isContextuallyTyped, context) {
+            this.typeCheckAnyFunctionExpression(funcProp, funcProp.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(funcProp.callSignature.parameterList), TypeScript.ASTHelpers.getType(funcProp), funcProp.block, null, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.resolveObjectLiteralExpression = function (expressionAST, isContextuallyTyped, context, additionalResults) {
+            var symbol = this.getSymbolForAST(expressionAST, context);
+            var hasResolvedSymbol = symbol && symbol.isResolved;
+
+            if (!hasResolvedSymbol || additionalResults || this.canTypeCheckAST(expressionAST, context)) {
+                if (this.canTypeCheckAST(expressionAST, context)) {
+                    this.setTypeChecked(expressionAST, context);
+                }
+                symbol = this.computeObjectLiteralExpression(expressionAST, isContextuallyTyped, context, additionalResults);
+                this.setSymbolForAST(expressionAST, symbol, context);
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.bindObjectLiteralMembers = function (objectLiteralDeclaration, objectLiteralTypeSymbol, objectLiteralMembers, isUsingExistingSymbol, pullTypeContext) {
+            var boundMemberSymbols = [];
+            var memberSymbol;
+            for (var i = 0, len = objectLiteralMembers.nonSeparatorCount(); i < len; i++) {
+                var propertyAssignment = objectLiteralMembers.nonSeparatorAt(i);
+
+                var id = this.getPropertyAssignmentName(propertyAssignment);
+                var assignmentText = getPropertyAssignmentNameTextFromIdentifier(id);
+
+                var isAccessor = propertyAssignment.kind() === 139 /* GetAccessor */ || propertyAssignment.kind() === 140 /* SetAccessor */;
+                var decl = this.semanticInfoChain.getDeclForAST(propertyAssignment);
+                TypeScript.Debug.assert(decl);
+
+                if (propertyAssignment.kind() === 240 /* SimplePropertyAssignment */) {
+                    if (!isUsingExistingSymbol) {
+                        memberSymbol = new TypeScript.PullSymbol(assignmentText.memberName, 4096 /* Property */);
+                        memberSymbol.addDeclaration(decl);
+                        decl.setSymbol(memberSymbol);
+                    } else {
+                        memberSymbol = decl.getSymbol();
+                    }
+                } else if (propertyAssignment.kind() === 241 /* FunctionPropertyAssignment */) {
+                    memberSymbol = decl.getSymbol();
+                } else {
+                    TypeScript.Debug.assert(isAccessor);
+                    memberSymbol = decl.getSymbol();
+                }
+
+                if (!isUsingExistingSymbol && !isAccessor) {
+                    var existingMember = objectLiteralTypeSymbol.findMember(memberSymbol.name, true);
+                    if (existingMember) {
+                        pullTypeContext.postDiagnostic(this.semanticInfoChain.duplicateIdentifierDiagnosticFromAST(propertyAssignment, assignmentText.actualText, existingMember.getDeclarations()[0].ast()));
+                    }
+
+                    objectLiteralTypeSymbol.addMember(memberSymbol);
+                }
+
+                boundMemberSymbols.push(memberSymbol);
+            }
+
+            return boundMemberSymbols;
+        };
+
+        PullTypeResolver.prototype.resolveObjectLiteralMembers = function (objectLiteralDeclaration, objectLiteralTypeSymbol, objectLiteralContextualType, objectLiteralMembers, stringIndexerSignature, numericIndexerSignature, allMemberTypes, allNumericMemberTypes, boundMemberSymbols, isUsingExistingSymbol, pullTypeContext, additionalResults) {
+            for (var i = 0, len = objectLiteralMembers.nonSeparatorCount(); i < len; i++) {
+                var propertyAssignment = objectLiteralMembers.nonSeparatorAt(i);
+
+                var acceptedContextualType = false;
+                var assigningSymbol = null;
+
+                var id = this.getPropertyAssignmentName(propertyAssignment);
+                var memberSymbol = boundMemberSymbols[i];
+                var contextualMemberType = null;
+
+                if (objectLiteralContextualType) {
+                    assigningSymbol = this.getNamedPropertySymbol(memberSymbol.name, 68147712 /* SomeValue */, objectLiteralContextualType);
+
+                    if (!assigningSymbol) {
+                        if (numericIndexerSignature && TypeScript.PullHelpers.isNameNumeric(memberSymbol.name)) {
+                            assigningSymbol = numericIndexerSignature;
+                        } else if (stringIndexerSignature) {
+                            assigningSymbol = stringIndexerSignature;
+                        }
+                    }
+
+                    if (assigningSymbol) {
+                        this.resolveDeclaredSymbol(assigningSymbol, pullTypeContext);
+
+                        contextualMemberType = assigningSymbol.kind === 4194304 /* IndexSignature */ ? assigningSymbol.returnType : assigningSymbol.type;
+                        pullTypeContext.propagateContextualType(contextualMemberType);
+
+                        acceptedContextualType = true;
+
+                        if (additionalResults) {
+                            additionalResults.membersContextTypeSymbols[i] = contextualMemberType;
+                        }
+                    }
+                }
+
+                var memberSymbolType = this.resolveAST(propertyAssignment, contextualMemberType !== null, pullTypeContext).type;
+
+                if (memberSymbolType) {
+                    if (memberSymbolType.isGeneric()) {
+                        objectLiteralTypeSymbol.setHasGenericMember();
+                    }
+
+                    if (stringIndexerSignature) {
+                        allMemberTypes.push(memberSymbolType);
+                    }
+                    if (numericIndexerSignature && TypeScript.PullHelpers.isNameNumeric(memberSymbol.name)) {
+                        allNumericMemberTypes.push(memberSymbolType);
+                    }
+                }
+
+                if (acceptedContextualType) {
+                    pullTypeContext.popAnyContextualType();
+                }
+
+                var isAccessor = propertyAssignment.kind() === 140 /* SetAccessor */ || propertyAssignment.kind() === 139 /* GetAccessor */;
+                if (!memberSymbol.isResolved) {
+                    if (isAccessor) {
+                        this.setSymbolForAST(id, memberSymbolType, pullTypeContext);
+                    } else {
+                        pullTypeContext.setTypeInContext(memberSymbol, memberSymbolType);
+                        memberSymbol.setResolved();
+
+                        this.setSymbolForAST(id, memberSymbol, pullTypeContext);
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.computeObjectLiteralExpression = function (objectLitAST, isContextuallyTyped, context, additionalResults) {
+            var objectLitDecl = this.semanticInfoChain.getDeclForAST(objectLitAST);
+            TypeScript.Debug.assert(objectLitDecl);
+
+            var typeSymbol = this.getSymbolForAST(objectLitAST, context);
+            var isUsingExistingSymbol = !!typeSymbol;
+
+            if (!typeSymbol) {
+                typeSymbol = new TypeScript.PullTypeSymbol("", 256 /* ObjectLiteral */);
+                typeSymbol.addDeclaration(objectLitDecl);
+                this.setSymbolForAST(objectLitAST, typeSymbol, context);
+                objectLitDecl.setSymbol(typeSymbol);
+            }
+
+            var propertyAssignments = objectLitAST.propertyAssignments;
+            var contextualType = null;
+
+            if (isContextuallyTyped) {
+                contextualType = context.getContextualType();
+                this.resolveDeclaredSymbol(contextualType, context);
+            }
+
+            var stringIndexerSignature = null;
+            var numericIndexerSignature = null;
+            var allMemberTypes = null;
+            var allNumericMemberTypes = null;
+
+            if (contextualType) {
+                var indexSignatures = this.getBothKindsOfIndexSignaturesExcludingAugmentedType(contextualType, context);
+
+                stringIndexerSignature = indexSignatures.stringSignature;
+                numericIndexerSignature = indexSignatures.numericSignature;
+
+                var inInferentialTyping = context.isInferentiallyTyping();
+                if (stringIndexerSignature) {
+                    allMemberTypes = inInferentialTyping ? [] : [stringIndexerSignature.returnType];
+                }
+
+                if (numericIndexerSignature) {
+                    allNumericMemberTypes = inInferentialTyping ? [] : [numericIndexerSignature.returnType];
+                }
+            }
+
+            if (propertyAssignments) {
+                if (additionalResults) {
+                    additionalResults.membersContextTypeSymbols = [];
+                }
+
+                var boundMemberSymbols = this.bindObjectLiteralMembers(objectLitDecl, typeSymbol, propertyAssignments, isUsingExistingSymbol, context);
+
+                this.resolveObjectLiteralMembers(objectLitDecl, typeSymbol, contextualType, propertyAssignments, stringIndexerSignature, numericIndexerSignature, allMemberTypes, allNumericMemberTypes, boundMemberSymbols, isUsingExistingSymbol, context, additionalResults);
+
+                if (!isUsingExistingSymbol) {
+                    this.stampObjectLiteralWithIndexSignature(typeSymbol, allMemberTypes, stringIndexerSignature, context);
+                    this.stampObjectLiteralWithIndexSignature(typeSymbol, allNumericMemberTypes, numericIndexerSignature, context);
+                }
+            }
+
+            typeSymbol.setResolved();
+            return typeSymbol;
+        };
+
+        PullTypeResolver.prototype.getPropertyAssignmentName = function (propertyAssignment) {
+            if (propertyAssignment.kind() === 240 /* SimplePropertyAssignment */) {
+                return propertyAssignment.propertyName;
+            } else if (propertyAssignment.kind() === 241 /* FunctionPropertyAssignment */) {
+                return propertyAssignment.propertyName;
+            } else if (propertyAssignment.kind() === 139 /* GetAccessor */) {
+                return propertyAssignment.propertyName;
+            } else if (propertyAssignment.kind() === 140 /* SetAccessor */) {
+                return propertyAssignment.propertyName;
+            } else {
+                TypeScript.Debug.assert(false);
+            }
+        };
+
+        PullTypeResolver.prototype.stampObjectLiteralWithIndexSignature = function (objectLiteralSymbol, indexerTypeCandidates, contextualIndexSignature, context) {
+            if (contextualIndexSignature) {
+                var typeCollection = {
+                    getLength: function () {
+                        return indexerTypeCandidates.length;
+                    },
+                    getTypeAtIndex: function (index) {
+                        return indexerTypeCandidates[index];
+                    }
+                };
+                var decl = objectLiteralSymbol.getDeclarations()[0];
+                var indexerReturnType = this.findBestCommonType(typeCollection, context).widenedType(this, null, context);
+                if (indexerReturnType === contextualIndexSignature.returnType) {
+                    objectLiteralSymbol.addIndexSignature(contextualIndexSignature);
+                } else {
+                    this.semanticInfoChain.addSyntheticIndexSignature(decl, objectLiteralSymbol, this.getASTForDecl(decl), contextualIndexSignature.parameters[0].name, contextualIndexSignature.parameters[0].type, indexerReturnType);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveArrayLiteralExpression = function (arrayLit, isContextuallyTyped, context) {
+            var symbol = this.getSymbolForAST(arrayLit, context);
+            if (!symbol || this.canTypeCheckAST(arrayLit, context)) {
+                if (this.canTypeCheckAST(arrayLit, context)) {
+                    this.setTypeChecked(arrayLit, context);
+                }
+                symbol = this.computeArrayLiteralExpressionSymbol(arrayLit, isContextuallyTyped, context);
+                this.setSymbolForAST(arrayLit, symbol, context);
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.computeArrayLiteralExpressionSymbol = function (arrayLit, isContextuallyTyped, context) {
+            var elements = arrayLit.expressions;
+            var elementType = null;
+            var elementTypes = [];
+            var comparisonInfo = new TypeComparisonInfo();
+            var contextualElementType = null;
+            comparisonInfo.onlyCaptureFirstError = true;
+
+            if (isContextuallyTyped) {
+                var contextualType = context.getContextualType();
+
+                this.resolveDeclaredSymbol(contextualType, context);
+
+                if (contextualType) {
+                    var indexSignatures = this.getBothKindsOfIndexSignaturesExcludingAugmentedType(contextualType, context);
+                    if (indexSignatures.numericSignature) {
+                        contextualElementType = indexSignatures.numericSignature.returnType;
+                    }
+                }
+            }
+
+            if (elements) {
+                if (contextualElementType) {
+                    context.propagateContextualType(contextualElementType);
+                }
+
+                for (var i = 0, n = elements.nonSeparatorCount(); i < n; i++) {
+                    elementTypes.push(this.resolveAST(elements.nonSeparatorAt(i), contextualElementType !== null, context).type);
+                }
+
+                if (contextualElementType) {
+                    context.popAnyContextualType();
+                }
+            }
+
+            if (elementTypes.length) {
+                elementType = elementTypes[0];
+            }
+            var collection;
+
+            if (contextualElementType && !context.isInferentiallyTyping()) {
+                if (!elementType) {
+                    elementType = contextualElementType;
+                }
+
+                collection = {
+                    getLength: function () {
+                        return elements.nonSeparatorCount() + 1;
+                    },
+                    getTypeAtIndex: function (index) {
+                        return index === 0 ? contextualElementType : elementTypes[index - 1];
+                    }
+                };
+            } else {
+                collection = {
+                    getLength: function () {
+                        return elements.nonSeparatorCount();
+                    },
+                    getTypeAtIndex: function (index) {
+                        return elementTypes[index];
+                    }
+                };
+            }
+
+            elementType = elementType ? this.findBestCommonType(collection, context, comparisonInfo) : elementType;
+
+            if (!elementType) {
+                elementType = this.semanticInfoChain.undefinedTypeSymbol;
+            }
+
+            return this.getArrayType(elementType);
+        };
+
+        PullTypeResolver.prototype.resolveElementAccessExpression = function (callEx, context) {
+            var symbolAndDiagnostic = this.computeElementAccessExpressionSymbolAndDiagnostic(callEx, context);
+
+            if (this.canTypeCheckAST(callEx, context)) {
+                this.typeCheckElementAccessExpression(callEx, context, symbolAndDiagnostic);
+            }
+
+            return symbolAndDiagnostic.symbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckElementAccessExpression = function (callEx, context, symbolAndDiagnostic) {
+            this.setTypeChecked(callEx, context);
+            context.postDiagnostic(symbolAndDiagnostic.diagnostic);
+        };
+
+        PullTypeResolver.prototype.computeElementAccessExpressionSymbolAndDiagnostic = function (callEx, context) {
+            var targetSymbol = this.resolveAST(callEx.expression, false, context);
+            var indexType = this.resolveAST(callEx.argumentExpression, false, context).type;
+
+            var targetTypeSymbol = targetSymbol.type;
+
+            targetTypeSymbol = this.getApparentType(targetTypeSymbol);
+
+            if (this.isAnyOrEquivalent(targetTypeSymbol)) {
+                return { symbol: targetTypeSymbol };
+            }
+
+            var elementType = targetTypeSymbol.getElementType();
+
+            var isNumberIndex = indexType === this.semanticInfoChain.numberTypeSymbol || TypeScript.PullHelpers.symbolIsEnum(indexType);
+
+            if (elementType && isNumberIndex) {
+                return { symbol: elementType };
+            }
+
+            if (callEx.argumentExpression.kind() === 14 /* StringLiteral */ || callEx.argumentExpression.kind() === 13 /* NumericLiteral */) {
+                var memberName = callEx.argumentExpression.kind() === 14 /* StringLiteral */ ? TypeScript.stripStartAndEndQuotes(callEx.argumentExpression.text()) : callEx.argumentExpression.valueText();
+
+                var member = this._getNamedPropertySymbolOfAugmentedType(memberName, targetTypeSymbol);
+
+                if (member) {
+                    this.resolveDeclaredSymbol(member, context);
+
+                    return { symbol: member.type };
+                }
+            }
+
+            var signatures = this.getBothKindsOfIndexSignaturesIncludingAugmentedType(targetTypeSymbol, context);
+
+            var stringSignature = signatures.stringSignature;
+            var numberSignature = signatures.numericSignature;
+
+            if (numberSignature && (isNumberIndex || indexType === this.semanticInfoChain.anyTypeSymbol)) {
+                return { symbol: numberSignature.returnType || this.semanticInfoChain.anyTypeSymbol };
+            } else if (stringSignature && (isNumberIndex || indexType === this.semanticInfoChain.anyTypeSymbol || indexType === this.semanticInfoChain.stringTypeSymbol)) {
+                return { symbol: stringSignature.returnType || this.semanticInfoChain.anyTypeSymbol };
+            } else if (isNumberIndex || indexType === this.semanticInfoChain.anyTypeSymbol || indexType === this.semanticInfoChain.stringTypeSymbol) {
+                if (this.compilationSettings.noImplicitAny()) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(callEx.argumentExpression, TypeScript.DiagnosticCode.Index_signature_of_object_type_implicitly_has_an_any_type));
+                }
+                return { symbol: this.semanticInfoChain.anyTypeSymbol };
+            } else {
+                return {
+                    symbol: this.getNewErrorTypeSymbol(),
+                    diagnostic: this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.Value_of_type_0_is_not_indexable_by_type_1, [targetTypeSymbol.toString(), indexType.toString()])
+                };
+            }
+        };
+
+        PullTypeResolver.prototype.getBothKindsOfIndexSignaturesIncludingAugmentedType = function (enclosingType, context) {
+            return this._getBothKindsOfIndexSignatures(enclosingType, context, true);
+        };
+
+        PullTypeResolver.prototype.getBothKindsOfIndexSignaturesExcludingAugmentedType = function (enclosingType, context) {
+            return this._getBothKindsOfIndexSignatures(enclosingType, context, false);
+        };
+
+        PullTypeResolver.prototype._getBothKindsOfIndexSignatures = function (enclosingType, context, includeAugmentedType) {
+            var signatures = includeAugmentedType ? enclosingType.getIndexSignaturesOfAugmentedType(this, this.cachedFunctionInterfaceType(), this.cachedObjectInterfaceType()) : enclosingType.getIndexSignatures();
+
+            var stringSignature = null;
+            var numberSignature = null;
+            var signature = null;
+            var paramSymbols;
+            var paramType;
+
+            for (var i = 0; i < signatures.length; i++) {
+                if (stringSignature && numberSignature) {
+                    break;
+                }
+
+                signature = signatures[i];
+                if (!signature.isResolved) {
+                    this.resolveDeclaredSymbol(signature, context);
+                }
+
+                paramSymbols = signature.parameters;
+
+                if (paramSymbols.length) {
+                    paramType = paramSymbols[0].type;
+
+                    if (!stringSignature && paramType === this.semanticInfoChain.stringTypeSymbol) {
+                        stringSignature = signature;
+                        continue;
+                    } else if (!numberSignature && paramType === this.semanticInfoChain.numberTypeSymbol) {
+                        numberSignature = signature;
+                        continue;
+                    }
+                }
+            }
+
+            return {
+                numericSignature: numberSignature,
+                stringSignature: stringSignature
+            };
+        };
+
+        PullTypeResolver.prototype._addUnhiddenSignaturesFromBaseType = function (derivedTypeSignatures, baseTypeSignatures, signaturesBeingAggregated) {
+            var _this = this;
+            if (!derivedTypeSignatures) {
+                signaturesBeingAggregated.push.apply(signaturesBeingAggregated, baseTypeSignatures);
+                return;
+            }
+
+            var context = new TypeScript.PullTypeResolutionContext(this);
+            for (var i = 0; i < baseTypeSignatures.length; i++) {
+                var baseSignature = baseTypeSignatures[i];
+
+                var signatureIsHidden = TypeScript.ArrayUtilities.any(derivedTypeSignatures, function (sig) {
+                    return _this.signaturesAreIdenticalWithNewEnclosingTypes(baseSignature, sig, context, false);
+                });
+
+                if (!signatureIsHidden) {
+                    signaturesBeingAggregated.push(baseSignature);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveBinaryAdditionOperation = function (binaryExpression, context) {
+            var lhsExpression = this.resolveAST(binaryExpression.left, false, context);
+            var lhsType = lhsExpression.type;
+            var rhsType = this.resolveAST(binaryExpression.right, false, context).type;
+
+            if (TypeScript.PullHelpers.symbolIsEnum(lhsType)) {
+                lhsType = this.semanticInfoChain.numberTypeSymbol;
+            }
+
+            if (TypeScript.PullHelpers.symbolIsEnum(rhsType)) {
+                rhsType = this.semanticInfoChain.numberTypeSymbol;
+            }
+
+            var isLhsTypeNullOrUndefined = lhsType === this.semanticInfoChain.nullTypeSymbol || lhsType === this.semanticInfoChain.undefinedTypeSymbol;
+            var isRhsTypeNullOrUndefined = rhsType === this.semanticInfoChain.nullTypeSymbol || rhsType === this.semanticInfoChain.undefinedTypeSymbol;
+
+            if (isLhsTypeNullOrUndefined) {
+                if (isRhsTypeNullOrUndefined) {
+                    lhsType = rhsType = this.semanticInfoChain.anyTypeSymbol;
+                } else {
+                    lhsType = rhsType;
+                }
+            } else if (isRhsTypeNullOrUndefined) {
+                rhsType = lhsType;
+            }
+
+            var exprType = null;
+
+            if (lhsType === this.semanticInfoChain.stringTypeSymbol || rhsType === this.semanticInfoChain.stringTypeSymbol) {
+                exprType = this.semanticInfoChain.stringTypeSymbol;
+            } else if (this.isAnyOrEquivalent(lhsType) || this.isAnyOrEquivalent(rhsType)) {
+                exprType = this.semanticInfoChain.anyTypeSymbol;
+            } else if (rhsType === this.semanticInfoChain.numberTypeSymbol && lhsType === this.semanticInfoChain.numberTypeSymbol) {
+                exprType = this.semanticInfoChain.numberTypeSymbol;
+            }
+
+            if (this.canTypeCheckAST(binaryExpression, context)) {
+                this.setTypeChecked(binaryExpression, context);
+
+                if (exprType) {
+                    if (binaryExpression.kind() === 175 /* AddAssignmentExpression */) {
+                        if (!this.isReference(binaryExpression.left, lhsExpression)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_left_hand_side_of_assignment_expression));
+                        }
+
+                        this.checkAssignability(binaryExpression.left, exprType, lhsType, context);
+                    }
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_expression_types_not_known_to_support_the_addition_operator));
+                }
+            }
+
+            if (!exprType) {
+                exprType = this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            return exprType;
+        };
+
+        PullTypeResolver.prototype.bestCommonTypeOfTwoTypes = function (type1, type2, context) {
+            return this.findBestCommonType({
+                getLength: function () {
+                    return 2;
+                },
+                getTypeAtIndex: function (index) {
+                    switch (index) {
+                        case 0:
+                            return type1;
+                        case 1:
+                            return type2;
+                    }
+                }
+            }, context);
+        };
+
+        PullTypeResolver.prototype.bestCommonTypeOfThreeTypes = function (type1, type2, type3, context) {
+            return this.findBestCommonType({
+                getLength: function () {
+                    return 3;
+                },
+                getTypeAtIndex: function (index) {
+                    switch (index) {
+                        case 0:
+                            return type1;
+                        case 1:
+                            return type2;
+                        case 2:
+                            return type3;
+                    }
+                }
+            }, context);
+        };
+
+        PullTypeResolver.prototype.resolveLogicalOrExpression = function (binex, isContextuallyTyped, context) {
+            if (this.canTypeCheckAST(binex, context)) {
+                this.setTypeChecked(binex, context);
+            }
+
+            if (isContextuallyTyped) {
+                var contextualType = context.getContextualType();
+                var leftType = this.resolveAST(binex.left, isContextuallyTyped, context).type;
+                var rightType = this.resolveAST(binex.right, isContextuallyTyped, context).type;
+
+                return context.isInferentiallyTyping() ? this.bestCommonTypeOfTwoTypes(leftType, rightType, context) : this.bestCommonTypeOfThreeTypes(contextualType, leftType, rightType, context);
+            } else {
+                var leftType = this.resolveAST(binex.left, false, context).type;
+
+                context.pushNewContextualType(leftType);
+                var rightType = this.resolveAST(binex.right, true, context).type;
+                context.popAnyContextualType();
+
+                return this.bestCommonTypeOfTwoTypes(leftType, rightType, context);
+            }
+        };
+
+        PullTypeResolver.prototype.resolveLogicalAndExpression = function (binex, context) {
+            if (this.canTypeCheckAST(binex, context)) {
+                this.setTypeChecked(binex, context);
+
+                this.resolveAST(binex.left, false, context);
+            }
+
+            return this.resolveAST(binex.right, false, context).type;
+        };
+
+        PullTypeResolver.prototype.computeTypeOfConditionalExpression = function (leftType, rightType, isContextuallyTyped, context) {
+            if (isContextuallyTyped && !context.isInferentiallyTyping()) {
+                var contextualType = context.getContextualType();
+                return this.bestCommonTypeOfThreeTypes(contextualType, leftType, rightType, context);
+            } else {
+                return this.bestCommonTypeOfTwoTypes(leftType, rightType, context);
+            }
+        };
+
+        PullTypeResolver.prototype.resolveConditionalExpression = function (trinex, isContextuallyTyped, context) {
+            var leftType = this.resolveAST(trinex.whenTrue, isContextuallyTyped, context).type;
+            var rightType = this.resolveAST(trinex.whenFalse, isContextuallyTyped, context).type;
+
+            var expressionType = this.computeTypeOfConditionalExpression(leftType, rightType, isContextuallyTyped, context);
+
+            var conditionalTypesAreValid = this.conditionExpressionTypesAreValid(leftType, rightType, expressionType, isContextuallyTyped, context);
+
+            if (this.canTypeCheckAST(trinex, context)) {
+                this.setTypeChecked(trinex, context);
+                this.resolveAST(trinex.condition, false, context);
+
+                if (!this.conditionExpressionTypesAreValid(leftType, rightType, expressionType, isContextuallyTyped, context)) {
+                    if (isContextuallyTyped) {
+                        var contextualType = context.getContextualType();
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(trinex, TypeScript.DiagnosticCode.Type_of_conditional_0_must_be_identical_to_1_2_or_3, [expressionType.toString(), leftType.toString(), rightType.toString(), contextualType.toString()]));
+                    } else {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(trinex, TypeScript.DiagnosticCode.Type_of_conditional_0_must_be_identical_to_1_or_2, [expressionType.toString(), leftType.toString(), rightType.toString()]));
+                    }
+                }
+            }
+
+            if (!conditionalTypesAreValid) {
+                return this.getNewErrorTypeSymbol();
+            }
+
+            return expressionType;
+        };
+
+        PullTypeResolver.prototype.conditionExpressionTypesAreValid = function (leftType, rightType, expressionType, isContextuallyTyped, context) {
+            if (isContextuallyTyped) {
+                var contextualType = context.getContextualType();
+                if (this.typesAreIdentical(expressionType, leftType, context) || this.typesAreIdentical(expressionType, rightType, context) || this.typesAreIdentical(expressionType, contextualType, context)) {
+                    return true;
+                }
+            } else {
+                if (this.typesAreIdentical(expressionType, leftType, context) || this.typesAreIdentical(expressionType, rightType, context)) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.resolveParenthesizedExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+            }
+
+            return this.resolveAST(ast.expression, false, context);
+        };
+
+        PullTypeResolver.prototype.resolveExpressionStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+
+                this.resolveAST(ast.expression, false, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveInvocationExpression = function (callEx, context, additionalResults) {
+            var symbol = this.getSymbolForAST(callEx, context);
+
+            if (!symbol || !symbol.isResolved) {
+                if (!additionalResults) {
+                    additionalResults = new PullAdditionalCallResolutionData();
+                }
+                symbol = this.computeInvocationExpressionSymbol(callEx, context, additionalResults);
+                if (this.canTypeCheckAST(callEx, context)) {
+                    this.setTypeChecked(callEx, context);
+                }
+                if (symbol !== this.semanticInfoChain.anyTypeSymbol) {
+                    this.setSymbolForAST(callEx, symbol, context);
+                }
+                this.semanticInfoChain.setCallResolutionDataForAST(callEx, additionalResults);
+            } else {
+                if (this.canTypeCheckAST(callEx, context)) {
+                    this.typeCheckInvocationExpression(callEx, context);
+                }
+
+                var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx);
+                if (additionalResults && (callResolutionData !== additionalResults)) {
+                    additionalResults.actualParametersContextTypeSymbols = callResolutionData.actualParametersContextTypeSymbols;
+                    additionalResults.candidateSignature = callResolutionData.candidateSignature;
+                    additionalResults.resolvedSignatures = callResolutionData.resolvedSignatures;
+                    additionalResults.targetSymbol = callResolutionData.targetSymbol;
+                }
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckInvocationExpression = function (callEx, context) {
+            this.setTypeChecked(callEx, context);
+            var targetSymbol = this.resolveAST(callEx.expression, false, context);
+
+            if (callEx.argumentList.arguments) {
+                var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx);
+
+                var len = callEx.argumentList.arguments.nonSeparatorCount();
+                for (var i = 0; i < len; i++) {
+                    var contextualType = callResolutionData.actualParametersContextTypeSymbols ? callResolutionData.actualParametersContextTypeSymbols[i] : null;
+                    if (contextualType) {
+                        context.pushNewContextualType(contextualType);
+                    }
+
+                    this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType !== null, context);
+
+                    if (contextualType) {
+                        context.popAnyContextualType();
+                        contextualType = null;
+                    }
+                }
+            }
+
+            for (var i = 0; i < callResolutionData.diagnosticsFromOverloadResolution.length; i++) {
+                context.postDiagnostic(callResolutionData.diagnosticsFromOverloadResolution[i]);
+            }
+        };
+
+        PullTypeResolver.prototype.computeInvocationExpressionSymbol = function (callEx, context, additionalResults) {
+            var targetSymbol = this.resolveAST(callEx.expression, false, context);
+            var targetAST = this.getCallTargetErrorSpanAST(callEx);
+
+            var targetTypeSymbol = targetSymbol.type;
+            if (this.isAnyOrEquivalent(targetTypeSymbol)) {
+                this.resolveAST(callEx.argumentList.arguments, false, context);
+
+                if (callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()) {
+                    if (targetTypeSymbol === this.semanticInfoChain.anyTypeSymbol) {
+                        this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Untyped_function_calls_may_not_accept_type_arguments), additionalResults, context);
+                        return this.getNewErrorTypeSymbol();
+                    }
+                }
+
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var isSuperCall = false;
+
+            if (callEx.expression.kind() === 50 /* SuperKeyword */) {
+                isSuperCall = true;
+
+                if (targetTypeSymbol.isClass()) {
+                    targetSymbol = targetTypeSymbol.getConstructorMethod();
+                    this.resolveDeclaredSymbol(targetSymbol, context);
+                    targetTypeSymbol = targetSymbol.type;
+                } else {
+                    this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Calls_to_super_are_only_valid_inside_a_class), additionalResults, context);
+                    this.resolveAST(callEx.argumentList.arguments, false, context);
+
+                    return this.getNewErrorTypeSymbol();
+                }
+            }
+
+            var signatures = isSuperCall ? targetTypeSymbol.getConstructSignatures() : targetTypeSymbol.getCallSignatures();
+
+            if (!signatures.length && (targetTypeSymbol.kind === 33554432 /* ConstructorType */)) {
+                this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, [targetTypeSymbol.toString()]), additionalResults, context);
+            }
+
+            var explicitTypeArgs = null;
+            var couldNotFindGenericOverload = false;
+            var couldNotAssignToConstraint;
+            var constraintDiagnostic = null;
+            var typeArgumentCountDiagnostic = null;
+            var diagnostics = [];
+
+            if (callEx.argumentList.typeArgumentList) {
+                explicitTypeArgs = [];
+
+                if (callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()) {
+                    for (var i = 0; i < callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount(); i++) {
+                        explicitTypeArgs[i] = this.resolveTypeReference(callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorAt(i), context);
+                    }
+                }
+            }
+
+            var triedToInferTypeArgs = false;
+
+            var resolvedSignatures = [];
+            var inferredOrExplicitTypeArgs;
+            var specializedSignature;
+            var typeParameters;
+            var typeConstraint = null;
+            var beforeResolutionSignatures = signatures;
+            var targetTypeReplacementMap = targetTypeSymbol.getTypeParameterArgumentMap();
+
+            for (var i = 0; i < signatures.length; i++) {
+                typeParameters = signatures[i].getTypeParameters();
+                couldNotAssignToConstraint = false;
+
+                if (signatures[i].isGeneric() && typeParameters.length) {
+                    if (isSuperCall && targetTypeSymbol.isGeneric() && !callEx.argumentList.typeArgumentList) {
+                        explicitTypeArgs = signatures[i].returnType.getTypeArguments();
+                    }
+
+                    if (explicitTypeArgs) {
+                        if (explicitTypeArgs.length === typeParameters.length) {
+                            inferredOrExplicitTypeArgs = explicitTypeArgs;
+                        } else {
+                            typeArgumentCountDiagnostic = typeArgumentCountDiagnostic || this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Signature_expected_0_type_arguments_got_1_instead, [typeParameters.length, explicitTypeArgs.length]);
+                            continue;
+                        }
+                    } else {
+                        TypeScript.Debug.assert(callEx.argumentList);
+                        var typeArgumentInferenceContext = new TypeScript.InvocationTypeArgumentInferenceContext(this, context, signatures[i], callEx.argumentList.arguments);
+                        inferredOrExplicitTypeArgs = this.inferArgumentTypesForSignature(typeArgumentInferenceContext, new TypeComparisonInfo(), context);
+                        triedToInferTypeArgs = true;
+                    }
+
+                    TypeScript.Debug.assert(inferredOrExplicitTypeArgs && inferredOrExplicitTypeArgs.length == typeParameters.length);
+
+                    var mutableTypeReplacementMap = new TypeScript.PullInstantiationHelpers.MutableTypeArgumentMap(targetTypeReplacementMap ? targetTypeReplacementMap : []);
+                    TypeScript.PullInstantiationHelpers.updateMutableTypeParameterArgumentMap(typeParameters, inferredOrExplicitTypeArgs, mutableTypeReplacementMap);
+                    var typeReplacementMap = mutableTypeReplacementMap.typeParameterArgumentMap;
+
+                    if (explicitTypeArgs) {
+                        for (var j = 0; j < typeParameters.length; j++) {
+                            typeConstraint = typeParameters[j].getConstraint();
+
+                            if (typeConstraint) {
+                                if (typeConstraint.isGeneric()) {
+                                    typeConstraint = this.instantiateType(typeConstraint, typeReplacementMap);
+                                }
+
+                                if (!this.sourceIsAssignableToTarget(inferredOrExplicitTypeArgs[j], typeConstraint, targetAST, context, null, true)) {
+                                    var enclosingSymbol = this.getEnclosingSymbolForAST(targetAST);
+                                    constraintDiagnostic = this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2, [inferredOrExplicitTypeArgs[j].toString(enclosingSymbol, true), typeConstraint.toString(enclosingSymbol, true), typeParameters[j].toString(enclosingSymbol, true)]);
+                                    couldNotAssignToConstraint = true;
+                                }
+
+                                if (couldNotAssignToConstraint) {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                    if (couldNotAssignToConstraint) {
+                        continue;
+                    }
+
+                    specializedSignature = this.instantiateSignature(signatures[i], typeReplacementMap);
+
+                    if (specializedSignature) {
+                        resolvedSignatures[resolvedSignatures.length] = specializedSignature;
+                    }
+                } else {
+                    if (!(callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount())) {
+                        resolvedSignatures[resolvedSignatures.length] = signatures[i];
+                    }
+                }
+            }
+
+            if (signatures.length && !resolvedSignatures.length) {
+                couldNotFindGenericOverload = true;
+            }
+
+            signatures = resolvedSignatures;
+
+            var errorCondition = null;
+            if (!signatures.length) {
+                additionalResults.targetSymbol = targetSymbol;
+                additionalResults.resolvedSignatures = beforeResolutionSignatures;
+                additionalResults.candidateSignature = beforeResolutionSignatures && beforeResolutionSignatures.length ? beforeResolutionSignatures[0] : null;
+
+                additionalResults.actualParametersContextTypeSymbols = actualParametersContextTypeSymbols;
+
+                this.resolveAST(callEx.argumentList.arguments, false, context);
+
+                if (!couldNotFindGenericOverload) {
+                    if (this.cachedFunctionInterfaceType() && this.sourceIsAssignableToTarget(targetTypeSymbol, this.cachedFunctionInterfaceType(), targetAST, context)) {
+                        if (callEx.argumentList.typeArgumentList) {
+                            this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Non_generic_functions_may_not_accept_type_arguments), additionalResults, context);
+                        }
+                        return this.semanticInfoChain.anyTypeSymbol;
+                    }
+
+                    this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature), additionalResults, context);
+                } else if (constraintDiagnostic) {
+                    this.postOverloadResolutionDiagnostics(constraintDiagnostic, additionalResults, context);
+                } else if (typeArgumentCountDiagnostic) {
+                    this.postOverloadResolutionDiagnostics(typeArgumentCountDiagnostic, additionalResults, context);
+                } else {
+                    this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.Could_not_select_overload_for_call_expression), additionalResults, context);
+                }
+
+                return this.getNewErrorTypeSymbol();
+            }
+
+            var signature = this.resolveOverloads(callEx, signatures, callEx.argumentList.typeArgumentList !== null, context, diagnostics);
+            var useBeforeResolutionSignatures = signature == null;
+
+            if (!signature) {
+                for (var i = 0; i < diagnostics.length; i++) {
+                    this.postOverloadResolutionDiagnostics(diagnostics[i], additionalResults, context);
+                }
+
+                this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Could_not_select_overload_for_call_expression), additionalResults, context);
+
+                errorCondition = this.getNewErrorTypeSymbol();
+
+                if (!signatures.length) {
+                    return errorCondition;
+                }
+
+                signature = signatures[0];
+            }
+
+            var rootSignature = signature.getRootSymbol();
+            if (!rootSignature.isGeneric() && callEx.argumentList.typeArgumentList) {
+                this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Non_generic_functions_may_not_accept_type_arguments), additionalResults, context);
+            } else if (rootSignature.isGeneric() && callEx.argumentList.typeArgumentList && rootSignature.getTypeParameters() && (callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount() !== rootSignature.getTypeParameters().length)) {
+                this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Signature_expected_0_type_arguments_got_1_instead, [rootSignature.getTypeParameters().length, callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()]), additionalResults, context);
+            }
+
+            var returnType = isSuperCall ? this.semanticInfoChain.voidTypeSymbol : signature.returnType;
+
+            var actualParametersContextTypeSymbols = [];
+            if (callEx.argumentList.arguments) {
+                var len = callEx.argumentList.arguments.nonSeparatorCount();
+                var params = signature.parameters;
+                var contextualType = null;
+                var signatureDecl = signature.getDeclarations()[0];
+
+                for (var i = 0; i < len; i++) {
+                    if (params.length) {
+                        if (i < params.length - 1 || (i < params.length && !signature.hasVarArgs)) {
+                            this.resolveDeclaredSymbol(params[i], context);
+                            contextualType = params[i].type;
+                        } else if (signature.hasVarArgs) {
+                            contextualType = params[params.length - 1].type;
+                            if (contextualType.isArrayNamedTypeReference()) {
+                                contextualType = contextualType.getElementType();
+                            }
+                        }
+                    }
+
+                    if (contextualType) {
+                        context.pushNewContextualType(contextualType);
+                        actualParametersContextTypeSymbols[i] = contextualType;
+                    }
+
+                    this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType !== null, context);
+
+                    if (contextualType) {
+                        context.popAnyContextualType();
+                        contextualType = null;
+                    }
+                }
+            }
+
+            additionalResults.targetSymbol = targetSymbol;
+            if (useBeforeResolutionSignatures && beforeResolutionSignatures) {
+                additionalResults.resolvedSignatures = beforeResolutionSignatures;
+                additionalResults.candidateSignature = beforeResolutionSignatures[0];
+            } else {
+                additionalResults.resolvedSignatures = signatures;
+                additionalResults.candidateSignature = signature;
+            }
+            additionalResults.actualParametersContextTypeSymbols = actualParametersContextTypeSymbols;
+
+            if (errorCondition) {
+                return errorCondition;
+            }
+
+            if (!returnType) {
+                returnType = this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            return returnType;
+        };
+
+        PullTypeResolver.prototype.resolveObjectCreationExpression = function (callEx, context, additionalResults) {
+            var symbol = this.getSymbolForAST(callEx, context);
+
+            if (!symbol || !symbol.isResolved) {
+                if (!additionalResults) {
+                    additionalResults = new PullAdditionalCallResolutionData();
+                }
+                symbol = this.computeObjectCreationExpressionSymbol(callEx, context, additionalResults);
+                if (this.canTypeCheckAST(callEx, context)) {
+                    this.setTypeChecked(callEx, context);
+                }
+                this.setSymbolForAST(callEx, symbol, context);
+                this.semanticInfoChain.setCallResolutionDataForAST(callEx, additionalResults);
+            } else {
+                if (this.canTypeCheckAST(callEx, context)) {
+                    this.typeCheckObjectCreationExpression(callEx, context);
+                }
+
+                var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx);
+                if (additionalResults && (callResolutionData !== additionalResults)) {
+                    additionalResults.actualParametersContextTypeSymbols = callResolutionData.actualParametersContextTypeSymbols;
+                    additionalResults.candidateSignature = callResolutionData.candidateSignature;
+                    additionalResults.resolvedSignatures = callResolutionData.resolvedSignatures;
+                    additionalResults.targetSymbol = callResolutionData.targetSymbol;
+                }
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckObjectCreationExpression = function (callEx, context) {
+            this.setTypeChecked(callEx, context);
+            this.resolveAST(callEx.expression, false, context);
+            var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx);
+            if (callEx.argumentList) {
+                var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx);
+                var len = callEx.argumentList.arguments.nonSeparatorCount();
+
+                for (var i = 0; i < len; i++) {
+                    var contextualType = callResolutionData.actualParametersContextTypeSymbols ? callResolutionData.actualParametersContextTypeSymbols[i] : null;
+                    if (contextualType) {
+                        context.pushNewContextualType(contextualType);
+                    }
+
+                    this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType !== null, context);
+
+                    if (contextualType) {
+                        context.popAnyContextualType();
+                        contextualType = null;
+                    }
+                }
+            }
+
+            for (var i = 0; i < callResolutionData.diagnosticsFromOverloadResolution.length; i++) {
+                context.postDiagnostic(callResolutionData.diagnosticsFromOverloadResolution[i]);
+            }
+        };
+
+        PullTypeResolver.prototype.postOverloadResolutionDiagnostics = function (diagnostic, additionalResults, context) {
+            if (!context.inProvisionalResolution()) {
+                additionalResults.diagnosticsFromOverloadResolution.push(diagnostic);
+            }
+            context.postDiagnostic(diagnostic);
+        };
+
+        PullTypeResolver.prototype.computeObjectCreationExpressionSymbol = function (callEx, context, additionalResults) {
+            var _this = this;
+            var returnType = null;
+
+            var targetSymbol = this.resolveAST(callEx.expression, false, context);
+            var targetTypeSymbol = targetSymbol.isType() ? targetSymbol : targetSymbol.type;
+
+            var targetAST = this.getCallTargetErrorSpanAST(callEx);
+
+            var constructSignatures = targetTypeSymbol.getConstructSignatures();
+
+            var explicitTypeArgs = null;
+            var usedCallSignaturesInstead = false;
+            var couldNotAssignToConstraint;
+            var constraintDiagnostic = null;
+            var typeArgumentCountDiagnostic = null;
+            var diagnostics = [];
+
+            if (this.isAnyOrEquivalent(targetTypeSymbol)) {
+                if (callEx.argumentList) {
+                    this.resolveAST(callEx.argumentList.arguments, false, context);
+                }
+
+                return targetTypeSymbol;
+            }
+
+            if (!constructSignatures.length) {
+                constructSignatures = targetTypeSymbol.getCallSignatures();
+                usedCallSignaturesInstead = true;
+
+                if (this.compilationSettings.noImplicitAny()) {
+                    this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.new_expression_which_lacks_a_constructor_signature_implicitly_has_an_any_type), additionalResults, context);
+                }
+            }
+
+            if (constructSignatures.length) {
+                if (callEx.argumentList && callEx.argumentList.typeArgumentList) {
+                    explicitTypeArgs = [];
+
+                    if (callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()) {
+                        for (var i = 0; i < callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount(); i++) {
+                            explicitTypeArgs[i] = this.resolveTypeReference(callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorAt(i), context);
+                        }
+                    }
+                }
+
+                if (targetTypeSymbol.isGeneric()) {
+                    var resolvedSignatures = [];
+                    var inferredOrExplicitTypeArgs;
+                    var specializedSignature;
+                    var typeParameters;
+                    var typeConstraint = null;
+                    var triedToInferTypeArgs;
+                    var targetTypeReplacementMap = targetTypeSymbol.getTypeParameterArgumentMap();
+
+                    for (var i = 0; i < constructSignatures.length; i++) {
+                        couldNotAssignToConstraint = false;
+
+                        if (constructSignatures[i].isGeneric()) {
+                            typeParameters = constructSignatures[i].getTypeParameters();
+
+                            if (explicitTypeArgs) {
+                                if (explicitTypeArgs.length === typeParameters.length) {
+                                    inferredOrExplicitTypeArgs = explicitTypeArgs;
+                                } else {
+                                    typeArgumentCountDiagnostic = typeArgumentCountDiagnostic || this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Signature_expected_0_type_arguments_got_1_instead, [typeParameters.length, explicitTypeArgs.length]);
+                                    continue;
+                                }
+                            } else if (callEx.argumentList) {
+                                var typeArgumentInferenceContext = new TypeScript.InvocationTypeArgumentInferenceContext(this, context, constructSignatures[i], callEx.argumentList.arguments);
+                                inferredOrExplicitTypeArgs = this.inferArgumentTypesForSignature(typeArgumentInferenceContext, new TypeComparisonInfo(), context);
+                                triedToInferTypeArgs = true;
+                            } else {
+                                inferredOrExplicitTypeArgs = TypeScript.ArrayUtilities.select(typeParameters, function (typeParameter) {
+                                    return typeParameter.getDefaultConstraint(_this.semanticInfoChain);
+                                });
+                            }
+
+                            TypeScript.Debug.assert(inferredOrExplicitTypeArgs && inferredOrExplicitTypeArgs.length == typeParameters.length);
+
+                            var mutableTypeReplacementMap = new TypeScript.PullInstantiationHelpers.MutableTypeArgumentMap(targetTypeReplacementMap ? targetTypeReplacementMap : []);
+                            TypeScript.PullInstantiationHelpers.updateMutableTypeParameterArgumentMap(typeParameters, inferredOrExplicitTypeArgs, mutableTypeReplacementMap);
+                            var typeReplacementMap = mutableTypeReplacementMap.typeParameterArgumentMap;
+
+                            if (explicitTypeArgs) {
+                                for (var j = 0; j < typeParameters.length; j++) {
+                                    typeConstraint = typeParameters[j].getConstraint();
+
+                                    if (typeConstraint) {
+                                        if (typeConstraint.isGeneric()) {
+                                            typeConstraint = this.instantiateType(typeConstraint, typeReplacementMap);
+                                        }
+
+                                        if (!this.sourceIsAssignableToTarget(inferredOrExplicitTypeArgs[j], typeConstraint, targetAST, context, null, true)) {
+                                            var enclosingSymbol = this.getEnclosingSymbolForAST(targetAST);
+                                            constraintDiagnostic = this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2, [inferredOrExplicitTypeArgs[j].toString(enclosingSymbol, true), typeConstraint.toString(enclosingSymbol, true), typeParameters[j].toString(enclosingSymbol, true)]);
+                                            couldNotAssignToConstraint = true;
+                                        }
+
+                                        if (couldNotAssignToConstraint) {
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+
+                            if (couldNotAssignToConstraint) {
+                                continue;
+                            }
+
+                            specializedSignature = this.instantiateSignature(constructSignatures[i], typeReplacementMap);
+
+                            if (specializedSignature) {
+                                resolvedSignatures[resolvedSignatures.length] = specializedSignature;
+                            }
+                        } else {
+                            if (!(callEx.argumentList && callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount())) {
+                                resolvedSignatures[resolvedSignatures.length] = constructSignatures[i];
+                            }
+                        }
+                    }
+
+                    constructSignatures = resolvedSignatures;
+                }
+
+                var signature = this.resolveOverloads(callEx, constructSignatures, callEx.argumentList && callEx.argumentList.typeArgumentList !== null, context, diagnostics);
+
+                additionalResults.targetSymbol = targetSymbol;
+                additionalResults.resolvedSignatures = constructSignatures;
+                additionalResults.candidateSignature = signature;
+                additionalResults.actualParametersContextTypeSymbols = [];
+
+                if (!constructSignatures.length) {
+                    if (constraintDiagnostic) {
+                        this.postOverloadResolutionDiagnostics(constraintDiagnostic, additionalResults, context);
+                    } else if (typeArgumentCountDiagnostic) {
+                        this.postOverloadResolutionDiagnostics(typeArgumentCountDiagnostic, additionalResults, context);
+                    }
+
+                    return this.getNewErrorTypeSymbol();
+                }
+
+                var errorCondition = null;
+
+                if (!signature) {
+                    for (var i = 0; i < diagnostics.length; i++) {
+                        this.postOverloadResolutionDiagnostics(diagnostics[i], additionalResults, context);
+                    }
+
+                    this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Could_not_select_overload_for_new_expression), additionalResults, context);
+
+                    errorCondition = this.getNewErrorTypeSymbol();
+
+                    if (!constructSignatures.length) {
+                        return errorCondition;
+                    }
+
+                    signature = constructSignatures[0];
+                }
+
+                returnType = signature.returnType;
+
+                if (returnType && !signature.isGeneric() && returnType.isGeneric() && !returnType.getIsSpecialized()) {
+                    if (explicitTypeArgs && explicitTypeArgs.length) {
+                        returnType = this.createInstantiatedType(returnType, explicitTypeArgs);
+                    } else {
+                        returnType = this.instantiateTypeToAny(returnType, context);
+                    }
+                }
+
+                if (usedCallSignaturesInstead) {
+                    if (returnType !== this.semanticInfoChain.voidTypeSymbol) {
+                        this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Call_signatures_used_in_a_new_expression_must_have_a_void_return_type), additionalResults, context);
+
+                        return this.getNewErrorTypeSymbol();
+                    } else {
+                        returnType = this.semanticInfoChain.anyTypeSymbol;
+                    }
+                }
+
+                if (!returnType) {
+                    returnType = signature.returnType;
+
+                    if (!returnType) {
+                        returnType = targetTypeSymbol;
+                    }
+                }
+
+                var actualParametersContextTypeSymbols = [];
+                if (callEx.argumentList && callEx.argumentList.arguments) {
+                    var len = callEx.argumentList.arguments.nonSeparatorCount();
+                    var params = signature.parameters;
+                    var contextualType = null;
+                    var signatureDecl = signature.getDeclarations()[0];
+
+                    for (var i = 0; i < len; i++) {
+                        if (params.length) {
+                            if (i < params.length - 1 || (i < params.length && !signature.hasVarArgs)) {
+                                this.resolveDeclaredSymbol(params[i], context);
+                                contextualType = params[i].type;
+                            } else if (signature.hasVarArgs) {
+                                contextualType = params[params.length - 1].type;
+                                if (contextualType.isArrayNamedTypeReference()) {
+                                    contextualType = contextualType.getElementType();
+                                }
+                            }
+                        }
+
+                        if (contextualType) {
+                            context.pushNewContextualType(contextualType);
+                            actualParametersContextTypeSymbols[i] = contextualType;
+                        }
+
+                        this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType !== null, context);
+
+                        if (contextualType) {
+                            context.popAnyContextualType();
+                            contextualType = null;
+                        }
+                    }
+                }
+
+                additionalResults.targetSymbol = targetSymbol;
+                additionalResults.resolvedSignatures = constructSignatures;
+                additionalResults.candidateSignature = signature;
+                additionalResults.actualParametersContextTypeSymbols = actualParametersContextTypeSymbols;
+
+                if (errorCondition) {
+                    return errorCondition;
+                }
+
+                if (!returnType) {
+                    returnType = this.semanticInfoChain.anyTypeSymbol;
+                }
+
+                return returnType;
+            } else if (callEx.argumentList) {
+                this.resolveAST(callEx.argumentList.arguments, false, context);
+            }
+
+            this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Invalid_new_expression), additionalResults, context);
+
+            return this.getNewErrorTypeSymbol();
+        };
+
+        PullTypeResolver.prototype.instantiateSignatureInContext = function (signatureAToInstantiate, contextualSignatureB, context, shouldFixContextualSignatureParameterTypes) {
+            var typeReplacementMap = [];
+            var inferredTypeArgs;
+            var specializedSignature;
+            var typeParameters = signatureAToInstantiate.getTypeParameters();
+            var typeConstraint = null;
+
+            var typeArgumentInferenceContext = new TypeScript.ContextualSignatureInstantiationTypeArgumentInferenceContext(this, context, signatureAToInstantiate, contextualSignatureB, shouldFixContextualSignatureParameterTypes);
+            inferredTypeArgs = this.inferArgumentTypesForSignature(typeArgumentInferenceContext, new TypeComparisonInfo(), context);
+
+            var functionTypeA = signatureAToInstantiate.functionType;
+            var functionTypeB = contextualSignatureB.functionType;
+            var enclosingTypeParameterMap;
+
+            if (functionTypeA) {
+                enclosingTypeParameterMap = functionTypeA.getTypeParameterArgumentMap();
+
+                for (var id in enclosingTypeParameterMap) {
+                    typeReplacementMap[id] = enclosingTypeParameterMap[id];
+                }
+            }
+
+            if (functionTypeB) {
+                enclosingTypeParameterMap = functionTypeB.getTypeParameterArgumentMap();
+
+                for (var id in enclosingTypeParameterMap) {
+                    typeReplacementMap[id] = enclosingTypeParameterMap[id];
+                }
+            }
+
+            TypeScript.PullInstantiationHelpers.updateTypeParameterArgumentMap(typeParameters, inferredTypeArgs, typeReplacementMap);
+
+            return this.instantiateSignature(signatureAToInstantiate, typeReplacementMap);
+        };
+
+        PullTypeResolver.prototype.resolveCastExpression = function (assertionExpression, context) {
+            var typeAssertionType = this.resolveTypeReference(assertionExpression.type, context).type;
+
+            if (this.canTypeCheckAST(assertionExpression, context)) {
+                this.typeCheckCastExpression(assertionExpression, context, typeAssertionType);
+            }
+
+            return typeAssertionType;
+        };
+
+        PullTypeResolver.prototype.typeCheckCastExpression = function (assertionExpression, context, typeAssertionType) {
+            this.setTypeChecked(assertionExpression, context);
+
+            context.pushNewContextualType(typeAssertionType);
+            var exprType = this.resolveAST(assertionExpression.expression, true, context).type;
+            context.popAnyContextualType();
+
+            this.resolveDeclaredSymbol(typeAssertionType, context);
+            this.resolveDeclaredSymbol(exprType, context);
+
+            var comparisonInfo = new TypeComparisonInfo();
+
+            var isAssignable = this.sourceIsAssignableToTarget(exprType, typeAssertionType, assertionExpression, context, comparisonInfo);
+
+            if (!isAssignable) {
+                var widenedExprType = exprType.widenedType(this, assertionExpression.expression, context);
+                isAssignable = this.sourceIsAssignableToTarget(typeAssertionType, widenedExprType, assertionExpression, context, comparisonInfo);
+            }
+
+            if (!isAssignable) {
+                var enclosingSymbol = this.getEnclosingSymbolForAST(assertionExpression);
+                if (comparisonInfo.message) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(assertionExpression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [exprType.toString(enclosingSymbol), typeAssertionType.toString(enclosingSymbol), comparisonInfo.message]));
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(assertionExpression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [exprType.toString(enclosingSymbol), typeAssertionType.toString(enclosingSymbol)]));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveAssignmentExpression = function (binaryExpression, context) {
+            var leftExpr = this.resolveAST(binaryExpression.left, false, context);
+            var leftType = leftExpr.type;
+
+            context.pushNewContextualType(leftType);
+            var rightType = this.resolveAST(binaryExpression.right, true, context).type;
+            context.popAnyContextualType();
+
+            rightType = this.getInstanceTypeForAssignment(binaryExpression.left, rightType, context);
+
+            if (this.canTypeCheckAST(binaryExpression, context)) {
+                this.setTypeChecked(binaryExpression, context);
+
+                if (!this.isReference(binaryExpression.left, leftExpr)) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_left_hand_side_of_assignment_expression));
+                } else {
+                    this.checkAssignability(binaryExpression.left, rightType, leftExpr.type, context);
+                }
+            }
+
+            return rightType;
+        };
+
+        PullTypeResolver.prototype.getInstanceTypeForAssignment = function (lhs, type, context) {
+            var typeToReturn = type;
+            if (typeToReturn && typeToReturn.isAlias()) {
+                typeToReturn = typeToReturn.getExportAssignedTypeSymbol();
+            }
+
+            if (typeToReturn && typeToReturn.isContainer() && !typeToReturn.isEnum()) {
+                var instanceTypeSymbol = typeToReturn.getInstanceType();
+
+                if (!instanceTypeSymbol) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(lhs, TypeScript.DiagnosticCode.Tried_to_set_variable_type_to_uninitialized_module_type_0, [type.toString()]));
+                    typeToReturn = null;
+                } else {
+                    typeToReturn = instanceTypeSymbol;
+                }
+            }
+
+            return typeToReturn;
+        };
+
+        PullTypeResolver.prototype.widenType = function (type, ast, context) {
+            if (type === this.semanticInfoChain.undefinedTypeSymbol || type === this.semanticInfoChain.nullTypeSymbol || type.isError()) {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            if (type.isArrayNamedTypeReference()) {
+                return this.widenArrayType(type, ast, context);
+            } else if (type.kind === 256 /* ObjectLiteral */) {
+                return this.widenObjectLiteralType(type, ast, context);
+            }
+
+            return type;
+        };
+
+        PullTypeResolver.prototype.widenArrayType = function (type, ast, context) {
+            var elementType = type.getElementType().widenedType(this, ast, context);
+
+            if (this.compilationSettings.noImplicitAny() && ast) {
+                if (elementType === this.semanticInfoChain.anyTypeSymbol && type.getElementType() !== this.semanticInfoChain.anyTypeSymbol) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Array_Literal_implicitly_has_an_any_type_from_widening));
+                }
+            }
+
+            return this.getArrayType(elementType);
+        };
+
+        PullTypeResolver.prototype.widenObjectLiteralType = function (type, ast, context) {
+            if (!this.needsToWidenObjectLiteralType(type, ast, context)) {
+                return type;
+            }
+
+            TypeScript.Debug.assert(type.name === "");
+            var newObjectTypeSymbol = new TypeScript.PullTypeSymbol(type.name, type.kind);
+            var declsOfObjectType = type.getDeclarations();
+            TypeScript.Debug.assert(declsOfObjectType.length === 1);
+            newObjectTypeSymbol.addDeclaration(declsOfObjectType[0]);
+            var members = type.getMembers();
+
+            for (var i = 0; i < members.length; i++) {
+                var memberType = members[i].type;
+
+                var widenedMemberType = members[i].type.widenedType(this, ast, context);
+                var newMember = new TypeScript.PullSymbol(members[i].name, members[i].kind);
+
+                var declsOfMember = members[i].getDeclarations();
+
+                newMember.addDeclaration(declsOfMember[0]);
+                newMember.type = widenedMemberType;
+                newObjectTypeSymbol.addMember(newMember);
+                newMember.setResolved();
+
+                if (this.compilationSettings.noImplicitAny() && ast && widenedMemberType === this.semanticInfoChain.anyTypeSymbol && memberType !== this.semanticInfoChain.anyTypeSymbol) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Object_literal_s_property_0_implicitly_has_an_any_type_from_widening, [members[i].name]));
+                }
+            }
+
+            var indexers = type.getIndexSignatures();
+            for (var i = 0; i < indexers.length; i++) {
+                var newIndexer = new TypeScript.PullSignatureSymbol(4194304 /* IndexSignature */);
+                var parameter = indexers[i].parameters[0];
+                var newParameter = new TypeScript.PullSymbol(parameter.name, parameter.kind);
+                newParameter.type = parameter.type;
+                newIndexer.addParameter(newParameter);
+                newIndexer.returnType = indexers[i].returnType;
+                newObjectTypeSymbol.addIndexSignature(newIndexer);
+            }
+
+            return newObjectTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.needsToWidenObjectLiteralType = function (type, ast, context) {
+            var members = type.getMembers();
+            for (var i = 0; i < members.length; i++) {
+                var memberType = members[i].type;
+                if (memberType !== memberType.widenedType(this, ast, context)) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.findBestCommonType = function (collection, context, comparisonInfo) {
+            var len = collection.getLength();
+
+            for (var i = 0; i < len; i++) {
+                var candidateType = collection.getTypeAtIndex(i);
+                if (this.typeIsBestCommonTypeCandidate(candidateType, collection, context)) {
+                    return candidateType;
+                }
+            }
+
+            return this.semanticInfoChain.emptyTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeIsBestCommonTypeCandidate = function (candidateType, collection, context) {
+            for (var i = 0; i < collection.getLength(); i++) {
+                var otherType = collection.getTypeAtIndex(i);
+                if (candidateType === otherType) {
+                    continue;
+                }
+
+                if (!this.sourceIsSubtypeOfTarget(otherType, candidateType, null, context)) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.typesAreIdenticalInEnclosingTypes = function (t1, t2, context) {
+            t1 = this.getSymbolForRelationshipCheck(t1);
+            t2 = this.getSymbolForRelationshipCheck(t2);
+
+            if (t1 === t2) {
+                return true;
+            }
+
+            if (t1 && t2) {
+                if (context.oneOfClassificationsIsInfinitelyExpanding()) {
+                    return this.infinitelyExpandingTypesAreIdentical(t1, t2, context);
+                }
+            }
+
+            return this.typesAreIdentical(t1, t2, context);
+        };
+
+        PullTypeResolver.prototype.typesAreIdenticalWithNewEnclosingTypes = function (t1, t2, context) {
+            var enclosingTypeWalkers = context.resetEnclosingTypeWalkers();
+            var areTypesIdentical = this.typesAreIdentical(t1, t2, context);
+            context.setEnclosingTypeWalkers(enclosingTypeWalkers);
+            return areTypesIdentical;
+        };
+
+        PullTypeResolver.prototype.typesAreIdentical = function (t1, t2, context) {
+            t1 = this.getSymbolForRelationshipCheck(t1);
+            t2 = this.getSymbolForRelationshipCheck(t2);
+
+            if (t1 === t2) {
+                return true;
+            }
+
+            if (!t1 || !t2) {
+                return false;
+            }
+
+            if (TypeScript.hasFlag(t1.kind, 64 /* Enum */) || TypeScript.hasFlag(t2.kind, 64 /* Enum */)) {
+                return false;
+            }
+
+            if (t1.isPrimitive() && t1.isStringConstant() && t2.isPrimitive() && t2.isStringConstant()) {
+                return TypeScript.stripStartAndEndQuotes(t1.name) === TypeScript.stripStartAndEndQuotes(t2.name);
+            }
+
+            if (t1.isPrimitive() || t2.isPrimitive()) {
+                return false;
+            }
+
+            if (t1.isError() && t2.isError()) {
+                return true;
+            }
+
+            var isIdentical = this.identicalCache.valueAt(t1.pullSymbolID, t2.pullSymbolID);
+            if (isIdentical != undefined) {
+                return isIdentical;
+            }
+
+            if (t1.isTypeParameter() !== t2.isTypeParameter()) {
+                return false;
+            } else if (t1.isTypeParameter()) {
+                var t1ParentDeclaration = t1.getDeclarations()[0].getParentDecl();
+                var t2ParentDeclaration = t2.getDeclarations()[0].getParentDecl();
+
+                if (t1ParentDeclaration === t2ParentDeclaration) {
+                    return this.symbolsShareDeclaration(t1, t2);
+                } else {
+                    return false;
+                }
+            }
+
+            if (t1.isPrimitive() !== t2.isPrimitive()) {
+                return false;
+            }
+
+            this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, true);
+            var symbolsWhenStartedWalkingTypes = context.startWalkingTypes(t1, t2);
+            isIdentical = this.typesAreIdenticalWorker(t1, t2, context);
+            context.endWalkingTypes(symbolsWhenStartedWalkingTypes);
+            this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, isIdentical);
+
+            return isIdentical;
+        };
+
+        PullTypeResolver.prototype.typesAreIdenticalWorker = function (t1, t2, context) {
+            if (t1.getIsSpecialized() && t2.getIsSpecialized()) {
+                if (TypeScript.PullHelpers.getRootType(t1) === TypeScript.PullHelpers.getRootType(t2) && TypeScript.PullHelpers.getRootType(t1).isNamedTypeSymbol()) {
+                    var t1TypeArguments = t1.getTypeArguments();
+                    var t2TypeArguments = t2.getTypeArguments();
+
+                    if (t1TypeArguments && t2TypeArguments) {
+                        for (var i = 0; i < t1TypeArguments.length; i++) {
+                            if (!this.typesAreIdenticalWithNewEnclosingTypes(t1TypeArguments[i], t2TypeArguments[i], context)) {
+                                return false;
+                            }
+                        }
+                    }
+
+                    return true;
+                }
+            }
+
+            if (t1.hasMembers() && t2.hasMembers()) {
+                var t1Members = t1.getAllMembers(68147712 /* SomeValue */, 0 /* all */);
+                var t2Members = t2.getAllMembers(68147712 /* SomeValue */, 0 /* all */);
+
+                if (t1Members.length !== t2Members.length) {
+                    return false;
+                }
+
+                var t1MemberSymbol = null;
+                var t2MemberSymbol = null;
+
+                var t1MemberType = null;
+                var t2MemberType = null;
+
+                for (var iMember = 0; iMember < t1Members.length; iMember++) {
+                    t1MemberSymbol = t1Members[iMember];
+                    t2MemberSymbol = this.getNamedPropertySymbol(t1MemberSymbol.name, 68147712 /* SomeValue */, t2);
+
+                    if (!this.propertiesAreIdentical(t1MemberSymbol, t2MemberSymbol, context)) {
+                        return false;
+                    }
+                }
+            } else if (t1.hasMembers() || t2.hasMembers()) {
+                return false;
+            }
+
+            var t1CallSigs = t1.getCallSignatures();
+            var t2CallSigs = t2.getCallSignatures();
+
+            var t1ConstructSigs = t1.getConstructSignatures();
+            var t2ConstructSigs = t2.getConstructSignatures();
+
+            var t1IndexSigs = t1.getIndexSignatures();
+            var t2IndexSigs = t2.getIndexSignatures();
+
+            if (!this.signatureGroupsAreIdentical(t1CallSigs, t2CallSigs, context)) {
+                return false;
+            }
+
+            if (!this.signatureGroupsAreIdentical(t1ConstructSigs, t2ConstructSigs, context)) {
+                return false;
+            }
+
+            if (!this.signatureGroupsAreIdentical(t1IndexSigs, t2IndexSigs, context)) {
+                return false;
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.propertiesAreIdentical = function (propertySymbol1, propertySymbol2, context) {
+            if (!propertySymbol2 || (propertySymbol1.isOptional !== propertySymbol2.isOptional)) {
+                return false;
+            }
+
+            var t1MemberSymbolIsPrivate = propertySymbol1.anyDeclHasFlag(2 /* Private */);
+            var t2MemberSymbolIsPrivate = propertySymbol2.anyDeclHasFlag(2 /* Private */);
+
+            if (t1MemberSymbolIsPrivate !== t2MemberSymbolIsPrivate) {
+                return false;
+            } else if (t2MemberSymbolIsPrivate && t1MemberSymbolIsPrivate) {
+                var t1MemberSymbolDecl = propertySymbol1.getDeclarations()[0];
+                var sourceDecl = propertySymbol2.getDeclarations()[0];
+                if (t1MemberSymbolDecl !== sourceDecl) {
+                    return false;
+                }
+            }
+
+            var t1MemberType = propertySymbol1.type;
+            var t2MemberType = propertySymbol2.type;
+
+            context.walkMemberTypes(propertySymbol1.name);
+            var areMemberTypesIdentical = this.typesAreIdenticalInEnclosingTypes(t1MemberType, t2MemberType, context);
+            context.postWalkMemberTypes();
+            return areMemberTypesIdentical;
+        };
+
+        PullTypeResolver.prototype.propertiesAreIdenticalWithNewEnclosingTypes = function (type1, type2, property1, property2, context) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(type1, type2);
+            var arePropertiesIdentical = this.propertiesAreIdentical(property1, property2, context);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return arePropertiesIdentical;
+        };
+
+        PullTypeResolver.prototype.signatureGroupsAreIdentical = function (sg1, sg2, context) {
+            if (sg1 === sg2) {
+                return true;
+            }
+
+            if (!sg1 || !sg2) {
+                return false;
+            }
+
+            if (sg1.length !== sg2.length) {
+                return false;
+            }
+
+            for (var i = 0; i < sg1.length; i++) {
+                context.walkSignatures(sg1[i].kind, i);
+                var areSignaturesIdentical = this.signaturesAreIdentical(sg1[i], sg2[i], context, true);
+                context.postWalkSignatures();
+                if (!areSignaturesIdentical) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.typeParametersAreIdentical = function (tp1, tp2, context) {
+            var typeParamsAreIdentical = this.typeParametersAreIdenticalWorker(tp1, tp2, context);
+
+            this.setTypeParameterIdentity(tp1, tp2, undefined);
+
+            return typeParamsAreIdentical;
+        };
+
+        PullTypeResolver.prototype.typeParametersAreIdenticalWorker = function (tp1, tp2, context) {
+            if (!!(tp1 && tp1.length) !== !!(tp2 && tp2.length)) {
+                return false;
+            }
+
+            if (tp1 && tp2 && (tp1.length !== tp2.length)) {
+                return false;
+            }
+
+            if (tp1 && tp2) {
+                for (var i = 0; i < tp1.length; i++) {
+                    context.walkTypeParameterConstraints(i);
+                    var areConstraintsIdentical = this.typesAreIdentical(tp1[i].getConstraint(), tp2[i].getConstraint(), context);
+                    context.postWalkTypeParameterConstraints();
+                    if (!areConstraintsIdentical) {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.setTypeParameterIdentity = function (tp1, tp2, val) {
+            if (tp1 && tp2 && tp1.length === tp2.length) {
+                for (var i = 0; i < tp1.length; i++) {
+                    this.identicalCache.setValueAt(tp1[i].pullSymbolID, tp2[i].pullSymbolID, val);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.signaturesAreIdenticalWithNewEnclosingTypes = function (s1, s2, context, includingReturnType) {
+            if (typeof includingReturnType === "undefined") { includingReturnType = true; }
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(s1, s2);
+            var areSignaturesIdentical = this.signaturesAreIdentical(s1, s2, context, includingReturnType);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return areSignaturesIdentical;
+        };
+
+        PullTypeResolver.prototype.signaturesAreIdentical = function (s1, s2, context, includingReturnType) {
+            if (typeof includingReturnType === "undefined") { includingReturnType = true; }
+            if (s1 === s2) {
+                return true;
+            }
+
+            var signaturesIdentical = this.identicalCache.valueAt(s1.pullSymbolID, s2.pullSymbolID);
+            if (signaturesIdentical || (signaturesIdentical != undefined && includingReturnType)) {
+                return signaturesIdentical;
+            }
+
+            var oldValue = signaturesIdentical;
+            this.identicalCache.setValueAt(s1.pullSymbolID, s2.pullSymbolID, true);
+
+            signaturesIdentical = this.signaturesAreIdenticalWorker(s1, s2, context, includingReturnType);
+
+            if (includingReturnType) {
+                this.identicalCache.setValueAt(s1.pullSymbolID, s2.pullSymbolID, signaturesIdentical);
+            } else {
+                this.identicalCache.setValueAt(s1.pullSymbolID, s2.pullSymbolID, oldValue);
+            }
+
+            return signaturesIdentical;
+        };
+
+        PullTypeResolver.prototype.signaturesAreIdenticalWorker = function (s1, s2, context, includingReturnType) {
+            if (typeof includingReturnType === "undefined") { includingReturnType = true; }
+            if (s1.hasVarArgs !== s2.hasVarArgs) {
+                return false;
+            }
+
+            if (s1.nonOptionalParamCount !== s2.nonOptionalParamCount) {
+                return false;
+            }
+
+            if (s1.parameters.length !== s2.parameters.length) {
+                return false;
+            }
+
+            var s1TypeParameters = s1.getTypeParameters();
+            var s2TypeParameters = s2.getTypeParameters();
+            this.setTypeParameterIdentity(s1TypeParameters, s2TypeParameters, true);
+
+            var typeParametersParametersAndReturnTypesAreIdentical = this.signatureTypeParametersParametersAndReturnTypesAreIdentical(s1, s2, context, includingReturnType);
+
+            this.setTypeParameterIdentity(s1TypeParameters, s2TypeParameters, undefined);
+            return typeParametersParametersAndReturnTypesAreIdentical;
+        };
+
+        PullTypeResolver.prototype.signatureTypeParametersParametersAndReturnTypesAreIdentical = function (s1, s2, context, includingReturnType) {
+            if (!this.typeParametersAreIdenticalWorker(s1.getTypeParameters(), s2.getTypeParameters(), context)) {
+                return false;
+            }
+
+            if (includingReturnType) {
+                TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(s1);
+                TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(s2);
+                context.walkReturnTypes();
+                var areReturnTypesIdentical = this.typesAreIdenticalInEnclosingTypes(s1.returnType, s2.returnType, context);
+                context.postWalkReturnTypes();
+                if (!areReturnTypesIdentical) {
+                    return false;
+                }
+            }
+
+            var s1Params = s1.parameters;
+            var s2Params = s2.parameters;
+
+            for (var iParam = 0; iParam < s1Params.length; iParam++) {
+                TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(s1Params[iParam]);
+                TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(s2Params[iParam]);
+                context.walkParameterTypes(iParam);
+                var areParameterTypesIdentical = this.typesAreIdenticalInEnclosingTypes(s1Params[iParam].type, s2Params[iParam].type, context);
+                context.postWalkParameterTypes();
+
+                if (!areParameterTypesIdentical) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.signatureReturnTypesAreIdentical = function (s1, s2, context) {
+            var s1TypeParameters = s1.getTypeParameters();
+            var s2TypeParameters = s2.getTypeParameters();
+            this.setTypeParameterIdentity(s1TypeParameters, s2TypeParameters, true);
+
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(s1, s2);
+            context.walkReturnTypes();
+            var returnTypeIsIdentical = this.typesAreIdenticalInEnclosingTypes(s1.returnType, s2.returnType, context);
+
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+
+            this.setTypeParameterIdentity(s1TypeParameters, s2TypeParameters, undefined);
+
+            return returnTypeIsIdentical;
+        };
+
+        PullTypeResolver.prototype.symbolsShareDeclaration = function (symbol1, symbol2) {
+            var decls1 = symbol1.getDeclarations();
+            var decls2 = symbol2.getDeclarations();
+
+            if (decls1.length && decls2.length) {
+                return decls1[0] === decls2[0];
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.sourceIsSubtypeOfTarget = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            return this.sourceIsRelatableToTarget(source, target, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+        };
+
+        PullTypeResolver.prototype.sourceMembersAreAssignableToTargetMembers = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(source, target);
+            var areSourceMembersAreAssignableToTargetMembers = this.sourceMembersAreRelatableToTargetMembers(source, target, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return areSourceMembersAreAssignableToTargetMembers;
+        };
+
+        PullTypeResolver.prototype.sourcePropertyIsAssignableToTargetProperty = function (source, target, sourceProp, targetProp, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(source, target);
+            var isSourcePropertyIsAssignableToTargetProperty = this.sourcePropertyIsRelatableToTargetProperty(source, target, sourceProp, targetProp, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return isSourcePropertyIsAssignableToTargetProperty;
+        };
+
+        PullTypeResolver.prototype.sourceCallSignaturesAreAssignableToTargetCallSignatures = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(source, target);
+            var areSourceCallSignaturesAssignableToTargetCallSignatures = this.sourceCallSignaturesAreRelatableToTargetCallSignatures(source, target, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return areSourceCallSignaturesAssignableToTargetCallSignatures;
+        };
+
+        PullTypeResolver.prototype.sourceConstructSignaturesAreAssignableToTargetConstructSignatures = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(source, target);
+            var areSourceConstructSignaturesAssignableToTargetConstructSignatures = this.sourceConstructSignaturesAreRelatableToTargetConstructSignatures(source, target, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return areSourceConstructSignaturesAssignableToTargetConstructSignatures;
+        };
+
+        PullTypeResolver.prototype.sourceIndexSignaturesAreAssignableToTargetIndexSignatures = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(source, target);
+            var areSourceIndexSignaturesAssignableToTargetIndexSignatures = this.sourceIndexSignaturesAreRelatableToTargetIndexSignatures(source, target, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return areSourceIndexSignaturesAssignableToTargetIndexSignatures;
+        };
+
+        PullTypeResolver.prototype.typeIsAssignableToFunction = function (source, ast, context) {
+            if (source.isFunctionType()) {
+                return true;
+            }
+
+            return this.cachedFunctionInterfaceType() && this.sourceIsAssignableToTarget(source, this.cachedFunctionInterfaceType(), ast, context);
+        };
+
+        PullTypeResolver.prototype.signatureIsAssignableToTarget = function (s1, s2, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(s1, s2);
+            var isSignatureIsAssignableToTarget = this.signatureIsRelatableToTarget(s1, s2, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return isSignatureIsAssignableToTarget;
+        };
+
+        PullTypeResolver.prototype.sourceIsAssignableToTarget = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            return this.sourceIsRelatableToTarget(source, target, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+        };
+
+        PullTypeResolver.prototype.sourceIsAssignableToTargetWithNewEnclosingTypes = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            return this.sourceIsRelatableToTargetWithNewEnclosingTypes(source, target, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+        };
+
+        PullTypeResolver.prototype.getSymbolForRelationshipCheck = function (symbol) {
+            if (symbol && symbol.isTypeReference()) {
+                return symbol.getReferencedTypeSymbol();
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.sourceIsRelatableToTargetInEnclosingTypes = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            source = this.getSymbolForRelationshipCheck(source);
+            target = this.getSymbolForRelationshipCheck(target);
+
+            if (source === target) {
+                return true;
+            }
+
+            if (source && target) {
+                if (context.oneOfClassificationsIsInfinitelyExpanding()) {
+                    return this.infinitelyExpandingSourceTypeIsRelatableToTargetType(source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+                }
+            }
+
+            return this.sourceIsRelatableToTarget(source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+        };
+
+        PullTypeResolver.prototype.sourceIsRelatableToTargetWithNewEnclosingTypes = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            var isSourceRelatable = this.sourceIsRelatableToTarget(source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return isSourceRelatable;
+        };
+
+        PullTypeResolver.prototype.sourceIsRelatableToTargetInCache = function (source, target, comparisonCache, comparisonInfo) {
+            var isRelatable = comparisonCache.valueAt(source.pullSymbolID, target.pullSymbolID);
+
+            if (isRelatable) {
+                return { isRelatable: isRelatable };
+            }
+
+            if (isRelatable != undefined && !comparisonInfo) {
+                return { isRelatable: isRelatable };
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.sourceIsRelatableToTarget = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            source = this.getSymbolForRelationshipCheck(source);
+            target = this.getSymbolForRelationshipCheck(target);
+
+            if (source === target) {
+                return true;
+            }
+
+            if (!(source && target)) {
+                return true;
+            }
+
+            var sourceApparentType = this.getApparentType(source);
+
+            var isRelatableInfo = this.sourceIsRelatableToTargetInCache(source, target, comparisonCache, comparisonInfo);
+            if (isRelatableInfo) {
+                return isRelatableInfo.isRelatable;
+            }
+
+            if (source === this.semanticInfoChain.stringTypeSymbol && target.isPrimitive() && target.isStringConstant()) {
+                return comparisonInfo && comparisonInfo.stringConstantVal && (comparisonInfo.stringConstantVal.kind() === 14 /* StringLiteral */) && (TypeScript.stripStartAndEndQuotes(comparisonInfo.stringConstantVal.text()) === TypeScript.stripStartAndEndQuotes(target.name));
+            }
+
+            if (assignableTo) {
+                if (this.isAnyOrEquivalent(source) || this.isAnyOrEquivalent(target)) {
+                    return true;
+                }
+            } else {
+                if (this.isAnyOrEquivalent(target)) {
+                    return true;
+                }
+            }
+
+            if (target === this.semanticInfoChain.stringTypeSymbol && source.isPrimitive() && source.isStringConstant()) {
+                return true;
+            }
+
+            if (source.isPrimitive() && source.isStringConstant() && target.isPrimitive() && target.isStringConstant()) {
+                return TypeScript.stripStartAndEndQuotes(source.name) === TypeScript.stripStartAndEndQuotes(target.name);
+            }
+
+            if (source === this.semanticInfoChain.undefinedTypeSymbol) {
+                return true;
+            }
+
+            if ((source === this.semanticInfoChain.nullTypeSymbol) && (target !== this.semanticInfoChain.undefinedTypeSymbol && target != this.semanticInfoChain.voidTypeSymbol)) {
+                return true;
+            }
+
+            if (target === this.semanticInfoChain.voidTypeSymbol) {
+                if (source === this.semanticInfoChain.undefinedTypeSymbol || source == this.semanticInfoChain.nullTypeSymbol) {
+                    return true;
+                }
+
+                return false;
+            } else if (source === this.semanticInfoChain.voidTypeSymbol) {
+                if (target === this.semanticInfoChain.anyTypeSymbol) {
+                    return true;
+                }
+
+                return false;
+            }
+
+            if (target === this.semanticInfoChain.numberTypeSymbol && TypeScript.PullHelpers.symbolIsEnum(source)) {
+                return true;
+            }
+
+            if (source === this.semanticInfoChain.numberTypeSymbol && TypeScript.PullHelpers.symbolIsEnum(target)) {
+                return assignableTo;
+            }
+
+            if (TypeScript.PullHelpers.symbolIsEnum(target) && TypeScript.PullHelpers.symbolIsEnum(source)) {
+                return this.symbolsShareDeclaration(target, source);
+            }
+
+            if ((source.kind & 64 /* Enum */) || (target.kind & 64 /* Enum */)) {
+                return false;
+            }
+
+            if (source.getIsSpecialized() && target.getIsSpecialized()) {
+                if (TypeScript.PullHelpers.getRootType(source) === TypeScript.PullHelpers.getRootType(target) && TypeScript.PullHelpers.getRootType(source).isNamedTypeSymbol()) {
+                    var sourceTypeArguments = source.getTypeArguments();
+                    var targetTypeArguments = target.getTypeArguments();
+
+                    if (sourceTypeArguments && targetTypeArguments) {
+                        comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, true);
+
+                        for (var i = 0; i < sourceTypeArguments.length; i++) {
+                            if (!this.sourceIsRelatableToTargetWithNewEnclosingTypes(sourceTypeArguments[i], targetTypeArguments[i], assignableTo, comparisonCache, ast, context, null, isComparingInstantiatedSignatures)) {
+                                break;
+                            }
+                        }
+
+                        if (i === sourceTypeArguments.length) {
+                            return true;
+                        } else {
+                            comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, undefined);
+                        }
+                    }
+                }
+            }
+
+            if (target.isTypeParameter()) {
+                if (source.isTypeParameter()) {
+                    if (!source.getConstraint()) {
+                        return this.typesAreIdentical(target, source, context);
+                    } else {
+                        return this.isSourceTypeParameterConstrainedToTargetTypeParameter(source, target);
+                    }
+                } else {
+                    if (isComparingInstantiatedSignatures) {
+                        target = target.getBaseConstraint(this.semanticInfoChain);
+                    } else {
+                        return this.typesAreIdentical(target, sourceApparentType, context);
+                    }
+                }
+            }
+
+            if (sourceApparentType.isPrimitive() || target.isPrimitive()) {
+                return false;
+            }
+
+            comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, true);
+
+            var symbolsWhenStartedWalkingTypes = context.startWalkingTypes(sourceApparentType, target);
+
+            var needsSourceSubstitutionUpdate = source != sourceApparentType && context.enclosingTypeWalker1._canWalkStructure() && context.enclosingTypeWalker1._getCurrentSymbol() != sourceApparentType;
+            if (needsSourceSubstitutionUpdate) {
+                context.enclosingTypeWalker1.setCurrentSymbol(sourceApparentType);
+            }
+
+            var isRelatable = this.sourceIsRelatableToTargetWorker(source, target, sourceApparentType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+
+            if (needsSourceSubstitutionUpdate) {
+                context.enclosingTypeWalker1.setCurrentSymbol(source);
+            }
+            context.endWalkingTypes(symbolsWhenStartedWalkingTypes);
+
+            comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, isRelatable);
+            return isRelatable;
+        };
+
+        PullTypeResolver.prototype.isSourceTypeParameterConstrainedToTargetTypeParameter = function (source, target) {
+            var current = source;
+            while (current && current.isTypeParameter()) {
+                if (current === target) {
+                    return true;
+                }
+
+                current = current.getConstraint();
+            }
+            return false;
+        };
+
+        PullTypeResolver.prototype.sourceIsRelatableToTargetWorker = function (source, target, sourceSubstitution, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            if (target.hasMembers() && !this.sourceMembersAreRelatableToTargetMembers(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) {
+                return false;
+            }
+
+            if (!this.sourceCallSignaturesAreRelatableToTargetCallSignatures(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) {
+                return false;
+            }
+
+            if (!this.sourceConstructSignaturesAreRelatableToTargetConstructSignatures(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) {
+                return false;
+            }
+
+            if (!this.sourceIndexSignaturesAreRelatableToTargetIndexSignatures(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) {
+                return false;
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.sourceMembersAreRelatableToTargetMembers = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var targetProps = target.getAllMembers(68147712 /* SomeValue */, 0 /* all */);
+
+            for (var itargetProp = 0; itargetProp < targetProps.length; itargetProp++) {
+                var targetProp = targetProps[itargetProp];
+
+                var sourceProp = this._getNamedPropertySymbolOfAugmentedType(targetProp.name, source);
+
+                this.resolveDeclaredSymbol(targetProp, context);
+
+                var targetPropType = targetProp.type;
+
+                if (!sourceProp) {
+                    if (!(targetProp.isOptional)) {
+                        if (comparisonInfo) {
+                            var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                            comparisonInfo.flags |= 2 /* RequiredPropertyIsMissing */;
+                            comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_0_is_missing_property_1_from_type_2, [source.toString(enclosingSymbol), targetProp.getScopedNameEx().toString(), target.toString(enclosingSymbol)]));
+                        }
+                        return false;
+                    }
+                    continue;
+                }
+
+                if (!this.sourcePropertyIsRelatableToTargetProperty(source, target, sourceProp, targetProp, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.infinitelyExpandingSourceTypeIsRelatableToTargetType = function (sourceType, targetType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var widenedTargetType = targetType.widenedType(this, null, context);
+            var widenedSourceType = sourceType.widenedType(this, null, context);
+
+            if ((widenedSourceType !== this.semanticInfoChain.anyTypeSymbol) && (widenedTargetType !== this.semanticInfoChain.anyTypeSymbol)) {
+                var sourceTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(sourceType);
+                var targetTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(targetType);
+
+                if (sourceTypeNamedTypeReference !== targetTypeNamedTypeReference) {
+                    comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false);
+                    if (comparisonInfo) {
+                        var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                        comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_infinitely_expanding_type_reference_do_not_refer_to_same_named_type, [sourceType.getScopedNameEx(enclosingSymbol).toString(), targetType.toString(enclosingSymbol)]));
+                    }
+                    return false;
+                }
+
+                var sourceTypeArguments = sourceType.getTypeArguments();
+                var targetTypeArguments = targetType.getTypeArguments();
+
+                if (!sourceTypeArguments && !targetTypeArguments) {
+                    comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, true);
+                    return true;
+                }
+
+                if (!(sourceTypeArguments && targetTypeArguments) || sourceTypeArguments.length !== targetTypeArguments.length) {
+                    comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false);
+                    if (comparisonInfo) {
+                        var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                        comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_infinitely_expanding_type_reference_have_incompatible_type_arguments, [sourceType.toString(enclosingSymbol), targetType.toString(enclosingSymbol)]));
+                    }
+                    return false;
+                }
+
+                var comparisonInfoTypeArgumentsCheck = null;
+                if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) {
+                    comparisonInfoTypeArgumentsCheck = new TypeComparisonInfo(comparisonInfo);
+                }
+                var isRelatable = true;
+                for (var i = 0; i < sourceTypeArguments.length && isRelatable; i++) {
+                    context.walkTypeArgument(i);
+
+                    if (!this.sourceIsRelatableToTargetInEnclosingTypes(sourceTypeArguments[i], targetTypeArguments[i], assignableTo, comparisonCache, ast, context, comparisonInfoTypeArgumentsCheck, isComparingInstantiatedSignatures)) {
+                        isRelatable = false;
+                        if (comparisonInfo) {
+                            var message;
+                            var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+
+                            if (comparisonInfoTypeArgumentsCheck && comparisonInfoTypeArgumentsCheck.message) {
+                                message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_infinitely_expanding_type_reference_have_incompatible_type_arguments_NL_2, [sourceType.toString(enclosingSymbol), targetType.toString(enclosingSymbol), comparisonInfoTypeArgumentsCheck.message]);
+                            } else {
+                                message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_infinitely_expanding_type_reference_have_incompatible_type_arguments, [sourceType.toString(enclosingSymbol), targetType.toString(enclosingSymbol)]);
+                            }
+                            comparisonInfo.addMessage(message);
+                        }
+                    }
+
+                    context.postWalkTypeArgument();
+                }
+            }
+
+            comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, isRelatable);
+            return isRelatable;
+        };
+
+        PullTypeResolver.prototype.infinitelyExpandingTypesAreIdentical = function (sourceType, targetType, context) {
+            var widenedTargetType = targetType.widenedType(this, null, null);
+            var widenedSourceType = sourceType.widenedType(this, null, null);
+
+            if ((widenedSourceType !== this.semanticInfoChain.anyTypeSymbol) && (widenedTargetType !== this.semanticInfoChain.anyTypeSymbol)) {
+                var sourceTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(sourceType);
+                var targetTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(targetType);
+                if (sourceTypeNamedTypeReference !== targetTypeNamedTypeReference) {
+                    this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false);
+                    return false;
+                }
+
+                var sourceTypeArguments = sourceType.getTypeArguments();
+                var targetTypeArguments = targetType.getTypeArguments();
+
+                if (!sourceTypeArguments && !targetTypeArguments) {
+                    this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, true);
+                    return true;
+                }
+
+                if (!(sourceTypeArguments && targetTypeArguments) || sourceTypeArguments.length !== targetTypeArguments.length) {
+                    this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false);
+                    return false;
+                }
+
+                for (var i = 0; i < sourceTypeArguments.length; i++) {
+                    context.walkTypeArgument(i);
+                    var areIdentical = this.typesAreIdenticalInEnclosingTypes(sourceTypeArguments[i], targetTypeArguments[i], context);
+                    context.postWalkTypeArgument();
+
+                    if (!areIdentical) {
+                        this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false);
+                        return false;
+                    }
+                }
+            }
+
+            this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, true);
+            return true;
+        };
+
+        PullTypeResolver.prototype.sourcePropertyIsRelatableToTargetProperty = function (source, target, sourceProp, targetProp, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var _this = this;
+            var sourceAndTargetAreConstructors = source.isConstructor() && target.isConstructor();
+
+            var getNames = function (takeTypesFromPropertyContainers) {
+                var enclosingSymbol = _this.getEnclosingSymbolForAST(ast);
+                var sourceType = takeTypesFromPropertyContainers ? sourceProp.getContainer() : source;
+                var targetType = takeTypesFromPropertyContainers ? targetProp.getContainer() : target;
+                if (sourceAndTargetAreConstructors) {
+                    sourceType = sourceType.getAssociatedContainerType();
+                    targetType = targetType.getAssociatedContainerType();
+                }
+                return {
+                    propertyName: targetProp.getScopedNameEx().toString(),
+                    sourceTypeName: sourceType.toString(enclosingSymbol),
+                    targetTypeName: targetType.toString(enclosingSymbol)
+                };
+            };
+
+            var targetPropIsPrivate = targetProp.anyDeclHasFlag(2 /* Private */);
+            var sourcePropIsPrivate = sourceProp.anyDeclHasFlag(2 /* Private */);
+
+            if (targetPropIsPrivate !== sourcePropIsPrivate) {
+                if (comparisonInfo) {
+                    var names = getNames(true);
+                    var code;
+                    if (targetPropIsPrivate) {
+                        code = sourceAndTargetAreConstructors ? TypeScript.DiagnosticCode.Static_property_0_defined_as_public_in_type_1_is_defined_as_private_in_type_2 : TypeScript.DiagnosticCode.Property_0_defined_as_public_in_type_1_is_defined_as_private_in_type_2;
+                    } else {
+                        code = sourceAndTargetAreConstructors ? TypeScript.DiagnosticCode.Static_property_0_defined_as_private_in_type_1_is_defined_as_public_in_type_2 : TypeScript.DiagnosticCode.Property_0_defined_as_private_in_type_1_is_defined_as_public_in_type_2;
+                    }
+                    comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(code, [names.propertyName, names.sourceTypeName, names.targetTypeName]));
+                    comparisonInfo.flags |= 128 /* InconsistantPropertyAccesibility */;
+                }
+                return false;
+            } else if (sourcePropIsPrivate && targetPropIsPrivate) {
+                var targetDecl = targetProp.getDeclarations()[0];
+                var sourceDecl = sourceProp.getDeclarations()[0];
+
+                if (targetDecl !== sourceDecl) {
+                    if (comparisonInfo) {
+                        var names = getNames(true);
+
+                        comparisonInfo.flags |= 128 /* InconsistantPropertyAccesibility */;
+                        var code = sourceAndTargetAreConstructors ? TypeScript.DiagnosticCode.Types_0_and_1_define_static_property_2_as_private : TypeScript.DiagnosticCode.Types_0_and_1_define_property_2_as_private;
+                        comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(code, [names.sourceTypeName, names.targetTypeName, names.propertyName]));
+                    }
+
+                    return false;
+                }
+            }
+
+            if (sourceProp.isOptional && !targetProp.isOptional) {
+                if (comparisonInfo) {
+                    var names = getNames(true);
+                    comparisonInfo.flags |= 2 /* RequiredPropertyIsMissing */;
+                    comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Property_0_defined_as_optional_in_type_1_but_is_required_in_type_2, [names.propertyName, names.sourceTypeName, names.targetTypeName]));
+                }
+                return false;
+            }
+
+            this.resolveDeclaredSymbol(sourceProp, context);
+
+            var sourcePropType = sourceProp.type;
+            var targetPropType = targetProp.type;
+
+            var isRelatableInfo = this.sourceIsRelatableToTargetInCache(sourcePropType, targetPropType, comparisonCache, comparisonInfo);
+            if (isRelatableInfo) {
+                return isRelatableInfo.isRelatable;
+            }
+
+            var comparisonInfoPropertyTypeCheck = null;
+            if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) {
+                comparisonInfoPropertyTypeCheck = new TypeComparisonInfo(comparisonInfo);
+            }
+
+            context.walkMemberTypes(targetProp.name);
+            var isSourcePropertyRelatableToTargetProperty = this.sourceIsRelatableToTargetInEnclosingTypes(sourcePropType, targetPropType, assignableTo, comparisonCache, ast, context, comparisonInfoPropertyTypeCheck, isComparingInstantiatedSignatures);
+            context.postWalkMemberTypes();
+
+            if (!isSourcePropertyRelatableToTargetProperty && comparisonInfo) {
+                var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                comparisonInfo.flags |= 32 /* IncompatiblePropertyTypes */;
+                var message;
+                var names = getNames(false);
+                if (comparisonInfoPropertyTypeCheck && comparisonInfoPropertyTypeCheck.message) {
+                    var code = sourceAndTargetAreConstructors ? TypeScript.DiagnosticCode.Types_of_static_property_0_of_class_1_and_class_2_are_incompatible_NL_3 : TypeScript.DiagnosticCode.Types_of_property_0_of_types_1_and_2_are_incompatible_NL_3;
+                    message = TypeScript.getDiagnosticMessage(code, [names.propertyName, names.sourceTypeName, names.targetTypeName, comparisonInfoPropertyTypeCheck.message]);
+                } else {
+                    var code = sourceAndTargetAreConstructors ? TypeScript.DiagnosticCode.Types_of_static_property_0_of_class_1_and_class_2_are_incompatible : TypeScript.DiagnosticCode.Types_of_property_0_of_types_1_and_2_are_incompatible;
+                    message = TypeScript.getDiagnosticMessage(code, [names.propertyName, names.sourceTypeName, names.targetTypeName]);
+                }
+                comparisonInfo.addMessage(message);
+            }
+
+            return isSourcePropertyRelatableToTargetProperty;
+        };
+
+        PullTypeResolver.prototype.sourceCallSignaturesAreRelatableToTargetCallSignatures = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var targetCallSigs = target.getCallSignatures();
+
+            if (targetCallSigs.length) {
+                var comparisonInfoSignatuesTypeCheck = null;
+                if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) {
+                    comparisonInfoSignatuesTypeCheck = new TypeComparisonInfo(comparisonInfo);
+                }
+
+                var sourceCallSigs = source.getCallSignatures();
+                if (!this.signatureGroupIsRelatableToTarget(source, target, sourceCallSigs, targetCallSigs, assignableTo, comparisonCache, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures)) {
+                    if (comparisonInfo) {
+                        var message;
+                        var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                        if (sourceCallSigs.length && targetCallSigs.length) {
+                            if (comparisonInfoSignatuesTypeCheck && comparisonInfoSignatuesTypeCheck.message) {
+                                message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Call_signatures_of_types_0_and_1_are_incompatible_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfoSignatuesTypeCheck.message]);
+                            } else {
+                                message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Call_signatures_of_types_0_and_1_are_incompatible, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)]);
+                            }
+                        } else {
+                            var hasSig = targetCallSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol);
+                            var lacksSig = !targetCallSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol);
+                            message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_0_requires_a_call_signature_but_type_1_lacks_one, [hasSig, lacksSig]);
+                        }
+                        comparisonInfo.flags |= 4 /* IncompatibleSignatures */;
+                        comparisonInfo.addMessage(message);
+                    }
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.sourceConstructSignaturesAreRelatableToTargetConstructSignatures = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var targetConstructSigs = target.getConstructSignatures();
+            if (targetConstructSigs.length) {
+                var comparisonInfoSignatuesTypeCheck = null;
+                if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) {
+                    comparisonInfoSignatuesTypeCheck = new TypeComparisonInfo(comparisonInfo);
+                }
+
+                var sourceConstructSigs = source.getConstructSignatures();
+                if (!this.signatureGroupIsRelatableToTarget(source, target, sourceConstructSigs, targetConstructSigs, assignableTo, comparisonCache, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures)) {
+                    if (comparisonInfo) {
+                        var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                        var message;
+                        if (sourceConstructSigs.length && targetConstructSigs.length) {
+                            if (comparisonInfoSignatuesTypeCheck && comparisonInfoSignatuesTypeCheck.message) {
+                                message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Construct_signatures_of_types_0_and_1_are_incompatible_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfoSignatuesTypeCheck.message]);
+                            } else {
+                                message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Construct_signatures_of_types_0_and_1_are_incompatible, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)]);
+                            }
+                        } else {
+                            var hasSig = targetConstructSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol);
+                            var lacksSig = !targetConstructSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol);
+                            message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_0_requires_a_construct_signature_but_type_1_lacks_one, [hasSig, lacksSig]);
+                        }
+                        comparisonInfo.flags |= 4 /* IncompatibleSignatures */;
+                        comparisonInfo.addMessage(message);
+                    }
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.sourceIndexSignaturesAreRelatableToTargetIndexSignatures = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var targetIndexSigs = this.getBothKindsOfIndexSignaturesExcludingAugmentedType(target, context);
+            var targetStringSig = targetIndexSigs.stringSignature;
+            var targetNumberSig = targetIndexSigs.numericSignature;
+
+            if (targetStringSig || targetNumberSig) {
+                var sourceIndexSigs = this.getBothKindsOfIndexSignaturesIncludingAugmentedType(source, context);
+                var enclosingTypeIndexSigs = context.getBothKindOfIndexSignatures(true, false);
+                var sourceStringSig = sourceIndexSigs.stringSignature;
+                var sourceNumberSig = sourceIndexSigs.numericSignature;
+
+                var comparable = true;
+                var comparisonInfoSignatuesTypeCheck = null;
+                if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) {
+                    comparisonInfoSignatuesTypeCheck = new TypeComparisonInfo(comparisonInfo);
+                }
+
+                if (targetStringSig) {
+                    if (sourceStringSig) {
+                        context.walkIndexSignatureReturnTypes(enclosingTypeIndexSigs, true, true);
+                        comparable = this.sourceIsRelatableToTargetInEnclosingTypes(sourceStringSig.returnType, targetStringSig.returnType, assignableTo, comparisonCache, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures);
+                        context.postWalkIndexSignatureReturnTypes();
+                    } else {
+                        comparable = false;
+                    }
+                }
+
+                if (comparable && targetNumberSig) {
+                    if (sourceNumberSig) {
+                        context.walkIndexSignatureReturnTypes(enclosingTypeIndexSigs, false, false);
+                        comparable = this.sourceIsRelatableToTargetInEnclosingTypes(sourceNumberSig.returnType, targetNumberSig.returnType, assignableTo, comparisonCache, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures);
+                        context.postWalkIndexSignatureReturnTypes();
+                    } else if (sourceStringSig) {
+                        context.walkIndexSignatureReturnTypes(enclosingTypeIndexSigs, true, false);
+                        comparable = this.sourceIsRelatableToTargetInEnclosingTypes(sourceStringSig.returnType, targetNumberSig.returnType, assignableTo, comparisonCache, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures);
+                        context.postWalkIndexSignatureReturnTypes();
+                    } else {
+                        comparable = false;
+                    }
+                }
+
+                if (!comparable) {
+                    if (comparisonInfo) {
+                        var message;
+                        var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                        if (comparisonInfoSignatuesTypeCheck && comparisonInfoSignatuesTypeCheck.message) {
+                            message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Index_signatures_of_types_0_and_1_are_incompatible_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfoSignatuesTypeCheck.message]);
+                        } else {
+                            message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Index_signatures_of_types_0_and_1_are_incompatible, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)]);
+                        }
+                        comparisonInfo.flags |= 4 /* IncompatibleSignatures */;
+                        comparisonInfo.addMessage(message);
+                    }
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.signatureGroupIsRelatableToTarget = function (source, target, sourceSG, targetSG, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            if (sourceSG === targetSG) {
+                return true;
+            }
+
+            if (!(sourceSG.length && targetSG.length)) {
+                return false;
+            }
+
+            var foundMatch = false;
+
+            var targetExcludeDefinition = targetSG.length > 1;
+            var sourceExcludeDefinition = sourceSG.length > 1;
+            var sigsCompared = 0;
+            var comparisonInfoSignatuesTypeCheck = null;
+            if (comparisonInfo) {
+                comparisonInfoSignatuesTypeCheck = new TypeComparisonInfo(comparisonInfo, true);
+                comparisonInfoSignatuesTypeCheck.message = comparisonInfo.message;
+            }
+            for (var iMSig = 0; iMSig < targetSG.length; iMSig++) {
+                var mSig = targetSG[iMSig];
+
+                if (mSig.isStringConstantOverloadSignature() || (targetExcludeDefinition && mSig.isDefinition())) {
+                    continue;
+                }
+
+                for (var iNSig = 0; iNSig < sourceSG.length; iNSig++) {
+                    var nSig = sourceSG[iNSig];
+
+                    if (nSig.isStringConstantOverloadSignature() || (sourceExcludeDefinition && nSig.isDefinition())) {
+                        continue;
+                    }
+
+                    context.walkSignatures(nSig.kind, iNSig, iMSig);
+                    var isSignatureRelatableToTarget = this.signatureIsRelatableToTarget(nSig, mSig, assignableTo, comparisonCache, ast, context, sigsCompared == 0 ? comparisonInfoSignatuesTypeCheck : null, isComparingInstantiatedSignatures);
+                    context.postWalkSignatures();
+
+                    sigsCompared++;
+
+                    if (isSignatureRelatableToTarget) {
+                        foundMatch = true;
+                        break;
+                    }
+                }
+
+                if (foundMatch) {
+                    foundMatch = false;
+                    continue;
+                }
+
+                if (comparisonInfo && sigsCompared == 1) {
+                    comparisonInfo.message = comparisonInfoSignatuesTypeCheck.message;
+                }
+
+                return false;
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.signatureIsRelatableToTarget = function (sourceSig, targetSig, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var isRelatableInfo = this.sourceIsRelatableToTargetInCache(sourceSig, targetSig, comparisonCache, comparisonInfo);
+            if (isRelatableInfo) {
+                return isRelatableInfo.isRelatable;
+            }
+
+            comparisonCache.setValueAt(sourceSig.pullSymbolID, targetSig.pullSymbolID, true);
+            var isRelatable = this.signatureIsRelatableToTargetWorker(sourceSig, targetSig, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            comparisonCache.setValueAt(sourceSig.pullSymbolID, targetSig.pullSymbolID, isRelatable);
+            return isRelatable;
+        };
+
+        PullTypeResolver.prototype.signatureIsRelatableToTargetWorker = function (sourceSig, targetSig, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var _this = this;
+            var sourceParameters = sourceSig.parameters;
+            var targetParameters = targetSig.parameters;
+
+            if (!sourceParameters || !targetParameters) {
+                return false;
+            }
+
+            var targetNonOptionalParamCount = targetSig.nonOptionalParamCount;
+            var sourceNonOptionalParamCount = sourceSig.nonOptionalParamCount;
+
+            if (!targetSig.hasVarArgs && sourceNonOptionalParamCount > targetParameters.length) {
+                if (comparisonInfo) {
+                    comparisonInfo.flags |= 3 /* SourceSignatureHasTooManyParameters */;
+                    comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Call_signature_expects_0_or_fewer_parameters, [targetParameters.length]));
+                }
+                return false;
+            }
+
+            if (this.signaturesAreIdentical(sourceSig, targetSig, context)) {
+                return true;
+            }
+
+            if (targetSig.isGeneric()) {
+                targetSig = this.instantiateSignatureToAny(targetSig);
+            }
+
+            if (sourceSig.isGeneric()) {
+                sourceSig = this.instantiateSignatureToAny(sourceSig);
+            }
+
+            var sourceReturnType = sourceSig.returnType;
+            var targetReturnType = targetSig.returnType;
+
+            if (targetReturnType !== this.semanticInfoChain.voidTypeSymbol) {
+                context.walkReturnTypes();
+                var returnTypesAreRelatable = this.sourceIsRelatableToTargetInEnclosingTypes(sourceReturnType, targetReturnType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+                context.postWalkReturnTypes();
+                if (!returnTypesAreRelatable) {
+                    if (comparisonInfo) {
+                        comparisonInfo.flags |= 16 /* IncompatibleReturnTypes */;
+                    }
+
+                    return false;
+                }
+            }
+
+            return targetSig.forAllCorrespondingParameterTypesInThisAndOtherSignature(sourceSig, function (targetParamType, sourceParamType, iParam) {
+                context.walkParameterTypes(iParam);
+                var areParametersRelatable = _this.sourceIsRelatableToTargetInEnclosingTypes(sourceParamType, targetParamType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+                if (!areParametersRelatable) {
+                    context.swapEnclosingTypeWalkers();
+                    areParametersRelatable = _this.sourceIsRelatableToTargetInEnclosingTypes(targetParamType, sourceParamType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+                    context.swapEnclosingTypeWalkers();
+                }
+                context.postWalkParameterTypes();
+
+                if (!areParametersRelatable) {
+                    if (comparisonInfo) {
+                        comparisonInfo.flags |= 64 /* IncompatibleParameterTypes */;
+                    }
+                }
+
+                return areParametersRelatable;
+            });
+        };
+
+        PullTypeResolver.prototype.resolveOverloads = function (application, group, haveTypeArgumentsAtCallSite, context, diagnostics) {
+            var _this = this;
+            var hasOverloads = group.length > 1;
+            var comparisonInfo = new TypeComparisonInfo();
+            var args = application.argumentList ? application.argumentList.arguments : null;
+
+            var initialCandidates = TypeScript.ArrayUtilities.where(group, function (signature) {
+                if (hasOverloads && signature.isDefinition()) {
+                    return false;
+                }
+
+                var rootSignature = signature.getRootSymbol();
+                if (haveTypeArgumentsAtCallSite && !rootSignature.isGeneric()) {
+                    return false;
+                }
+
+                return _this.overloadHasCorrectArity(signature, args);
+            });
+
+            var firstAssignableButNotSupertypeSignature = null;
+            var firstAssignableWithProvisionalErrorsSignature = null;
+
+            for (var i = 0; i < initialCandidates.length; i++) {
+                var applicability = this.overloadIsApplicable(initialCandidates[i], args, context, comparisonInfo);
+                if (applicability === 3 /* Subtype */) {
+                    return initialCandidates[i];
+                } else if (applicability === 2 /* AssignableWithNoProvisionalErrors */ && !firstAssignableButNotSupertypeSignature) {
+                    firstAssignableButNotSupertypeSignature = initialCandidates[i];
+                } else if (applicability === 1 /* AssignableButWithProvisionalErrors */ && !firstAssignableWithProvisionalErrorsSignature) {
+                    firstAssignableWithProvisionalErrorsSignature = initialCandidates[i];
+                }
+            }
+
+            if (firstAssignableButNotSupertypeSignature || firstAssignableWithProvisionalErrorsSignature) {
+                return firstAssignableButNotSupertypeSignature || firstAssignableWithProvisionalErrorsSignature;
+            } else {
+                var target = this.getCallTargetErrorSpanAST(application);
+                if (comparisonInfo.message) {
+                    diagnostics.push(this.semanticInfoChain.diagnosticFromAST(target, TypeScript.DiagnosticCode.Supplied_parameters_do_not_match_any_signature_of_call_target_NL_0, [comparisonInfo.message]));
+                } else {
+                    diagnostics.push(this.semanticInfoChain.diagnosticFromAST(target, TypeScript.DiagnosticCode.Supplied_parameters_do_not_match_any_signature_of_call_target, null));
+                }
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.getCallTargetErrorSpanAST = function (callEx) {
+            return (callEx.expression.kind() === 212 /* MemberAccessExpression */) ? callEx.expression.name : callEx.expression;
+        };
+
+        PullTypeResolver.prototype.overloadHasCorrectArity = function (signature, args) {
+            if (args == null) {
+                return signature.nonOptionalParamCount === 0;
+            }
+
+            var numberOfArgs = (args.nonSeparatorCount() && args.nonSeparatorCount() === args.separatorCount()) ? args.separatorCount() + 1 : args.nonSeparatorCount();
+            if (numberOfArgs < signature.nonOptionalParamCount) {
+                return false;
+            }
+            if (!signature.hasVarArgs && numberOfArgs > signature.parameters.length) {
+                return false;
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.overloadIsApplicable = function (signature, args, context, comparisonInfo) {
+            if (args === null) {
+                return 3 /* Subtype */;
+            }
+
+            var isInVarArg = false;
+            var parameters = signature.parameters;
+            var paramType = null;
+
+            var overloadApplicability = 3 /* Subtype */;
+
+            for (var i = 0; i < args.nonSeparatorCount(); i++) {
+                if (!isInVarArg) {
+                    this.resolveDeclaredSymbol(parameters[i], context);
+
+                    if (parameters[i].isVarArg) {
+                        paramType = parameters[i].type.getElementType() || this.getNewErrorTypeSymbol(parameters[i].type.getName());
+                        isInVarArg = true;
+                    } else {
+                        paramType = parameters[i].type;
+                    }
+                }
+
+                var statusOfCurrentArgument = this.overloadIsApplicableForArgument(paramType, args.nonSeparatorAt(i), i, context, comparisonInfo);
+
+                if (statusOfCurrentArgument === 0 /* NotAssignable */) {
+                    return 0 /* NotAssignable */;
+                } else if (statusOfCurrentArgument === 1 /* AssignableButWithProvisionalErrors */) {
+                    overloadApplicability = 1 /* AssignableButWithProvisionalErrors */;
+                } else if (overloadApplicability !== 1 /* AssignableButWithProvisionalErrors */ && statusOfCurrentArgument === 2 /* AssignableWithNoProvisionalErrors */) {
+                    overloadApplicability = 2 /* AssignableWithNoProvisionalErrors */;
+                }
+            }
+
+            return overloadApplicability;
+        };
+
+        PullTypeResolver.prototype.overloadIsApplicableForArgument = function (paramType, arg, argIndex, context, comparisonInfo) {
+            if (paramType.isAny()) {
+                return 3 /* Subtype */;
+            } else if (paramType.isError()) {
+                return 1 /* AssignableButWithProvisionalErrors */;
+            } else if (arg.kind() === 219 /* SimpleArrowFunctionExpression */) {
+                var simpleArrowFunction = arg;
+                return this.overloadIsApplicableForAnyFunctionExpressionArgument(paramType, arg, null, TypeScript.ASTHelpers.parametersFromIdentifier(simpleArrowFunction.identifier), null, simpleArrowFunction.block, simpleArrowFunction.expression, argIndex, context, comparisonInfo);
+            } else if (arg.kind() === 218 /* ParenthesizedArrowFunctionExpression */) {
+                var arrowFunction = arg;
+                return this.overloadIsApplicableForAnyFunctionExpressionArgument(paramType, arg, arrowFunction.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(arrowFunction.callSignature.parameterList), TypeScript.ASTHelpers.getType(arrowFunction), arrowFunction.block, arrowFunction.expression, argIndex, context, comparisonInfo);
+            } else if (arg.kind() === 222 /* FunctionExpression */) {
+                var functionExpression = arg;
+                return this.overloadIsApplicableForAnyFunctionExpressionArgument(paramType, arg, functionExpression.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(functionExpression.callSignature.parameterList), TypeScript.ASTHelpers.getType(functionExpression), functionExpression.block, null, argIndex, context, comparisonInfo);
+            } else if (arg.kind() === 215 /* ObjectLiteralExpression */) {
+                return this.overloadIsApplicableForObjectLiteralArgument(paramType, arg, argIndex, context, comparisonInfo);
+            } else if (arg.kind() === 214 /* ArrayLiteralExpression */) {
+                return this.overloadIsApplicableForArrayLiteralArgument(paramType, arg, argIndex, context, comparisonInfo);
+            } else {
+                return this.overloadIsApplicableForOtherArgument(paramType, arg, argIndex, context, comparisonInfo);
+            }
+        };
+
+        PullTypeResolver.prototype.overloadIsApplicableForAnyFunctionExpressionArgument = function (paramType, arg, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, argIndex, context, comparisonInfo) {
+            if (this.cachedFunctionInterfaceType() && paramType === this.cachedFunctionInterfaceType()) {
+                return 2 /* AssignableWithNoProvisionalErrors */;
+            }
+
+            context.pushProvisionalType(paramType);
+
+            var argSym = this.resolveAnyFunctionExpression(arg, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, true, context);
+
+            var applicabilityStatus = this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context);
+
+            context.popAnyContextualType();
+
+            return applicabilityStatus;
+        };
+
+        PullTypeResolver.prototype.overloadIsApplicableForObjectLiteralArgument = function (paramType, arg, argIndex, context, comparisonInfo) {
+            if (this.cachedObjectInterfaceType() && paramType === this.cachedObjectInterfaceType()) {
+                return 2 /* AssignableWithNoProvisionalErrors */;
+            }
+
+            context.pushProvisionalType(paramType);
+            var argSym = this.resolveObjectLiteralExpression(arg, true, context);
+
+            var applicabilityStatus = this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context);
+
+            context.popAnyContextualType();
+
+            return applicabilityStatus;
+        };
+
+        PullTypeResolver.prototype.overloadIsApplicableForArrayLiteralArgument = function (paramType, arg, argIndex, context, comparisonInfo) {
+            if (paramType === this.cachedArrayInterfaceType()) {
+                return 2 /* AssignableWithNoProvisionalErrors */;
+            }
+
+            context.pushProvisionalType(paramType);
+            var argSym = this.resolveArrayLiteralExpression(arg, true, context);
+
+            var applicabilityStatus = this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context);
+
+            context.popAnyContextualType();
+
+            return applicabilityStatus;
+        };
+
+        PullTypeResolver.prototype.overloadIsApplicableForOtherArgument = function (paramType, arg, argIndex, context, comparisonInfo) {
+            var argSym = this.resolveAST(arg, false, context);
+
+            if (argSym.type.isAlias()) {
+                var aliasSym = argSym.type;
+                argSym = aliasSym.getExportAssignedTypeSymbol();
+            }
+
+            comparisonInfo.stringConstantVal = arg;
+            return this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context);
+        };
+
+        PullTypeResolver.prototype.overloadIsApplicableForArgumentHelper = function (paramType, argSym, argumentIndex, comparisonInfo, arg, context) {
+            var tempComparisonInfo = new TypeComparisonInfo();
+            tempComparisonInfo.stringConstantVal = comparisonInfo.stringConstantVal;
+            if (!context.hasProvisionalErrors() && this.sourceIsSubtypeOfTarget(argSym.type, paramType, arg, context, tempComparisonInfo)) {
+                return 3 /* Subtype */;
+            }
+
+            if (this.sourceIsAssignableToTarget(argSym.type, paramType, arg, context, comparisonInfo.message ? tempComparisonInfo : comparisonInfo)) {
+                return context.hasProvisionalErrors() ? 1 /* AssignableButWithProvisionalErrors */ : 2 /* AssignableWithNoProvisionalErrors */;
+            }
+
+            if (!comparisonInfo.message) {
+                var enclosingSymbol = this.getEnclosingSymbolForAST(arg);
+                comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Could_not_apply_type_0_to_argument_1_which_is_of_type_2, [paramType.toString(enclosingSymbol), (argumentIndex + 1), argSym.getTypeName(enclosingSymbol)]));
+            }
+
+            return 0 /* NotAssignable */;
+        };
+
+        PullTypeResolver.prototype.inferArgumentTypesForSignature = function (argContext, comparisonInfo, context) {
+            var inferenceResultTypes = argContext.inferTypeArguments();
+            var typeParameters = argContext.signatureBeingInferred.getTypeParameters();
+            TypeScript.Debug.assert(typeParameters.length == inferenceResultTypes.length);
+
+            var typeReplacementMapForConstraints = null;
+            for (var i = 0; i < inferenceResultTypes.length; i++) {
+                if (typeParameters[i].getConstraint()) {
+                    typeReplacementMapForConstraints = typeReplacementMapForConstraints || TypeScript.PullInstantiationHelpers.createTypeParameterArgumentMap(typeParameters, inferenceResultTypes);
+                    var associatedConstraint = this.instantiateType(typeParameters[i].getConstraint(), typeReplacementMapForConstraints);
+                    if (!this.sourceIsAssignableToTargetWithNewEnclosingTypes(inferenceResultTypes[i], associatedConstraint, null, context, null, false)) {
+                        inferenceResultTypes[i] = associatedConstraint;
+                    }
+                }
+            }
+
+            if (argContext.isInvocationInferenceContext()) {
+                var invocationContext = argContext;
+                if (!this.typeParametersAreInScopeAtArgumentList(typeParameters, invocationContext.argumentASTs)) {
+                    for (var i = 0; i < inferenceResultTypes.length; i++) {
+                        if (inferenceResultTypes[i].wrapsSomeTypeParameter(argContext.candidateCache)) {
+                            inferenceResultTypes[i] = this.semanticInfoChain.anyTypeSymbol;
+                        }
+                    }
+                }
+            }
+
+            return inferenceResultTypes;
+        };
+
+        PullTypeResolver.prototype.typeParametersAreInScopeAtArgumentList = function (typeParameters, args) {
+            var enclosingDecl = this.getEnclosingDeclForAST(args);
+            var typeParameterParentDecl = typeParameters[0].getDeclarations()[0].getParentDecl();
+            return enclosingDecl.getParentPath().indexOf(typeParameterParentDecl) > -1;
+        };
+
+        PullTypeResolver.prototype.relateTypeToTypeParametersInEnclosingType = function (expressionType, parameterType, argContext, context) {
+            if (expressionType && parameterType) {
+                if (context.oneOfClassificationsIsInfinitelyExpanding()) {
+                    this.relateInifinitelyExpandingTypeToTypeParameters(expressionType, parameterType, argContext, context);
+                    return;
+                }
+            }
+            this.relateTypeToTypeParameters(expressionType, parameterType, argContext, context);
+        };
+
+        PullTypeResolver.prototype.relateTypeToTypeParametersWithNewEnclosingTypes = function (expressionType, parameterType, argContext, context) {
+            var enclosingTypeWalkers = context.resetEnclosingTypeWalkers();
+            this.relateTypeToTypeParameters(expressionType, parameterType, argContext, context);
+            context.setEnclosingTypeWalkers(enclosingTypeWalkers);
+        };
+
+        PullTypeResolver.prototype.relateTypeToTypeParameters = function (expressionType, parameterType, argContext, context) {
+            if (!expressionType || !parameterType) {
+                return;
+            }
+
+            if (expressionType.isError()) {
+                expressionType = this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            if (parameterType.isTypeParameter()) {
+                var typeParameter = parameterType;
+                argContext.addCandidateForInference(typeParameter, expressionType);
+                return;
+            }
+
+            if (parameterType.isNamedTypeSymbol() && !parameterType.isGeneric() && !parameterType.getTypeArguments()) {
+                return;
+            }
+
+            if (TypeScript.PullInstantiationHelpers.twoTypesAreInstantiationsOfSameNamedGenericType(expressionType, parameterType)) {
+                this.relateTypeArgumentsOfTypeToTypeParameters(expressionType, parameterType, argContext, context);
+            } else {
+                var symbolsWhenStartedWalkingTypes = context.startWalkingTypes(expressionType, parameterType);
+                this.relateObjectTypeToTypeParameters(expressionType, parameterType, argContext, context);
+                context.endWalkingTypes(symbolsWhenStartedWalkingTypes);
+            }
+        };
+
+        PullTypeResolver.prototype.relateTypeArgumentsOfTypeToTypeParameters = function (expressionType, parameterType, argContext, context) {
+            var parameterSideTypeArguments = parameterType.getTypeArguments();
+            var argumentSideTypeArguments = expressionType.getTypeArguments();
+
+            TypeScript.Debug.assert(parameterSideTypeArguments && argumentSideTypeArguments && parameterSideTypeArguments.length === argumentSideTypeArguments.length);
+            for (var i = 0; i < parameterSideTypeArguments.length; i++) {
+                this.relateTypeToTypeParametersWithNewEnclosingTypes(argumentSideTypeArguments[i], parameterSideTypeArguments[i], argContext, context);
+            }
+        };
+
+        PullTypeResolver.prototype.relateInifinitelyExpandingTypeToTypeParameters = function (expressionType, parameterType, argContext, context) {
+            if (!expressionType || !parameterType) {
+                return;
+            }
+
+            var expressionTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(expressionType);
+            var parameterTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(parameterType);
+            if (expressionTypeNamedTypeReference !== parameterTypeNamedTypeReference) {
+                return;
+            }
+
+            var expressionTypeTypeArguments = expressionType.getTypeArguments();
+            var parameterTypeArguments = parameterType.getTypeArguments();
+
+            if (expressionTypeTypeArguments && parameterTypeArguments && expressionTypeTypeArguments.length === parameterTypeArguments.length) {
+                for (var i = 0; i < expressionTypeTypeArguments.length; i++) {
+                    this.relateTypeArgumentsOfTypeToTypeParameters(expressionType, parameterType, argContext, context);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.relateFunctionSignatureToTypeParameters = function (expressionSignature, parameterSignature, argContext, context) {
+            var _this = this;
+            var expressionReturnType = expressionSignature.returnType;
+            var parameterReturnType = parameterSignature.returnType;
+
+            parameterSignature.forAllCorrespondingParameterTypesInThisAndOtherSignature(expressionSignature, function (parameterSignatureParameterType, expressionSignatureParameterType, i) {
+                context.walkParameterTypes(i);
+                _this.relateTypeToTypeParametersInEnclosingType(expressionSignatureParameterType, parameterSignatureParameterType, argContext, context);
+                context.postWalkParameterTypes();
+                return true;
+            });
+
+            context.walkReturnTypes();
+            this.relateTypeToTypeParametersInEnclosingType(expressionReturnType, parameterReturnType, argContext, context);
+            context.postWalkReturnTypes();
+        };
+
+        PullTypeResolver.prototype.relateObjectTypeToTypeParameters = function (objectType, parameterType, argContext, context) {
+            var parameterTypeMembers = parameterType.getMembers();
+            var parameterSignatures;
+
+            var objectMember;
+            var objectSignatures;
+
+            if (argContext.alreadyRelatingTypes(objectType, parameterType)) {
+                return;
+            }
+
+            for (var i = 0; i < parameterTypeMembers.length; i++) {
+                objectMember = this.getNamedPropertySymbol(parameterTypeMembers[i].name, 68147712 /* SomeValue */, objectType);
+                if (objectMember) {
+                    this.resolveDeclaredSymbol(objectMember);
+                    this.resolveDeclaredSymbol(parameterTypeMembers[i]);
+                    context.walkMemberTypes(parameterTypeMembers[i].name);
+                    this.relateTypeToTypeParametersInEnclosingType(objectMember.type, parameterTypeMembers[i].type, argContext, context);
+                    context.postWalkMemberTypes();
+                }
+            }
+
+            this.relateSignatureGroupToTypeParameters(objectType.getCallSignatures(), parameterType.getCallSignatures(), 1048576 /* CallSignature */, argContext, context);
+
+            this.relateSignatureGroupToTypeParameters(objectType.getConstructSignatures(), parameterType.getConstructSignatures(), 2097152 /* ConstructSignature */, argContext, context);
+
+            var parameterIndexSignatures = this.getBothKindsOfIndexSignaturesExcludingAugmentedType(parameterType, context);
+            var objectIndexSignatures = this.getBothKindsOfIndexSignaturesExcludingAugmentedType(objectType, context);
+            var indexSigInfo = context.getBothKindOfIndexSignatures(false, false);
+
+            if (parameterIndexSignatures.stringSignature && objectIndexSignatures.stringSignature) {
+                context.walkIndexSignatureReturnTypes(indexSigInfo, true, true, true);
+                this.relateFunctionSignatureToTypeParameters(objectIndexSignatures.stringSignature, parameterIndexSignatures.stringSignature, argContext, context);
+                context.postWalkIndexSignatureReturnTypes(true);
+            }
+            if (parameterIndexSignatures.numericSignature && objectIndexSignatures.numericSignature) {
+                context.walkIndexSignatureReturnTypes(indexSigInfo, false, false, true);
+                this.relateFunctionSignatureToTypeParameters(objectIndexSignatures.numericSignature, parameterIndexSignatures.numericSignature, argContext, context);
+                context.postWalkIndexSignatureReturnTypes(true);
+            }
+        };
+
+        PullTypeResolver.prototype.relateSignatureGroupToTypeParameters = function (argumentSignatures, parameterSignatures, signatureKind, argContext, context) {
+            for (var i = 0; i < parameterSignatures.length; i++) {
+                var paramSignature = parameterSignatures[i];
+                if (argumentSignatures.length > 0 && paramSignature.isGeneric()) {
+                    paramSignature = this.instantiateSignatureToAny(paramSignature);
+                }
+                for (var j = 0; j < argumentSignatures.length; j++) {
+                    var argumentSignature = argumentSignatures[j];
+                    if (argumentSignature.nonOptionalParamCount > paramSignature.nonOptionalParamCount) {
+                        continue;
+                    }
+
+                    if (argumentSignature.isGeneric()) {
+                        argumentSignature = this.instantiateSignatureToAny(argumentSignature);
+                    }
+
+                    context.walkSignatures(signatureKind, j, i);
+                    this.relateFunctionSignatureToTypeParameters(argumentSignature, paramSignature, argContext, context);
+                    context.postWalkSignatures();
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.alterPotentialGenericFunctionTypeToInstantiatedFunctionTypeForTypeArgumentInference = function (expressionSymbol, context) {
+            var inferentialType = context.getContextualType();
+            TypeScript.Debug.assert(inferentialType);
+            var expressionType = expressionSymbol.type;
+            if (this.isFunctionTypeWithExactlyOneCallSignatureAndNoOtherMembers(expressionType, true) && this.isFunctionTypeWithExactlyOneCallSignatureAndNoOtherMembers(inferentialType, false)) {
+                var genericExpressionSignature = expressionType.getCallSignatures()[0];
+                var contextualSignature = inferentialType.getCallSignatures()[0];
+
+                var instantiatedSignature = this.instantiateSignatureInContext(genericExpressionSignature, contextualSignature, context, true);
+                if (instantiatedSignature === null) {
+                    return expressionSymbol;
+                }
+
+                var newType = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */);
+                newType.appendCallSignature(instantiatedSignature);
+                return newType;
+            }
+
+            return expressionSymbol;
+        };
+
+        PullTypeResolver.prototype.isFunctionTypeWithExactlyOneCallSignatureAndNoOtherMembers = function (type, callSignatureShouldBeGeneric) {
+            TypeScript.Debug.assert(type);
+            if (type.getCallSignatures().length !== 1) {
+                return false;
+            }
+
+            var callSignatureIsGeneric = type.getCallSignatures()[0].isGeneric();
+            if (callSignatureIsGeneric !== callSignatureShouldBeGeneric) {
+                return false;
+            }
+
+            var typeHasOtherMembers = type.getConstructSignatures().length || type.getIndexSignatures().length || type.getAllMembers(68147712 /* SomeValue */, 0 /* all */).length;
+            if (typeHasOtherMembers) {
+                return false;
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.instantiateTypeToAny = function (typeToSpecialize, context) {
+            var typeParameters = typeToSpecialize.getTypeParameters();
+
+            if (!typeParameters.length) {
+                return typeToSpecialize;
+            }
+
+            var typeArguments = null;
+
+            if (!this._cachedAnyTypeArgs) {
+                this._cachedAnyTypeArgs = [
+                    [this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol]
+                ];
+            }
+
+            if (typeParameters.length < this._cachedAnyTypeArgs.length) {
+                typeArguments = this._cachedAnyTypeArgs[typeParameters.length - 1];
+            } else {
+                typeArguments = [];
+
+                for (var i = 0; i < typeParameters.length; i++) {
+                    typeArguments[typeArguments.length] = this.semanticInfoChain.anyTypeSymbol;
+                }
+            }
+
+            var type = this.createInstantiatedType(typeToSpecialize, typeArguments);
+
+            return type;
+        };
+
+        PullTypeResolver.prototype.instantiateSignatureToAny = function (signature) {
+            var typeParameters = signature.getTypeParameters();
+            if (!this._cachedAnyTypeArgs) {
+                this._cachedAnyTypeArgs = [
+                    [this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol]
+                ];
+            }
+
+            if (typeParameters.length < this._cachedAnyTypeArgs.length) {
+                var typeArguments = this._cachedAnyTypeArgs[typeParameters.length - 1];
+            } else {
+                var typeArguments = [];
+
+                for (var i = 0; i < typeParameters.length; i++) {
+                    typeArguments[typeArguments.length] = this.semanticInfoChain.anyTypeSymbol;
+                }
+            }
+
+            var typeParameterArgumentMap = TypeScript.PullInstantiationHelpers.createTypeParameterArgumentMap(typeParameters, typeArguments);
+            return this.instantiateSignature(signature, typeParameterArgumentMap);
+        };
+
+        PullTypeResolver.typeCheck = function (compilationSettings, semanticInfoChain, document) {
+            var sourceUnit = document.sourceUnit();
+
+            var resolver = semanticInfoChain.getResolver();
+            var context = new TypeScript.PullTypeResolutionContext(resolver, true, sourceUnit.fileName());
+
+            if (resolver.canTypeCheckAST(sourceUnit, context)) {
+                resolver.resolveAST(sourceUnit, false, context);
+                resolver.validateVariableDeclarationGroups(semanticInfoChain.getDeclForAST(sourceUnit), context);
+
+                while (resolver.typeCheckCallBacks.length) {
+                    var callBack = resolver.typeCheckCallBacks.pop();
+                    callBack(context);
+                }
+
+                resolver.processPostTypeCheckWorkItems(context);
+            }
+        };
+
+        PullTypeResolver.prototype.validateVariableDeclarationGroups = function (enclosingDecl, context) {
+            var _this = this;
+            this.scanVariableDeclarationGroups(enclosingDecl, function (_) {
+            }, function (subsequentDecl, firstSymbol) {
+                if (TypeScript.hasFlag(subsequentDecl.kind, 2048 /* Parameter */) || TypeScript.hasFlag(subsequentDecl.flags, 8388608 /* PropertyParameter */)) {
+                    return;
+                }
+
+                var boundDeclAST = _this.semanticInfoChain.getASTForDecl(subsequentDecl);
+
+                var symbol = subsequentDecl.getSymbol();
+                var symbolType = symbol.type;
+                var firstSymbolType = firstSymbol.type;
+
+                if (symbolType && firstSymbolType && symbolType !== firstSymbolType && !_this.typesAreIdentical(symbolType, firstSymbolType, context)) {
+                    context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(boundDeclAST, TypeScript.DiagnosticCode.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2, [symbol.getScopedName(), firstSymbolType.toString(firstSymbol), symbolType.toString(symbol)]));
+                }
+            });
+        };
+
+        PullTypeResolver.prototype.typeCheckFunctionOverloads = function (funcDecl, context, signature, allSignatures) {
+            if (!signature) {
+                var functionSignatureInfo = TypeScript.PullHelpers.getSignatureForFuncDecl(this.semanticInfoChain.getDeclForAST(funcDecl));
+                signature = functionSignatureInfo.signature;
+                allSignatures = functionSignatureInfo.allSignatures;
+            }
+            var functionDeclaration = this.semanticInfoChain.getDeclForAST(funcDecl);
+            var funcSymbol = functionDeclaration.getSymbol();
+
+            var definitionSignature = null;
+            for (var i = allSignatures.length - 1; i >= 0; i--) {
+                if (allSignatures[i].isDefinition()) {
+                    definitionSignature = allSignatures[i];
+                    break;
+                }
+            }
+
+            if (!signature.isDefinition()) {
+                var signatureParentDecl = signature.getDeclarations()[0].getParentDecl();
+                for (var i = 0; i < allSignatures.length; i++) {
+                    if (allSignatures[i] === signature) {
+                        break;
+                    }
+
+                    var allSignaturesParentDecl = allSignatures[i].getDeclarations()[0].getParentDecl();
+                    if (allSignaturesParentDecl !== signatureParentDecl) {
+                        continue;
+                    }
+
+                    if (this.signaturesAreIdenticalWithNewEnclosingTypes(allSignatures[i], signature, context, false)) {
+                        if (!this.signatureReturnTypesAreIdentical(allSignatures[i], signature, context)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overloads_cannot_differ_only_by_return_type));
+                        } else if (funcDecl.kind() === 137 /* ConstructorDeclaration */) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_constructor_overload_signature));
+                        } else if (functionDeclaration.kind === 2097152 /* ConstructSignature */) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_overload_construct_signature));
+                        } else if (functionDeclaration.kind === 1048576 /* CallSignature */) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_overload_call_signature));
+                        } else {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_overload_signature_for_0, [funcSymbol.getScopedNameEx().toString()]));
+                        }
+
+                        break;
+                    }
+                }
+            }
+
+            var isConstantOverloadSignature = signature.isStringConstantOverloadSignature();
+            if (isConstantOverloadSignature) {
+                if (signature.isDefinition()) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overload_signature_implementation_cannot_use_specialized_type));
+                } else {
+                    var foundSubtypeSignature = false;
+                    for (var i = 0; i < allSignatures.length; i++) {
+                        if (allSignatures[i].isDefinition() || allSignatures[i] === signature) {
+                            continue;
+                        }
+
+                        if (!allSignatures[i].isResolved) {
+                            this.resolveDeclaredSymbol(allSignatures[i], context);
+                        }
+
+                        if (allSignatures[i].isStringConstantOverloadSignature()) {
+                            continue;
+                        }
+
+                        if (this.signatureIsAssignableToTarget(signature, allSignatures[i], null, context)) {
+                            foundSubtypeSignature = true;
+                            break;
+                        }
+                    }
+
+                    if (!foundSubtypeSignature) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature));
+                    }
+                }
+            } else if (definitionSignature && definitionSignature !== signature) {
+                var comparisonInfo = new TypeComparisonInfo();
+
+                if (!definitionSignature.isResolved) {
+                    this.resolveDeclaredSymbol(definitionSignature, context);
+                }
+
+                if (!this.signatureIsAssignableToTarget(definitionSignature, signature, funcDecl, context, comparisonInfo)) {
+                    if (comparisonInfo.message) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overload_signature_is_not_compatible_with_function_definition_NL_0, [comparisonInfo.message]));
+                    } else {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overload_signature_is_not_compatible_with_function_definition));
+                    }
+                }
+            }
+
+            var signatureForVisibilityCheck = definitionSignature;
+            if (!definitionSignature) {
+                if (allSignatures[0] === signature) {
+                    return;
+                }
+                signatureForVisibilityCheck = allSignatures[0];
+            }
+
+            if (funcDecl.kind() !== 137 /* ConstructorDeclaration */ && functionDeclaration.kind !== 2097152 /* ConstructSignature */ && signatureForVisibilityCheck && signature !== signatureForVisibilityCheck) {
+                var errorCode;
+
+                if (signatureForVisibilityCheck.anyDeclHasFlag(2 /* Private */) !== signature.anyDeclHasFlag(2 /* Private */)) {
+                    errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_public_or_private;
+                } else if (signatureForVisibilityCheck.anyDeclHasFlag(1 /* Exported */) !== signature.anyDeclHasFlag(1 /* Exported */)) {
+                    errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_exported_or_not_exported;
+                } else if (signatureForVisibilityCheck.anyDeclHasFlag(8 /* Ambient */) !== signature.anyDeclHasFlag(8 /* Ambient */)) {
+                    errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_ambient_or_non_ambient;
+                } else if (signatureForVisibilityCheck.anyDeclHasFlag(128 /* Optional */) !== signature.anyDeclHasFlag(128 /* Optional */)) {
+                    errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_optional_or_required;
+                }
+
+                if (errorCode) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, errorCode));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.checkSymbolPrivacy = function (declSymbol, symbol, privacyErrorReporter) {
+            if (!symbol || symbol.kind === 2 /* Primitive */) {
+                return;
+            }
+
+            if (symbol.isType()) {
+                var typeSymbol = symbol;
+                var isNamedType = typeSymbol.isNamedTypeSymbol();
+
+                if (typeSymbol.isArrayNamedTypeReference()) {
+                    this.checkSymbolPrivacy(declSymbol, typeSymbol.getElementType(), privacyErrorReporter);
+                    return;
+                }
+
+                if (!isNamedType) {
+                    var typeOfSymbol = typeSymbol.getTypeOfSymbol();
+                    if (typeOfSymbol) {
+                        this.checkSymbolPrivacy(declSymbol, typeOfSymbol, privacyErrorReporter);
+                        return;
+                    }
+                }
+
+                if (typeSymbol.inSymbolPrivacyCheck) {
+                    return;
+                }
+
+                typeSymbol.inSymbolPrivacyCheck = true;
+
+                var typars = typeSymbol.getTypeArgumentsOrTypeParameters();
+                if (typars) {
+                    for (var i = 0; i < typars.length; i++) {
+                        this.checkSymbolPrivacy(declSymbol, typars[i], privacyErrorReporter);
+                    }
+                }
+
+                if (!isNamedType) {
+                    var members = typeSymbol.getMembers();
+                    for (var i = 0; i < members.length; i++) {
+                        this.checkSymbolPrivacy(declSymbol, members[i].type, privacyErrorReporter);
+                    }
+
+                    this.checkTypePrivacyOfSignatures(declSymbol, typeSymbol.getCallSignatures(), privacyErrorReporter);
+                    this.checkTypePrivacyOfSignatures(declSymbol, typeSymbol.getConstructSignatures(), privacyErrorReporter);
+                    this.checkTypePrivacyOfSignatures(declSymbol, typeSymbol.getIndexSignatures(), privacyErrorReporter);
+                } else if (typeSymbol.kind === 8192 /* TypeParameter */) {
+                    this.checkSymbolPrivacy(declSymbol, typeSymbol.getConstraint(), privacyErrorReporter);
+                }
+
+                typeSymbol.inSymbolPrivacyCheck = false;
+
+                if (!isNamedType) {
+                    return;
+                }
+            }
+
+            if (declSymbol.isExternallyVisible()) {
+                var symbolIsVisible = symbol.isExternallyVisible();
+
+                if (symbolIsVisible && symbol.kind !== 8192 /* TypeParameter */) {
+                    var symbolPath = symbol.pathToRoot();
+                    var declSymbolPath = declSymbol.pathToRoot();
+
+                    if (symbolPath[symbolPath.length - 1].kind === 32 /* DynamicModule */ && declSymbolPath[declSymbolPath.length - 1].kind === 32 /* DynamicModule */ && declSymbolPath[declSymbolPath.length - 1] !== symbolPath[symbolPath.length - 1]) {
+                        symbolIsVisible = false;
+                        var declSymbolScope = declSymbolPath[declSymbolPath.length - 1];
+                        for (var i = symbolPath.length - 1; i >= 0; i--) {
+                            var aliasSymbols = symbolPath[i].getExternalAliasedSymbols(declSymbolScope);
+                            if (aliasSymbols) {
+                                symbolIsVisible = true;
+                                aliasSymbols[0].setTypeUsedExternally();
+                                break;
+                            }
+                        }
+                        symbol = symbolPath[symbolPath.length - 1];
+                    }
+                } else if (symbol.kind === 128 /* TypeAlias */) {
+                    var aliasSymbol = symbol;
+                    symbolIsVisible = true;
+                    aliasSymbol.setTypeUsedExternally();
+                }
+
+                if (!symbolIsVisible) {
+                    privacyErrorReporter(symbol);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.checkTypePrivacyOfSignatures = function (declSymbol, signatures, privacyErrorReporter) {
+            for (var i = 0; i < signatures.length; i++) {
+                var signature = signatures[i];
+                if (signatures.length > 1 && signature.isDefinition()) {
+                    continue;
+                }
+
+                var typeParams = signature.getTypeParameters();
+                for (var j = 0; j < typeParams.length; j++) {
+                    this.checkSymbolPrivacy(declSymbol, typeParams[j], privacyErrorReporter);
+                }
+
+                var params = signature.parameters;
+                for (var j = 0; j < params.length; j++) {
+                    var paramType = params[j].type;
+                    this.checkSymbolPrivacy(declSymbol, paramType, privacyErrorReporter);
+                }
+
+                var returnType = signature.returnType;
+                this.checkSymbolPrivacy(declSymbol, returnType, privacyErrorReporter);
+            }
+        };
+
+        PullTypeResolver.prototype.typeParameterOfTypeDeclarationPrivacyErrorReporter = function (classOrInterface, typeParameterAST, typeParameter, symbol, context) {
+            var decl = this.semanticInfoChain.getDeclForAST(classOrInterface);
+            var enclosingDecl = this.getEnclosingDecl(decl);
+            var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null;
+            var messageCode;
+
+            var typeParameters = classOrInterface.kind() === 131 /* ClassDeclaration */ ? classOrInterface.typeParameterList : classOrInterface.typeParameterList;
+
+            var typeSymbol = symbol;
+            var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol);
+            if (typeSymbol.isContainer() && !typeSymbol.isEnum()) {
+                if (!TypeScript.isQuoted(typeSymbolName)) {
+                    typeSymbolName = "'" + typeSymbolName + "'";
+                }
+                if (classOrInterface.kind() === 131 /* ClassDeclaration */) {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_class_is_using_inaccessible_module_1;
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_interface_is_using_inaccessible_module_1;
+                }
+            } else {
+                if (classOrInterface.kind() === 131 /* ClassDeclaration */) {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_class_has_or_is_using_private_type_1;
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_interface_has_or_is_using_private_type_1;
+                }
+            }
+
+            var messageArguments = [typeParameter.getScopedName(enclosingSymbol, false, true), typeSymbolName];
+            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeParameterAST, messageCode, messageArguments));
+        };
+
+        PullTypeResolver.prototype.baseListPrivacyErrorReporter = function (classOrInterface, declSymbol, baseAst, isExtendedType, symbol, context) {
+            var decl = this.semanticInfoChain.getDeclForAST(classOrInterface);
+            var enclosingDecl = this.getEnclosingDecl(decl);
+            var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null;
+            var messageCode;
+
+            var typeSymbol = symbol;
+            var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol);
+            if (typeSymbol.isContainer() && !typeSymbol.isEnum()) {
+                if (!TypeScript.isQuoted(typeSymbolName)) {
+                    typeSymbolName = "'" + typeSymbolName + "'";
+                }
+                if (classOrInterface.kind() === 131 /* ClassDeclaration */) {
+                    if (isExtendedType) {
+                        messageCode = TypeScript.DiagnosticCode.Exported_class_0_extends_class_from_inaccessible_module_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Exported_class_0_implements_interface_from_inaccessible_module_1;
+                    }
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.Exported_interface_0_extends_interface_from_inaccessible_module_1;
+                }
+            } else {
+                if (classOrInterface.kind() === 131 /* ClassDeclaration */) {
+                    if (isExtendedType) {
+                        messageCode = TypeScript.DiagnosticCode.Exported_class_0_extends_private_class_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Exported_class_0_implements_private_interface_1;
+                    }
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.Exported_interface_0_extends_private_interface_1;
+                }
+            }
+
+            var messageArguments = [declSymbol.getScopedName(enclosingSymbol), typeSymbolName];
+            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseAst, messageCode, messageArguments));
+        };
+
+        PullTypeResolver.prototype.variablePrivacyErrorReporter = function (declAST, declSymbol, symbol, context) {
+            var typeSymbol = symbol;
+            var enclosingDecl = this.getEnclosingDecl(declSymbol.getDeclarations()[0]);
+            var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null;
+
+            var isProperty = declSymbol.kind === 4096 /* Property */;
+            var isPropertyOfClass = false;
+            var declParent = declSymbol.getContainer();
+            if (declParent && (declParent.kind === 8 /* Class */ || declParent.kind === 32768 /* ConstructorMethod */)) {
+                isPropertyOfClass = true;
+            }
+
+            var messageCode;
+            var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol);
+            if (typeSymbol.isContainer() && !typeSymbol.isEnum()) {
+                if (!TypeScript.isQuoted(typeSymbolName)) {
+                    typeSymbolName = "'" + typeSymbolName + "'";
+                }
+
+                if (declSymbol.anyDeclHasFlag(16 /* Static */)) {
+                    messageCode = TypeScript.DiagnosticCode.Public_static_property_0_of_exported_class_is_using_inaccessible_module_1;
+                } else if (isProperty) {
+                    if (isPropertyOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.Public_property_0_of_exported_class_is_using_inaccessible_module_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Property_0_of_exported_interface_is_using_inaccessible_module_1;
+                    }
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.Exported_variable_0_is_using_inaccessible_module_1;
+                }
+            } else {
+                if (declSymbol.anyDeclHasFlag(16 /* Static */)) {
+                    messageCode = TypeScript.DiagnosticCode.Public_static_property_0_of_exported_class_has_or_is_using_private_type_1;
+                } else if (isProperty) {
+                    if (isPropertyOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.Public_property_0_of_exported_class_has_or_is_using_private_type_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Property_0_of_exported_interface_has_or_is_using_private_type_1;
+                    }
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.Exported_variable_0_has_or_is_using_private_type_1;
+                }
+            }
+
+            var messageArguments = [declSymbol.getScopedName(enclosingSymbol), typeSymbolName];
+            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(declAST, messageCode, messageArguments));
+        };
+
+        PullTypeResolver.prototype.checkFunctionTypePrivacy = function (funcDeclAST, isStatic, typeParameters, parameters, returnTypeAnnotation, block, context) {
+            var _this = this;
+            if (funcDeclAST.kind() === 222 /* FunctionExpression */ || funcDeclAST.kind() === 241 /* FunctionPropertyAssignment */ || (funcDeclAST.kind() === 139 /* GetAccessor */ && funcDeclAST.parent.parent.kind() === 215 /* ObjectLiteralExpression */) || (funcDeclAST.kind() === 140 /* SetAccessor */ && funcDeclAST.parent.parent.kind() === 215 /* ObjectLiteralExpression */)) {
+                return;
+            }
+
+            var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            var functionSymbol = functionDecl.getSymbol();
+            ;
+            var functionSignature;
+
+            var isGetter = funcDeclAST.kind() === 139 /* GetAccessor */;
+            var isSetter = funcDeclAST.kind() === 140 /* SetAccessor */;
+            var isIndexSignature = functionDecl.kind === 4194304 /* IndexSignature */;
+
+            if (isGetter || isSetter) {
+                var accessorSymbol = functionSymbol;
+                functionSignature = (isGetter ? accessorSymbol.getGetter() : accessorSymbol.getSetter()).type.getCallSignatures()[0];
+            } else {
+                if (!functionSymbol) {
+                    var parentDecl = functionDecl.getParentDecl();
+                    functionSymbol = parentDecl.getSymbol();
+                    if (functionSymbol && functionSymbol.isType() && !functionSymbol.isNamedTypeSymbol()) {
+                        return;
+                    }
+                } else if (functionSymbol.kind === 65536 /* Method */ && !isStatic && !functionSymbol.getContainer().isNamedTypeSymbol()) {
+                    return;
+                }
+                functionSignature = functionDecl.getSignatureSymbol();
+            }
+
+            if (typeParameters && !isGetter && !isSetter && !isIndexSignature && funcDeclAST.kind() !== 137 /* ConstructorDeclaration */) {
+                for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) {
+                    var typeParameterAST = typeParameters.typeParameters.nonSeparatorAt(i);
+                    var typeParameter = this.resolveTypeParameterDeclaration(typeParameterAST, context);
+                    this.checkSymbolPrivacy(functionSymbol, typeParameter, function (symbol) {
+                        return _this.functionTypeArgumentArgumentTypePrivacyErrorReporter(funcDeclAST, isStatic, typeParameterAST, typeParameter, symbol, context);
+                    });
+                }
+            }
+
+            if (!isGetter && !isIndexSignature) {
+                var funcParams = functionSignature.parameters;
+                for (var i = 0; i < funcParams.length; i++) {
+                    this.checkSymbolPrivacy(functionSymbol, funcParams[i].type, function (symbol) {
+                        return _this.functionArgumentTypePrivacyErrorReporter(funcDeclAST, isStatic, parameters, i, funcParams[i], symbol, context);
+                    });
+                }
+            }
+
+            if (!isSetter) {
+                this.checkSymbolPrivacy(functionSymbol, functionSignature.returnType, function (symbol) {
+                    return _this.functionReturnTypePrivacyErrorReporter(funcDeclAST, isStatic, returnTypeAnnotation, block, functionSignature.returnType, symbol, context);
+                });
+            }
+        };
+
+        PullTypeResolver.prototype.functionTypeArgumentArgumentTypePrivacyErrorReporter = function (declAST, isStatic, typeParameterAST, typeParameter, symbol, context) {
+            var decl = this.semanticInfoChain.getDeclForAST(declAST);
+            var enclosingDecl = this.getEnclosingDecl(decl);
+            var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null;
+
+            var isMethod = decl.kind === 65536 /* Method */;
+            var isMethodOfClass = false;
+            var declParent = decl.getParentDecl();
+            if (declParent && (declParent.kind === 8 /* Class */ || isStatic)) {
+                isMethodOfClass = true;
+            }
+
+            var typeSymbol = symbol;
+            var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol);
+            var messageCode;
+            if (typeSymbol.isContainer() && !typeSymbol.isEnum()) {
+                if (!TypeScript.isQuoted(typeSymbolName)) {
+                    typeSymbolName = "'" + typeSymbolName + "'";
+                }
+
+                if (decl.kind === 2097152 /* ConstructSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1;
+                } else if (decl.kind === 1048576 /* CallSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1;
+                } else if (isMethod) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1;
+                    } else if (isMethodOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1;
+                    }
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_function_is_using_inaccessible_module_1;
+                }
+            } else {
+                if (decl.kind === 2097152 /* ConstructSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1;
+                } else if (decl.kind === 1048576 /* CallSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1;
+                } else if (isMethod) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1;
+                    } else if (isMethodOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1;
+                    }
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_function_has_or_is_using_private_type_1;
+                }
+            }
+
+            if (messageCode) {
+                var messageArgs = [typeParameter.getScopedName(enclosingSymbol, false, true), typeSymbolName];
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeParameterAST, messageCode, messageArgs));
+            }
+        };
+
+        PullTypeResolver.prototype.functionArgumentTypePrivacyErrorReporter = function (declAST, isStatic, parameters, argIndex, paramSymbol, symbol, context) {
+            var decl = this.semanticInfoChain.getDeclForAST(declAST);
+            var enclosingDecl = this.getEnclosingDecl(decl);
+            var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null;
+
+            var isGetter = declAST.kind() === 139 /* GetAccessor */;
+            var isSetter = declAST.kind() === 140 /* SetAccessor */;
+            var isMethod = decl.kind === 65536 /* Method */;
+            var isMethodOfClass = false;
+            var declParent = decl.getParentDecl();
+            if (declParent && (declParent.kind === 8 /* Class */ || isStatic)) {
+                isMethodOfClass = true;
+            }
+
+            var typeSymbol = symbol;
+            var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol);
+            var messageCode;
+            if (typeSymbol.isContainer() && !typeSymbol.isEnum()) {
+                if (!TypeScript.isQuoted(typeSymbolName)) {
+                    typeSymbolName = "'" + typeSymbolName + "'";
+                }
+
+                if (declAST.kind() === 137 /* ConstructorDeclaration */) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_from_exported_class_is_using_inaccessible_module_1;
+                } else if (isSetter) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_property_setter_from_exported_class_is_using_inaccessible_module_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_property_setter_from_exported_class_is_using_inaccessible_module_1;
+                    }
+                } else if (decl.kind === 2097152 /* ConstructSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1;
+                } else if (decl.kind === 1048576 /* CallSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1;
+                } else if (isMethod) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1;
+                    } else if (isMethodOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1;
+                    }
+                } else if (!isGetter) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_exported_function_is_using_inaccessible_module_1;
+                }
+            } else {
+                if (declAST.kind() === 137 /* ConstructorDeclaration */) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_type_1;
+                } else if (isSetter) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_type_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_type_1;
+                    }
+                } else if (decl.kind === 2097152 /* ConstructSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1;
+                } else if (decl.kind === 1048576 /* CallSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1;
+                } else if (isMethod) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1;
+                    } else if (isMethodOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1;
+                    }
+                } else if (!isGetter && decl.kind !== 4194304 /* IndexSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_exported_function_has_or_is_using_private_type_1;
+                }
+            }
+
+            if (messageCode) {
+                var parameter = parameters.astAt(argIndex);
+
+                var messageArgs = [paramSymbol.getScopedName(enclosingSymbol), typeSymbolName];
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(parameter, messageCode, messageArgs));
+            }
+        };
+
+        PullTypeResolver.prototype.functionReturnTypePrivacyErrorReporter = function (declAST, isStatic, returnTypeAnnotation, block, funcReturnType, symbol, context) {
+            var _this = this;
+            var decl = this.semanticInfoChain.getDeclForAST(declAST);
+            var enclosingDecl = this.getEnclosingDecl(decl);
+
+            var isGetter = declAST.kind() === 139 /* GetAccessor */;
+            var isSetter = declAST.kind() === 140 /* SetAccessor */;
+            var isMethod = decl.kind === 65536 /* Method */;
+            var isMethodOfClass = false;
+            var declParent = decl.getParentDecl();
+            if (declParent && (declParent.kind === 8 /* Class */ || isStatic)) {
+                isMethodOfClass = true;
+            }
+
+            var messageCode = null;
+            var typeSymbol = symbol;
+            var typeSymbolName = typeSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null);
+            if (typeSymbol.isContainer() && !typeSymbol.isEnum()) {
+                if (!TypeScript.isQuoted(typeSymbolName)) {
+                    typeSymbolName = "'" + typeSymbolName + "'";
+                }
+
+                if (isGetter) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_property_getter_from_exported_class_is_using_inaccessible_module_0;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_property_getter_from_exported_class_is_using_inaccessible_module_0;
+                    }
+                } else if (decl.kind === 2097152 /* ConstructSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_0;
+                } else if (decl.kind === 1048576 /* CallSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_call_signature_from_exported_interface_is_using_inaccessible_module_0;
+                } else if (decl.kind === 4194304 /* IndexSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_index_signature_from_exported_interface_is_using_inaccessible_module_0;
+                } else if (isMethod) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_method_from_exported_class_is_using_inaccessible_module_0;
+                    } else if (isMethodOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_method_from_exported_class_is_using_inaccessible_module_0;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_method_from_exported_interface_is_using_inaccessible_module_0;
+                    }
+                } else if (!isSetter && declAST.kind() !== 137 /* ConstructorDeclaration */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_exported_function_is_using_inaccessible_module_0;
+                }
+            } else {
+                if (isGetter) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_type_0;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_type_0;
+                    }
+                } else if (decl.kind === 2097152 /* ConstructSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_0;
+                } else if (decl.kind === 1048576 /* CallSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_type_0;
+                } else if (decl.kind === 4194304 /* IndexSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_type_0;
+                } else if (isMethod) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_type_0;
+                    } else if (isMethodOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_method_from_exported_class_has_or_is_using_private_type_0;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_method_from_exported_interface_has_or_is_using_private_type_0;
+                    }
+                } else if (!isSetter && declAST.kind() !== 137 /* ConstructorDeclaration */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_exported_function_has_or_is_using_private_type_0;
+                }
+            }
+
+            if (messageCode) {
+                var messageArguments = [typeSymbolName];
+                var reportOnFuncDecl = false;
+
+                if (returnTypeAnnotation) {
+                    var returnExpressionSymbol = this.resolveTypeReference(returnTypeAnnotation, context);
+
+                    if (TypeScript.PullHelpers.typeSymbolsAreIdentical(returnExpressionSymbol, funcReturnType)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, messageCode, messageArguments));
+                    }
+                }
+
+                if (block) {
+                    var reportErrorOnReturnExpressions = function (ast, walker) {
+                        var go = true;
+                        switch (ast.kind()) {
+                            case 129 /* FunctionDeclaration */:
+                            case 219 /* SimpleArrowFunctionExpression */:
+                            case 218 /* ParenthesizedArrowFunctionExpression */:
+                            case 222 /* FunctionExpression */:
+                                go = false;
+                                break;
+
+                            case 150 /* ReturnStatement */:
+                                var returnStatement = ast;
+                                var returnExpressionSymbol = _this.resolveAST(returnStatement.expression, false, context).type;
+
+                                if (TypeScript.PullHelpers.typeSymbolsAreIdentical(returnExpressionSymbol, funcReturnType)) {
+                                    context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(returnStatement, messageCode, messageArguments));
+                                } else {
+                                    reportOnFuncDecl = true;
+                                }
+                                go = false;
+                                break;
+
+                            default:
+                                break;
+                        }
+
+                        walker.options.goChildren = go;
+                        return ast;
+                    };
+
+                    TypeScript.getAstWalkerFactory().walk(block, reportErrorOnReturnExpressions);
+                }
+
+                if (reportOnFuncDecl) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(declAST, messageCode, messageArguments));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.enclosingClassIsDerived = function (classDecl) {
+            TypeScript.Debug.assert(classDecl.kind === 8 /* Class */);
+
+            var classSymbol = classDecl.getSymbol();
+            return classSymbol.getExtendedTypes().length > 0;
+        };
+
+        PullTypeResolver.prototype.isSuperInvocationExpression = function (ast) {
+            if (ast.kind() === 213 /* InvocationExpression */) {
+                var invocationExpression = ast;
+                if (invocationExpression.expression.kind() === 50 /* SuperKeyword */) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.isSuperInvocationExpressionStatement = function (node) {
+            if (node && node.kind() === 149 /* ExpressionStatement */) {
+                var expressionStatement = node;
+                if (this.isSuperInvocationExpression(expressionStatement.expression)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+
+        PullTypeResolver.prototype.getFirstStatementOfBlockOrNull = function (block) {
+            if (block && block.statements && block.statements.childCount() > 0) {
+                return block.statements.childAt(0);
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.superCallMustBeFirstStatementInConstructor = function (constructorDecl) {
+            TypeScript.Debug.assert(constructorDecl.kind === 32768 /* ConstructorMethod */);
+
+            if (constructorDecl) {
+                var enclosingClass = constructorDecl.getParentDecl();
+
+                var classSymbol = enclosingClass.getSymbol();
+                if (classSymbol.getExtendedTypes().length === 0) {
+                    return false;
+                }
+
+                var classMembers = classSymbol.getMembers();
+                for (var i = 0, n1 = classMembers.length; i < n1; i++) {
+                    var member = classMembers[i];
+
+                    if (member.kind === 4096 /* Property */) {
+                        var declarations = member.getDeclarations();
+                        for (var j = 0, n2 = declarations.length; j < n2; j++) {
+                            var declaration = declarations[j];
+                            var ast = this.semanticInfoChain.getASTForDecl(declaration);
+                            if (ast.kind() === 242 /* Parameter */) {
+                                return true;
+                            }
+
+                            if (ast.kind() === 136 /* MemberVariableDeclaration */) {
+                                var variableDeclarator = ast;
+                                if (variableDeclarator.variableDeclarator.equalsValueClause) {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.checkForThisCaptureInArrowFunction = function (expression) {
+            var enclosingDecl = this.getEnclosingDeclForAST(expression);
+
+            var declPath = enclosingDecl.getParentPath();
+
+            if (declPath.length) {
+                var inArrowFunction = false;
+                for (var i = declPath.length - 1; i >= 0; i--) {
+                    var decl = declPath[i];
+                    var declKind = decl.kind;
+                    var declFlags = decl.flags;
+
+                    if (declKind === 131072 /* FunctionExpression */ && TypeScript.hasFlag(declFlags, 8192 /* ArrowFunction */)) {
+                        inArrowFunction = true;
+                        continue;
+                    }
+
+                    if (inArrowFunction) {
+                        if (declKind === 16384 /* Function */ || declKind === 65536 /* Method */ || declKind === 32768 /* ConstructorMethod */ || declKind === 262144 /* GetAccessor */ || declKind === 524288 /* SetAccessor */ || declKind === 131072 /* FunctionExpression */ || declKind === 8 /* Class */ || declKind === 4 /* Container */ || declKind === 32 /* DynamicModule */ || declKind === 1 /* Script */) {
+                            decl.setFlags(decl.flags | 262144 /* MustCaptureThis */);
+
+                            if (declKind === 8 /* Class */) {
+                                var constructorSymbol = decl.getSymbol().getConstructorMethod();
+                                var constructorDecls = constructorSymbol.getDeclarations();
+                                for (var i = 0; i < constructorDecls.length; i++) {
+                                    constructorDecls[i].flags = constructorDecls[i].flags | 262144 /* MustCaptureThis */;
+                                }
+                            }
+                            break;
+                        }
+                    } else if (declKind === 16384 /* Function */ || declKind === 131072 /* FunctionExpression */) {
+                        break;
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckMembersAgainstIndexer = function (containerType, containerTypeDecl, context) {
+            var indexSignatures = this.getBothKindsOfIndexSignaturesExcludingAugmentedType(containerType, context);
+            var stringSignature = indexSignatures.stringSignature;
+            var numberSignature = indexSignatures.numericSignature;
+
+            if (stringSignature || numberSignature) {
+                var members = containerTypeDecl.getChildDecls();
+                for (var i = 0; i < members.length; i++) {
+                    var member = members[i];
+                    if ((member.name || (member.kind === 4096 /* Property */ && member.name === "")) && member.kind !== 32768 /* ConstructorMethod */ && !TypeScript.hasFlag(member.flags, 16 /* Static */)) {
+                        var memberSymbol = member.getSymbol();
+                        var relevantSignature = this.determineRelevantIndexerForMember(memberSymbol, numberSignature, stringSignature);
+                        if (relevantSignature) {
+                            var comparisonInfo = new TypeComparisonInfo();
+                            if (!this.sourceIsAssignableToTarget(memberSymbol.type, relevantSignature.returnType, member.ast(), context, comparisonInfo)) {
+                                this.reportErrorThatMemberIsNotSubtypeOfIndexer(memberSymbol, relevantSignature, member.ast(), context, comparisonInfo);
+                            }
+                        }
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.determineRelevantIndexerForMember = function (member, numberIndexSignature, stringIndexSignature) {
+            if (numberIndexSignature && TypeScript.PullHelpers.isNameNumeric(member.name)) {
+                return numberIndexSignature;
+            } else if (stringIndexSignature) {
+                return stringIndexSignature;
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.reportErrorThatMemberIsNotSubtypeOfIndexer = function (member, indexSignature, astForError, context, comparisonInfo) {
+            var enclosingSymbol = this.getEnclosingSymbolForAST(astForError);
+            if (indexSignature.parameters[0].type === this.semanticInfoChain.numberTypeSymbol) {
+                if (comparisonInfo.message) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_numerically_named_properties_must_be_assignable_to_numeric_indexer_type_0_NL_1, [indexSignature.returnType.toString(enclosingSymbol), comparisonInfo.message]));
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_numerically_named_properties_must_be_assignable_to_numeric_indexer_type_0, [indexSignature.returnType.toString(enclosingSymbol)]));
+                }
+            } else {
+                if (comparisonInfo.message) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_named_properties_must_be_assignable_to_string_indexer_type_0_NL_1, [indexSignature.returnType.toString(enclosingSymbol), comparisonInfo.message]));
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_named_properties_must_be_assignable_to_string_indexer_type_0, [indexSignature.returnType.toString(enclosingSymbol)]));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckIfTypeMemberPropertyOkToOverride = function (typeSymbol, extendedType, typeMember, extendedTypeMember, enclosingDecl, comparisonInfo) {
+            if (!typeSymbol.isClass()) {
+                return true;
+            }
+
+            var typeMemberKind = typeMember.kind;
+            var extendedMemberKind = extendedTypeMember.kind;
+
+            if (typeMemberKind === extendedMemberKind) {
+                return true;
+            }
+
+            var errorCode;
+            if (typeMemberKind === 4096 /* Property */) {
+                if (typeMember.isAccessor()) {
+                    errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function;
+                } else {
+                    errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function;
+                }
+            } else if (typeMemberKind === 65536 /* Method */) {
+                if (extendedTypeMember.isAccessor()) {
+                    errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor;
+                } else {
+                    errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property;
+                }
+            }
+
+            var message = TypeScript.getDiagnosticMessage(errorCode, [typeSymbol.toString(), typeMember.getScopedNameEx().toString(), extendedType.toString()]);
+            comparisonInfo.addMessage(message);
+            return false;
+        };
+
+        PullTypeResolver.prototype.typeCheckIfTypeExtendsType = function (classOrInterface, name, typeSymbol, extendedType, enclosingDecl, context) {
+            var typeMembers = typeSymbol.getMembers();
+
+            var comparisonInfo = new TypeComparisonInfo();
+            var foundError = false;
+            var foundError1 = false;
+            var foundError2 = false;
+
+            for (var i = 0; i < typeMembers.length; i++) {
+                var propName = typeMembers[i].name;
+                var extendedTypeProp = extendedType.findMember(propName, true);
+                if (extendedTypeProp) {
+                    this.resolveDeclaredSymbol(extendedTypeProp, context);
+                    foundError1 = !this.typeCheckIfTypeMemberPropertyOkToOverride(typeSymbol, extendedType, typeMembers[i], extendedTypeProp, enclosingDecl, comparisonInfo);
+
+                    if (!foundError1) {
+                        foundError2 = !this.sourcePropertyIsAssignableToTargetProperty(typeSymbol, extendedType, typeMembers[i], extendedTypeProp, classOrInterface, context, comparisonInfo);
+                    }
+
+                    if (foundError1 || foundError2) {
+                        foundError = true;
+                        break;
+                    }
+                }
+            }
+
+            if (!foundError && typeSymbol.hasOwnCallSignatures()) {
+                foundError = !this.sourceCallSignaturesAreAssignableToTargetCallSignatures(typeSymbol, extendedType, classOrInterface, context, comparisonInfo);
+            }
+
+            if (!foundError && typeSymbol.hasOwnConstructSignatures()) {
+                foundError = !this.sourceConstructSignaturesAreAssignableToTargetConstructSignatures(typeSymbol, extendedType, classOrInterface, context, comparisonInfo);
+            }
+
+            if (!foundError && typeSymbol.hasOwnIndexSignatures()) {
+                foundError = !this.sourceIndexSignaturesAreAssignableToTargetIndexSignatures(typeSymbol, extendedType, classOrInterface, context, comparisonInfo);
+            }
+
+            if (!foundError && typeSymbol.isClass()) {
+                var typeConstructorType = typeSymbol.getConstructorMethod().type;
+                var typeConstructorTypeMembers = typeConstructorType.getMembers();
+                if (typeConstructorTypeMembers.length) {
+                    var extendedConstructorType = extendedType.getConstructorMethod().type;
+                    var comparisonInfoForPropTypeCheck = new TypeComparisonInfo(comparisonInfo);
+
+                    for (var i = 0; i < typeConstructorTypeMembers.length; i++) {
+                        var propName = typeConstructorTypeMembers[i].name;
+                        var extendedConstructorTypeProp = extendedConstructorType.findMember(propName, true);
+                        if (extendedConstructorTypeProp) {
+                            if (!extendedConstructorTypeProp.isResolved) {
+                                this.resolveDeclaredSymbol(extendedConstructorTypeProp, context);
+                            }
+
+                            if (!this.sourcePropertyIsAssignableToTargetProperty(typeConstructorType, extendedConstructorType, typeConstructorTypeMembers[i], extendedConstructorTypeProp, classOrInterface, context, comparisonInfo)) {
+                                foundError = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (foundError) {
+                var errorCode;
+                if (typeSymbol.isClass()) {
+                    errorCode = TypeScript.DiagnosticCode.Class_0_cannot_extend_class_1_NL_2;
+                } else {
+                    if (extendedType.isClass()) {
+                        errorCode = TypeScript.DiagnosticCode.Interface_0_cannot_extend_class_1_NL_2;
+                    } else {
+                        errorCode = TypeScript.DiagnosticCode.Interface_0_cannot_extend_interface_1_NL_2;
+                    }
+                }
+
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, errorCode, [typeSymbol.getScopedName(), extendedType.getScopedName(), comparisonInfo.message]));
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckIfClassImplementsType = function (classDecl, classSymbol, implementedType, enclosingDecl, context) {
+            var comparisonInfo = new TypeComparisonInfo();
+            var foundError = !this.sourceMembersAreAssignableToTargetMembers(classSymbol, implementedType, classDecl, context, comparisonInfo);
+            if (!foundError) {
+                foundError = !this.sourceCallSignaturesAreAssignableToTargetCallSignatures(classSymbol, implementedType, classDecl, context, comparisonInfo);
+                if (!foundError) {
+                    foundError = !this.sourceConstructSignaturesAreAssignableToTargetConstructSignatures(classSymbol, implementedType, classDecl, context, comparisonInfo);
+                    if (!foundError) {
+                        foundError = !this.sourceIndexSignaturesAreAssignableToTargetIndexSignatures(classSymbol, implementedType, classDecl, context, comparisonInfo);
+                    }
+                }
+            }
+
+            if (foundError) {
+                var enclosingSymbol = this.getEnclosingSymbolForAST(classDecl);
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(classDecl.identifier, TypeScript.DiagnosticCode.Class_0_declares_interface_1_but_does_not_implement_it_NL_2, [classSymbol.getScopedName(enclosingSymbol), implementedType.getScopedName(enclosingSymbol), comparisonInfo.message]));
+            }
+        };
+
+        PullTypeResolver.prototype.computeValueSymbolFromAST = function (valueDeclAST, context) {
+            var prevInTypeCheck = context.inTypeCheck;
+            context.inTypeCheck = false;
+
+            var typeSymbolAlias = this.semanticInfoChain.getAliasSymbolForAST(valueDeclAST);
+
+            if (valueDeclAST.kind() == 11 /* IdentifierName */) {
+                var valueSymbol = this.computeNameExpression(valueDeclAST, context);
+            } else {
+                TypeScript.Debug.assert(valueDeclAST.kind() == 121 /* QualifiedName */);
+                var qualifiedName = valueDeclAST;
+
+                var lhs = this.computeValueSymbolFromAST(qualifiedName.left, context);
+                var valueSymbol = this.computeDottedNameExpressionFromLHS(lhs.symbol, qualifiedName.left, qualifiedName.right, context, false);
+            }
+            var valueSymbolAlias = this.semanticInfoChain.getAliasSymbolForAST(valueDeclAST);
+
+            this.semanticInfoChain.setAliasSymbolForAST(valueDeclAST, typeSymbolAlias);
+            context.inTypeCheck = prevInTypeCheck;
+
+            return { symbol: valueSymbol, alias: valueSymbolAlias };
+        };
+
+        PullTypeResolver.prototype.hasClassTypeSymbolConflictAsValue = function (baseDeclAST, typeSymbol, enclosingDecl, context) {
+            var typeSymbolAlias = this.semanticInfoChain.getAliasSymbolForAST(baseDeclAST);
+
+            var valueDeclAST = baseDeclAST.kind() == 126 /* GenericType */ ? baseDeclAST.name : baseDeclAST;
+            var valueSymbolInfo = this.computeValueSymbolFromAST(valueDeclAST, context);
+            var valueSymbol = valueSymbolInfo.symbol;
+            var valueSymbolAlias = valueSymbolInfo.alias;
+
+            if (typeSymbolAlias && valueSymbolAlias) {
+                return typeSymbolAlias !== valueSymbolAlias;
+            }
+
+            if (!valueSymbol.anyDeclHasFlag(16384 /* ClassConstructorVariable */)) {
+                return true;
+            }
+
+            var associatedContainerType = valueSymbol.type ? valueSymbol.type.getAssociatedContainerType() : null;
+
+            if (associatedContainerType) {
+                return associatedContainerType !== typeSymbol.getRootSymbol();
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.typeCheckBase = function (classOrInterface, name, typeSymbol, baseDeclAST, isExtendedType, enclosingDecl, context) {
+            var _this = this;
+            var typeDecl = this.semanticInfoChain.getDeclForAST(classOrInterface);
+
+            var baseType = this.resolveTypeReference(baseDeclAST, context).type;
+
+            if (!baseType) {
+                return;
+            }
+
+            var typeDeclIsClass = typeSymbol.isClass();
+
+            if (!typeSymbol.isValidBaseKind(baseType, isExtendedType)) {
+                if (!baseType.isError()) {
+                    if (isExtendedType) {
+                        if (typeDeclIsClass) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.A_class_may_only_extend_another_class));
+                        } else {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.An_interface_may_only_extend_another_class_or_interface));
+                        }
+                    } else {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.A_class_may_only_implement_another_class_or_interface));
+                    }
+                }
+                return;
+            } else if (typeDeclIsClass && isExtendedType) {
+                if (this.hasClassTypeSymbolConflictAsValue(baseDeclAST, baseType, enclosingDecl, context)) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_1, [TypeScript.ASTHelpers.getNameOfIdenfierOrQualifiedName(baseDeclAST.kind() == 126 /* GenericType */ ? baseDeclAST.name : baseDeclAST), baseType.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)]));
+                }
+            }
+
+            if (baseType.hasBase(typeSymbol)) {
+                typeSymbol.setHasBaseTypeConflict();
+                baseType.setHasBaseTypeConflict();
+
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, typeDeclIsClass ? TypeScript.DiagnosticCode.Class_0_is_recursively_referenced_as_a_base_type_of_itself : TypeScript.DiagnosticCode.Interface_0_is_recursively_referenced_as_a_base_type_of_itself, [typeSymbol.getScopedName()]));
+                return;
+            }
+
+            if (isExtendedType) {
+                this.typeCheckCallBacks.push(function (context) {
+                    return _this.typeCheckIfTypeExtendsType(classOrInterface, name, typeSymbol, baseType, enclosingDecl, context);
+                });
+            } else {
+                TypeScript.Debug.assert(classOrInterface.kind() === 131 /* ClassDeclaration */);
+
+                this.typeCheckCallBacks.push(function (context) {
+                    return _this.typeCheckIfClassImplementsType(classOrInterface, typeSymbol, baseType, enclosingDecl, context);
+                });
+            }
+
+            this.checkSymbolPrivacy(typeSymbol, baseType, function (errorSymbol) {
+                return _this.baseListPrivacyErrorReporter(classOrInterface, typeSymbol, baseDeclAST, isExtendedType, errorSymbol, context);
+            });
+        };
+
+        PullTypeResolver.prototype.typeCheckBases = function (classOrInterface, name, heritageClauses, typeSymbol, enclosingDecl, context) {
+            var _this = this;
+            var extendsClause = TypeScript.ASTHelpers.getExtendsHeritageClause(heritageClauses);
+            var implementsClause = TypeScript.ASTHelpers.getImplementsHeritageClause(heritageClauses);
+            if (!extendsClause && !implementsClause) {
+                return;
+            }
+
+            if (extendsClause) {
+                for (var i = 0; i < extendsClause.typeNames.nonSeparatorCount(); i++) {
+                    this.typeCheckBase(classOrInterface, name, typeSymbol, extendsClause.typeNames.nonSeparatorAt(i), true, enclosingDecl, context);
+                }
+            }
+
+            if (typeSymbol.isClass()) {
+                if (implementsClause) {
+                    for (var i = 0; i < implementsClause.typeNames.nonSeparatorCount(); i++) {
+                        this.typeCheckBase(classOrInterface, name, typeSymbol, implementsClause.typeNames.nonSeparatorAt(i), false, enclosingDecl, context);
+                    }
+                }
+            } else if (extendsClause && !typeSymbol.hasBaseTypeConflict() && typeSymbol.getExtendedTypes().length > 1) {
+                var firstInterfaceASTWithExtendsClause = TypeScript.ArrayUtilities.firstOrDefault(typeSymbol.getDeclarations(), function (decl) {
+                    return decl.ast().heritageClauses !== null;
+                }).ast();
+                if (classOrInterface === firstInterfaceASTWithExtendsClause) {
+                    this.typeCheckCallBacks.push(function (context) {
+                        _this.checkTypeCompatibilityBetweenBases(classOrInterface.identifier, typeSymbol, context);
+                    });
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.checkTypeCompatibilityBetweenBases = function (name, typeSymbol, context) {
+            var derivedIndexSignatures = typeSymbol.getOwnIndexSignatures();
+
+            var inheritedMembersMap = TypeScript.createIntrinsicsObject();
+            var inheritedIndexSignatures = new InheritedIndexSignatureInfo();
+
+            var typeHasOwnNumberIndexer = false;
+            var typeHasOwnStringIndexer = false;
+
+            if (typeSymbol.hasOwnIndexSignatures()) {
+                var ownIndexSignatures = typeSymbol.getOwnIndexSignatures();
+                for (var i = 0; i < ownIndexSignatures.length; i++) {
+                    if (ownIndexSignatures[i].parameters[0].type === this.semanticInfoChain.numberTypeSymbol) {
+                        typeHasOwnNumberIndexer = true;
+                    } else {
+                        typeHasOwnStringIndexer = true;
+                    }
+                }
+            }
+            var baseTypes = typeSymbol.getExtendedTypes();
+            for (var i = 0; i < baseTypes.length; i++) {
+                if (this.checkNamedPropertyIdentityBetweenBases(name, typeSymbol, baseTypes[i], inheritedMembersMap, context) || this.checkIndexSignatureIdentityBetweenBases(name, typeSymbol, baseTypes[i], inheritedIndexSignatures, typeHasOwnNumberIndexer, typeHasOwnStringIndexer, context)) {
+                    return;
+                }
+            }
+
+            if (this.checkThatInheritedNumberSignatureIsSubtypeOfInheritedStringSignature(name, typeSymbol, inheritedIndexSignatures, context)) {
+                return;
+            }
+
+            this.checkInheritedMembersAgainstInheritedIndexSignatures(name, typeSymbol, inheritedIndexSignatures, inheritedMembersMap, context);
+        };
+
+        PullTypeResolver.prototype.checkNamedPropertyIdentityBetweenBases = function (interfaceName, interfaceSymbol, baseTypeSymbol, inheritedMembersMap, context) {
+            var baseMembers = baseTypeSymbol.getAllMembers(4096 /* Property */ | 65536 /* Method */, 0 /* all */);
+            for (var i = 0; i < baseMembers.length; i++) {
+                var member = baseMembers[i];
+                var memberName = member.name;
+
+                if (interfaceSymbol.findMember(memberName, false)) {
+                    continue;
+                }
+
+                this.resolveDeclaredSymbol(member, context);
+
+                if (inheritedMembersMap[memberName]) {
+                    var prevMember = inheritedMembersMap[memberName];
+                    if (prevMember.baseOrigin !== baseTypeSymbol && !this.propertiesAreIdenticalWithNewEnclosingTypes(baseTypeSymbol, prevMember.baseOrigin, member, prevMember.memberSymbol, context)) {
+                        var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Named_properties_0_of_types_1_and_2_are_not_identical, [memberName, prevMember.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName()]);
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(), prevMember.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName(), innerDiagnostic]));
+                        return true;
+                    }
+                } else {
+                    inheritedMembersMap[memberName] = new MemberWithBaseOrigin(member, baseTypeSymbol);
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.checkIndexSignatureIdentityBetweenBases = function (interfaceName, interfaceSymbol, baseTypeSymbol, allInheritedSignatures, derivedTypeHasOwnNumberSignature, derivedTypeHasOwnStringSignature, context) {
+            if (derivedTypeHasOwnNumberSignature && derivedTypeHasOwnStringSignature) {
+                return false;
+            }
+
+            var indexSignaturesFromThisBaseType = baseTypeSymbol.getIndexSignatures();
+            for (var i = 0; i < indexSignaturesFromThisBaseType.length; i++) {
+                var currentInheritedSignature = indexSignaturesFromThisBaseType[i];
+
+                var parameterTypeIsString = currentInheritedSignature.parameters[0].type === this.semanticInfoChain.stringTypeSymbol;
+                var parameterTypeIsNumber = currentInheritedSignature.parameters[0].type === this.semanticInfoChain.numberTypeSymbol;
+
+                if (parameterTypeIsString && derivedTypeHasOwnStringSignature || parameterTypeIsNumber && derivedTypeHasOwnNumberSignature) {
+                    continue;
+                }
+
+                if (parameterTypeIsString) {
+                    if (allInheritedSignatures.stringSignatureWithBaseOrigin) {
+                        if (allInheritedSignatures.stringSignatureWithBaseOrigin.baseOrigin !== baseTypeSymbol && !this.typesAreIdentical(allInheritedSignatures.stringSignatureWithBaseOrigin.signature.returnType, currentInheritedSignature.returnType, context)) {
+                            var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_string_indexer_of_types_0_and_1_are_not_identical, [allInheritedSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName()]);
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(), allInheritedSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName(), innerDiagnostic]));
+                            return true;
+                        }
+                    } else {
+                        allInheritedSignatures.stringSignatureWithBaseOrigin = new SignatureWithBaseOrigin(currentInheritedSignature, baseTypeSymbol);
+                    }
+                } else if (parameterTypeIsNumber) {
+                    if (allInheritedSignatures.numberSignatureWithBaseOrigin) {
+                        if (allInheritedSignatures.numberSignatureWithBaseOrigin.baseOrigin !== baseTypeSymbol && !this.typesAreIdentical(allInheritedSignatures.numberSignatureWithBaseOrigin.signature.returnType, currentInheritedSignature.returnType, context)) {
+                            var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_number_indexer_of_types_0_and_1_are_not_identical, [allInheritedSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName()]);
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(), allInheritedSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName(), innerDiagnostic]));
+                            return true;
+                        }
+                    } else {
+                        allInheritedSignatures.numberSignatureWithBaseOrigin = new SignatureWithBaseOrigin(currentInheritedSignature, baseTypeSymbol);
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.checkInheritedMembersAgainstInheritedIndexSignatures = function (interfaceName, interfaceSymbol, inheritedIndexSignatures, inheritedMembers, context) {
+            if (!inheritedIndexSignatures.stringSignatureWithBaseOrigin && !inheritedIndexSignatures.numberSignatureWithBaseOrigin) {
+                return false;
+            }
+
+            var comparisonInfo = new TypeComparisonInfo();
+            var stringSignature = inheritedIndexSignatures.stringSignatureWithBaseOrigin && inheritedIndexSignatures.stringSignatureWithBaseOrigin.signature;
+            var numberSignature = inheritedIndexSignatures.numberSignatureWithBaseOrigin && inheritedIndexSignatures.numberSignatureWithBaseOrigin.signature;
+            for (var memberName in inheritedMembers) {
+                var memberWithBaseOrigin = inheritedMembers[memberName];
+                if (!memberWithBaseOrigin) {
+                    continue;
+                }
+
+                var relevantSignature = this.determineRelevantIndexerForMember(memberWithBaseOrigin.memberSymbol, numberSignature, stringSignature);
+                if (!relevantSignature) {
+                    continue;
+                }
+
+                var relevantSignatureIsNumberSignature = relevantSignature.parameters[0].type === this.semanticInfoChain.numberTypeSymbol;
+                var signatureBaseOrigin = relevantSignatureIsNumberSignature ? inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin : inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin;
+
+                if (signatureBaseOrigin === memberWithBaseOrigin.baseOrigin) {
+                    continue;
+                }
+
+                var memberIsSubtype = this.sourceIsAssignableToTarget(memberWithBaseOrigin.memberSymbol.type, relevantSignature.returnType, interfaceName, context, comparisonInfo);
+
+                if (!memberIsSubtype) {
+                    var enclosingSymbol = this.getEnclosingSymbolForAST(interfaceName);
+                    if (relevantSignatureIsNumberSignature) {
+                        var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_of_property_0_in_type_1_is_not_assignable_to_number_indexer_type_in_type_2_NL_3, [memberName, memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), comparisonInfo.message]);
+
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(enclosingSymbol), memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), innerDiagnostic]));
+                    } else {
+                        var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_of_property_0_in_type_1_is_not_assignable_to_string_indexer_type_in_type_2_NL_3, [memberName, memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), comparisonInfo.message]);
+
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(enclosingSymbol), memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), innerDiagnostic]));
+                    }
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.checkThatInheritedNumberSignatureIsSubtypeOfInheritedStringSignature = function (interfaceName, interfaceSymbol, inheritedIndexSignatures, context) {
+            if (inheritedIndexSignatures.numberSignatureWithBaseOrigin && inheritedIndexSignatures.stringSignatureWithBaseOrigin) {
+                if (inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin === inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin) {
+                    return false;
+                }
+
+                var comparisonInfo = new TypeComparisonInfo();
+                var signatureIsSubtype = this.sourceIsAssignableToTarget(inheritedIndexSignatures.numberSignatureWithBaseOrigin.signature.returnType, inheritedIndexSignatures.stringSignatureWithBaseOrigin.signature.returnType, interfaceName, context, comparisonInfo);
+
+                if (!signatureIsSubtype) {
+                    var enclosingSymbol = this.getEnclosingSymbolForAST(interfaceName);
+                    var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_of_number_indexer_in_type_0_is_not_assignable_to_string_indexer_type_in_type_1_NL_2, [
+                        inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol),
+                        inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), comparisonInfo.message]);
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [
+                        interfaceSymbol.getDisplayName(enclosingSymbol), inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(),
+                        inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), innerDiagnostic]));
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.checkAssignability = function (ast, source, target, context) {
+            var comparisonInfo = new TypeComparisonInfo();
+
+            var isAssignable = this.sourceIsAssignableToTarget(source, target, ast, context, comparisonInfo);
+
+            if (!isAssignable) {
+                var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                if (comparisonInfo.message) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfo.message]));
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)]));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.isReference = function (ast, astSymbol) {
+            if (ast.kind() === 217 /* ParenthesizedExpression */) {
+                return this.isReference(ast.expression, astSymbol);
+            }
+
+            if (ast.kind() !== 11 /* IdentifierName */ && ast.kind() !== 212 /* MemberAccessExpression */ && ast.kind() !== 221 /* ElementAccessExpression */) {
+                return false;
+            }
+
+            if (ast.kind() === 11 /* IdentifierName */) {
+                if (astSymbol.kind === 512 /* Variable */ && astSymbol.anyDeclHasFlag(4096 /* Enum */)) {
+                    return false;
+                }
+
+                if (astSymbol.kind === 512 /* Variable */ && astSymbol.anyDeclHasFlag(102400 /* SomeInitializedModule */)) {
+                    return false;
+                }
+
+                if (astSymbol.kind === 32768 /* ConstructorMethod */ || astSymbol.kind === 16384 /* Function */) {
+                    return false;
+                }
+            }
+
+            if (ast.kind() === 212 /* MemberAccessExpression */ && astSymbol.kind === 67108864 /* EnumMember */) {
+                return false;
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.checkForSuperMemberAccess = function (expression, name, resolvedName, context) {
+            if (resolvedName) {
+                if (expression.kind() === 50 /* SuperKeyword */ && !resolvedName.isError() && resolvedName.kind !== 65536 /* Method */) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode.Only_public_methods_of_the_base_class_are_accessible_via_the_super_keyword));
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.getEnclosingDeclForAST = function (ast) {
+            return this.semanticInfoChain.getEnclosingDecl(ast);
+        };
+
+        PullTypeResolver.prototype.getEnclosingSymbolForAST = function (ast) {
+            var enclosingDecl = this.getEnclosingDeclForAST(ast);
+            return enclosingDecl ? enclosingDecl.getSymbol() : null;
+        };
+
+        PullTypeResolver.prototype.checkForPrivateMemberAccess = function (name, expressionType, resolvedName, context) {
+            if (resolvedName) {
+                if (resolvedName.anyDeclHasFlag(2 /* Private */)) {
+                    var memberContainer = resolvedName.getContainer();
+                    if (memberContainer && memberContainer.kind === 33554432 /* ConstructorType */) {
+                        memberContainer = memberContainer.getAssociatedContainerType();
+                    }
+
+                    if (memberContainer && memberContainer.isClass()) {
+                        var memberClass = memberContainer.getDeclarations()[0].ast();
+                        TypeScript.Debug.assert(memberClass);
+
+                        var containingClass = this.getEnclosingClassDeclaration(name);
+
+                        if (!containingClass || containingClass !== memberClass) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode._0_1_is_inaccessible, [memberContainer.toString(null, false), name.text()]));
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.instantiateType = function (type, typeParameterArgumentMap) {
+            if (type.isPrimitive()) {
+                return type;
+            }
+
+            if (type.isError()) {
+                return type;
+            }
+
+            if (typeParameterArgumentMap[type.pullSymbolID]) {
+                return typeParameterArgumentMap[type.pullSymbolID];
+            }
+
+            type._resolveDeclaredSymbol();
+            if (type.isTypeParameter()) {
+                return this.instantiateTypeParameter(type, typeParameterArgumentMap);
+            }
+
+            if (type.wrapsSomeTypeParameter(typeParameterArgumentMap)) {
+                return TypeScript.PullInstantiatedTypeReferenceSymbol.create(this, type, typeParameterArgumentMap);
+            }
+
+            return type;
+        };
+
+        PullTypeResolver.prototype.instantiateTypeParameter = function (typeParameter, typeParameterArgumentMap) {
+            var constraint = typeParameter.getConstraint();
+            if (!constraint) {
+                return typeParameter;
+            }
+
+            var instantiatedConstraint = this.instantiateType(constraint, typeParameterArgumentMap);
+
+            if (instantiatedConstraint == constraint) {
+                return typeParameter;
+            }
+
+            var rootTypeParameter = typeParameter.getRootSymbol();
+            var instantiation = rootTypeParameter.getSpecialization([instantiatedConstraint]);
+            if (instantiation) {
+                return instantiation;
+            }
+
+            instantiation = new TypeScript.PullInstantiatedTypeParameterSymbol(rootTypeParameter, instantiatedConstraint);
+            return instantiation;
+        };
+
+        PullTypeResolver.prototype.instantiateSignature = function (signature, typeParameterArgumentMap) {
+            if (!signature.wrapsSomeTypeParameter(typeParameterArgumentMap)) {
+                return signature;
+            }
+
+            var rootSignature = signature.getRootSymbol();
+            var mutableTypeParameterMap = new TypeScript.PullInstantiationHelpers.MutableTypeArgumentMap(typeParameterArgumentMap);
+            TypeScript.PullInstantiationHelpers.instantiateTypeArgument(this, signature, mutableTypeParameterMap);
+
+            var instantiatedSignature = rootSignature.getSpecialization(mutableTypeParameterMap.typeParameterArgumentMap);
+            if (instantiatedSignature) {
+                return instantiatedSignature;
+            }
+
+            TypeScript.PullInstantiationHelpers.cleanUpTypeArgumentMap(signature, mutableTypeParameterMap);
+            typeParameterArgumentMap = mutableTypeParameterMap.typeParameterArgumentMap;
+
+            instantiatedSignature = new TypeScript.PullInstantiatedSignatureSymbol(rootSignature, typeParameterArgumentMap);
+
+            instantiatedSignature.returnType = this.instantiateType((rootSignature.returnType || this.semanticInfoChain.anyTypeSymbol), typeParameterArgumentMap);
+            instantiatedSignature.functionType = this.instantiateType(rootSignature.functionType, typeParameterArgumentMap);
+
+            var parameters = rootSignature.parameters;
+            var parameter = null;
+
+            if (parameters) {
+                for (var j = 0; j < parameters.length; j++) {
+                    parameter = new TypeScript.PullSymbol(parameters[j].name, 2048 /* Parameter */);
+                    parameter.setRootSymbol(parameters[j]);
+
+                    if (parameters[j].isOptional) {
+                        parameter.isOptional = true;
+                    }
+                    if (parameters[j].isVarArg) {
+                        parameter.isVarArg = true;
+                        instantiatedSignature.hasVarArgs = true;
+                    }
+                    instantiatedSignature.addParameter(parameter, parameter.isOptional);
+
+                    parameter.type = this.instantiateType(parameters[j].type, typeParameterArgumentMap);
+                }
+            }
+
+            return instantiatedSignature;
+        };
+        PullTypeResolver.globalTypeCheckPhase = 0;
+        return PullTypeResolver;
+    })();
+    TypeScript.PullTypeResolver = PullTypeResolver;
+
+    var TypeComparisonInfo = (function () {
+        function TypeComparisonInfo(sourceComparisonInfo, useSameIndent) {
+            this.onlyCaptureFirstError = false;
+            this.flags = 0 /* SuccessfulComparison */;
+            this.message = "";
+            this.stringConstantVal = null;
+            this.indent = 1;
+            if (sourceComparisonInfo) {
+                this.flags = sourceComparisonInfo.flags;
+                this.onlyCaptureFirstError = sourceComparisonInfo.onlyCaptureFirstError;
+                this.stringConstantVal = sourceComparisonInfo.stringConstantVal;
+                this.indent = sourceComparisonInfo.indent;
+                if (!useSameIndent) {
+                    this.indent++;
+                }
+            }
+        }
+        TypeComparisonInfo.prototype.indentString = function () {
+            var result = "";
+
+            for (var i = 0; i < this.indent; i++) {
+                result += "\t";
+            }
+
+            return result;
+        };
+
+        TypeComparisonInfo.prototype.addMessage = function (message) {
+            if (!this.onlyCaptureFirstError && this.message) {
+                this.message = this.message + TypeScript.newLine() + this.indentString() + message;
+            } else {
+                this.message = this.indentString() + message;
+            }
+        };
+        return TypeComparisonInfo;
+    })();
+    TypeScript.TypeComparisonInfo = TypeComparisonInfo;
+
+    function getPropertyAssignmentNameTextFromIdentifier(identifier) {
+        if (identifier.kind() === 11 /* IdentifierName */) {
+            return { actualText: identifier.text(), memberName: identifier.valueText() };
+        } else if (identifier.kind() === 14 /* StringLiteral */) {
+            return { actualText: identifier.text(), memberName: identifier.valueText() };
+        } else if (identifier.kind() === 13 /* NumericLiteral */) {
+            return { actualText: identifier.text(), memberName: identifier.valueText() };
+        } else {
+            throw TypeScript.Errors.invalidOperation();
+        }
+    }
+    TypeScript.getPropertyAssignmentNameTextFromIdentifier = getPropertyAssignmentNameTextFromIdentifier;
+
+    function isTypesOnlyLocation(ast) {
+        while (ast && ast.parent) {
+            switch (ast.parent.kind()) {
+                case 244 /* TypeAnnotation */:
+                    return true;
+                case 127 /* TypeQuery */:
+                    return false;
+                case 125 /* ConstructorType */:
+                    var constructorType = ast.parent;
+                    if (constructorType.type === ast) {
+                        return true;
+                    }
+                    break;
+                case 123 /* FunctionType */:
+                    var functionType = ast.parent;
+                    if (functionType.type === ast) {
+                        return true;
+                    }
+                    break;
+                case 239 /* Constraint */:
+                    var constraint = ast.parent;
+                    if (constraint.type === ast) {
+                        return true;
+                    }
+                    break;
+                case 220 /* CastExpression */:
+                    var castExpression = ast.parent;
+                    return castExpression.type === ast;
+                case 230 /* ExtendsHeritageClause */:
+                case 231 /* ImplementsHeritageClause */:
+                    return true;
+                case 228 /* TypeArgumentList */:
+                    return true;
+                case 131 /* ClassDeclaration */:
+                case 128 /* InterfaceDeclaration */:
+                case 130 /* ModuleDeclaration */:
+                case 129 /* FunctionDeclaration */:
+                case 145 /* MethodSignature */:
+                case 212 /* MemberAccessExpression */:
+                case 242 /* Parameter */:
+                    return false;
+            }
+
+            ast = ast.parent;
+        }
+
+        return false;
+    }
+    TypeScript.isTypesOnlyLocation = isTypesOnlyLocation;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    TypeScript.declCacheHit = 0;
+    TypeScript.declCacheMiss = 0;
+    TypeScript.symbolCacheHit = 0;
+    TypeScript.symbolCacheMiss = 0;
+
+    var sentinalEmptyArray = [];
+
+    var SemanticInfoChain = (function () {
+        function SemanticInfoChain(compiler, logger) {
+            this.compiler = compiler;
+            this.logger = logger;
+            this.documents = [];
+            this.fileNameToDocument = TypeScript.createIntrinsicsObject();
+            this.anyTypeDecl = null;
+            this.booleanTypeDecl = null;
+            this.numberTypeDecl = null;
+            this.stringTypeDecl = null;
+            this.nullTypeDecl = null;
+            this.undefinedTypeDecl = null;
+            this.voidTypeDecl = null;
+            this.undefinedValueDecl = null;
+            this.anyTypeSymbol = null;
+            this.booleanTypeSymbol = null;
+            this.numberTypeSymbol = null;
+            this.stringTypeSymbol = null;
+            this.nullTypeSymbol = null;
+            this.undefinedTypeSymbol = null;
+            this.voidTypeSymbol = null;
+            this.undefinedValueSymbol = null;
+            this.emptyTypeSymbol = null;
+            this.astSymbolMap = [];
+            this.astAliasSymbolMap = [];
+            this.astCallResolutionDataMap = [];
+            this.declSymbolMap = [];
+            this.declSignatureSymbolMap = [];
+            this.declCache = null;
+            this.symbolCache = null;
+            this.fileNameToDiagnostics = null;
+            this._binder = null;
+            this._resolver = null;
+            this._topLevelDecls = null;
+            this._fileNames = null;
+            var globalDecl = new TypeScript.RootPullDecl("", "", 0 /* Global */, 0 /* None */, this, false);
+            this.documents[0] = new TypeScript.Document(this.compiler, this, "", [], null, 0 /* None */, 0, false, null, globalDecl);
+
+            this.anyTypeDecl = new TypeScript.NormalPullDecl("any", "any", 2 /* Primitive */, 0 /* None */, globalDecl);
+            this.booleanTypeDecl = new TypeScript.NormalPullDecl("boolean", "boolean", 2 /* Primitive */, 0 /* None */, globalDecl);
+            this.numberTypeDecl = new TypeScript.NormalPullDecl("number", "number", 2 /* Primitive */, 0 /* None */, globalDecl);
+            this.stringTypeDecl = new TypeScript.NormalPullDecl("string", "string", 2 /* Primitive */, 0 /* None */, globalDecl);
+            this.voidTypeDecl = new TypeScript.NormalPullDecl("void", "void", 2 /* Primitive */, 0 /* None */, globalDecl);
+
+            this.nullTypeDecl = new TypeScript.RootPullDecl("null", "", 2 /* Primitive */, 0 /* None */, this, false);
+            this.undefinedTypeDecl = new TypeScript.RootPullDecl("undefined", "", 2 /* Primitive */, 0 /* None */, this, false);
+            this.undefinedValueDecl = new TypeScript.NormalPullDecl("undefined", "undefined", 512 /* Variable */, 8 /* Ambient */, globalDecl);
+
+            this.invalidate();
+        }
+        SemanticInfoChain.prototype.getDocument = function (fileName) {
+            var document = this.fileNameToDocument[fileName];
+            return document || null;
+        };
+
+        SemanticInfoChain.prototype.lineMap = function (fileName) {
+            return this.getDocument(fileName).lineMap();
+        };
+
+        SemanticInfoChain.prototype.fileNames = function () {
+            if (this._fileNames === null) {
+                this._fileNames = this.documents.slice(1).map(function (s) {
+                    return s.fileName;
+                });
+            }
+
+            return this._fileNames;
+        };
+
+        SemanticInfoChain.prototype.bindPrimitiveSymbol = function (decl, newSymbol) {
+            newSymbol.addDeclaration(decl);
+            decl.setSymbol(newSymbol);
+            newSymbol.setResolved();
+
+            return newSymbol;
+        };
+
+        SemanticInfoChain.prototype.addPrimitiveTypeSymbol = function (decl) {
+            var newSymbol = new TypeScript.PullPrimitiveTypeSymbol(decl.name);
+            return this.bindPrimitiveSymbol(decl, newSymbol);
+        };
+
+        SemanticInfoChain.prototype.addPrimitiveValueSymbol = function (decl, type) {
+            var newSymbol = new TypeScript.PullSymbol(decl.name, 512 /* Variable */);
+            newSymbol.type = type;
+            return this.bindPrimitiveSymbol(decl, newSymbol);
+        };
+
+        SemanticInfoChain.prototype.resetGlobalSymbols = function () {
+            this.anyTypeSymbol = this.addPrimitiveTypeSymbol(this.anyTypeDecl);
+            this.booleanTypeSymbol = this.addPrimitiveTypeSymbol(this.booleanTypeDecl);
+            this.numberTypeSymbol = this.addPrimitiveTypeSymbol(this.numberTypeDecl);
+            this.stringTypeSymbol = this.addPrimitiveTypeSymbol(this.stringTypeDecl);
+            this.voidTypeSymbol = this.addPrimitiveTypeSymbol(this.voidTypeDecl);
+            this.nullTypeSymbol = this.addPrimitiveTypeSymbol(this.nullTypeDecl);
+            this.undefinedTypeSymbol = this.addPrimitiveTypeSymbol(this.undefinedTypeDecl);
+            this.undefinedValueSymbol = this.addPrimitiveValueSymbol(this.undefinedValueDecl, this.undefinedTypeSymbol);
+
+            var emptyTypeDecl = new TypeScript.PullSynthesizedDecl("{}", "{}", 8388608 /* ObjectType */, 0 /* None */, null, this);
+            var emptyTypeSymbol = new TypeScript.PullTypeSymbol("{}", 8388608 /* ObjectType */);
+            emptyTypeDecl.setSymbol(emptyTypeSymbol);
+            emptyTypeSymbol.addDeclaration(emptyTypeDecl);
+            emptyTypeSymbol.setResolved();
+            this.emptyTypeSymbol = emptyTypeSymbol;
+        };
+
+        SemanticInfoChain.prototype.addDocument = function (document) {
+            var fileName = document.fileName;
+
+            var existingIndex = TypeScript.ArrayUtilities.indexOf(this.documents, function (u) {
+                return u.fileName === fileName;
+            });
+            if (existingIndex < 0) {
+                this.documents.push(document);
+            } else {
+                this.documents[existingIndex] = document;
+            }
+
+            this.fileNameToDocument[fileName] = document;
+
+            this.invalidate();
+        };
+
+        SemanticInfoChain.prototype.removeDocument = function (fileName) {
+            TypeScript.Debug.assert(fileName !== "", "Can't remove the semantic info for the global decl.");
+            var index = TypeScript.ArrayUtilities.indexOf(this.documents, function (u) {
+                return u.fileName === fileName;
+            });
+            if (index > 0) {
+                this.fileNameToDocument[fileName] = undefined;
+                this.documents.splice(index, 1);
+                this.invalidate();
+            }
+        };
+
+        SemanticInfoChain.prototype.getDeclPathCacheID = function (declPath, declKind) {
+            var cacheID = "";
+
+            for (var i = 0; i < declPath.length; i++) {
+                cacheID += "#" + declPath[i];
+            }
+
+            return cacheID + "#" + declKind.toString();
+        };
+
+        SemanticInfoChain.prototype.findTopLevelSymbol = function (name, kind, doNotGoPastThisDecl) {
+            var cacheID = this.getDeclPathCacheID([name], kind);
+
+            var symbol = this.symbolCache[cacheID];
+
+            if (!symbol) {
+                for (var i = 0, n = this.documents.length; i < n; i++) {
+                    var topLevelDecl = this.documents[i].topLevelDecl();
+
+                    var symbol = this.findTopLevelSymbolInDecl(topLevelDecl, name, kind, doNotGoPastThisDecl);
+                    if (symbol) {
+                        break;
+                    }
+
+                    if (doNotGoPastThisDecl && topLevelDecl.name === doNotGoPastThisDecl.fileName()) {
+                        return null;
+                    }
+                }
+
+                if (symbol) {
+                    this.symbolCache[cacheID] = symbol;
+                }
+            }
+
+            return symbol;
+        };
+
+        SemanticInfoChain.prototype.findTopLevelSymbolInDecl = function (topLevelDecl, name, kind, doNotGoPastThisDecl) {
+            var doNotGoPastThisPosition = doNotGoPastThisDecl && doNotGoPastThisDecl.fileName() === topLevelDecl.fileName() ? doNotGoPastThisDecl.ast().start() : -1;
+
+            var foundDecls = topLevelDecl.searchChildDecls(name, kind);
+
+            for (var j = 0; j < foundDecls.length; j++) {
+                var foundDecl = foundDecls[j];
+
+                if (doNotGoPastThisPosition !== -1 && foundDecl.ast() && foundDecl.ast().start() > doNotGoPastThisPosition) {
+                    break;
+                }
+
+                var symbol = foundDecls[j].getSymbol();
+                if (symbol) {
+                    return symbol;
+                }
+            }
+
+            return null;
+        };
+
+        SemanticInfoChain.prototype.findExternalModule = function (id) {
+            id = TypeScript.normalizePath(id);
+
+            var tsFile = id + ".ts";
+            var tsCacheID = this.getDeclPathCacheID([tsFile], 32 /* DynamicModule */);
+            symbol = this.symbolCache[tsCacheID];
+            if (symbol != undefined) {
+                return symbol;
+            }
+
+            var dtsFile = id + ".d.ts";
+            var dtsCacheID = this.getDeclPathCacheID([dtsFile], 32 /* DynamicModule */);
+            var symbol = this.symbolCache[dtsCacheID];
+            if (symbol) {
+                return symbol;
+            }
+
+            var dtsSymbol;
+            for (var i = 0; i < this.documents.length; i++) {
+                var document = this.documents[i];
+                var topLevelDecl = document.topLevelDecl();
+
+                if (topLevelDecl.isExternalModule()) {
+                    var isTsFile = document.fileName === tsFile;
+                    if (isTsFile || document.fileName === dtsFile) {
+                        var dynamicModuleDecl = topLevelDecl.getChildDecls()[0];
+                        symbol = dynamicModuleDecl.getSymbol();
+
+                        if (isTsFile) {
+                            this.symbolCache[tsCacheID] = symbol;
+
+                            return symbol;
+                        } else {
+                            dtsSymbol = symbol;
+                        }
+                    }
+                }
+            }
+
+            if (dtsSymbol) {
+                this.symbolCache[dtsCacheID] = symbol;
+                return dtsSymbol;
+            }
+
+            this.symbolCache[dtsCacheID] = null;
+            this.symbolCache[tsCacheID] = null;
+
+            return null;
+        };
+
+        SemanticInfoChain.prototype.findAmbientExternalModuleInGlobalContext = function (id) {
+            var cacheID = this.getDeclPathCacheID([id], 32 /* DynamicModule */);
+
+            var symbol = this.symbolCache[cacheID];
+            if (symbol == undefined) {
+                symbol = null;
+                for (var i = 0; i < this.documents.length; i++) {
+                    var document = this.documents[i];
+                    var topLevelDecl = document.topLevelDecl();
+
+                    if (!topLevelDecl.isExternalModule()) {
+                        var dynamicModules = topLevelDecl.searchChildDecls(id, 32 /* DynamicModule */);
+                        if (dynamicModules.length) {
+                            symbol = dynamicModules[0].getSymbol();
+                            break;
+                        }
+                    }
+                }
+
+                this.symbolCache[cacheID] = symbol;
+            }
+
+            return symbol;
+        };
+
+        SemanticInfoChain.prototype.findDecls = function (declPath, declKind) {
+            var cacheID = this.getDeclPathCacheID(declPath, declKind);
+
+            if (declPath.length) {
+                var cachedDecls = this.declCache[cacheID];
+
+                if (cachedDecls && cachedDecls.length) {
+                    TypeScript.declCacheHit++;
+                    return cachedDecls;
+                }
+            }
+
+            TypeScript.declCacheMiss++;
+
+            var declsToSearch = this.topLevelDecls();
+
+            var decls = TypeScript.sentinelEmptyArray;
+            var path;
+            var foundDecls = TypeScript.sentinelEmptyArray;
+
+            for (var i = 0; i < declPath.length; i++) {
+                path = declPath[i];
+                decls = TypeScript.sentinelEmptyArray;
+
+                var kind = (i === declPath.length - 1) ? declKind : 164 /* SomeContainer */;
+                for (var j = 0; j < declsToSearch.length; j++) {
+                    foundDecls = declsToSearch[j].searchChildDecls(path, kind);
+
+                    for (var k = 0; k < foundDecls.length; k++) {
+                        if (decls === TypeScript.sentinelEmptyArray) {
+                            decls = [];
+                        }
+                        decls[decls.length] = foundDecls[k];
+                    }
+                }
+
+                declsToSearch = decls;
+
+                if (!declsToSearch) {
+                    break;
+                }
+            }
+
+            if (decls.length) {
+                this.declCache[cacheID] = decls;
+            }
+
+            return decls;
+        };
+
+        SemanticInfoChain.prototype.findDeclsFromPath = function (declPath, declKind) {
+            var declString = [];
+
+            for (var i = 0, n = declPath.length; i < n; i++) {
+                if (declPath[i].kind & 1 /* Script */) {
+                    continue;
+                }
+
+                declString.push(declPath[i].name);
+            }
+
+            return this.findDecls(declString, declKind);
+        };
+
+        SemanticInfoChain.prototype.findSymbol = function (declPath, declType) {
+            var cacheID = this.getDeclPathCacheID(declPath, declType);
+
+            if (declPath.length) {
+                var cachedSymbol = this.symbolCache[cacheID];
+
+                if (cachedSymbol) {
+                    TypeScript.symbolCacheHit++;
+                    return cachedSymbol;
+                }
+            }
+
+            TypeScript.symbolCacheMiss++;
+
+            var decls = this.findDecls(declPath, declType);
+            var symbol = null;
+
+            if (decls.length) {
+                var decl = decls[0];
+                if (TypeScript.hasFlag(decl.kind, 164 /* SomeContainer */)) {
+                    var valueDecl = decl.getValueDecl();
+                    if (valueDecl) {
+                        valueDecl.ensureSymbolIsBound();
+                    }
+                }
+                symbol = decl.getSymbol();
+
+                if (symbol) {
+                    for (var i = 1; i < decls.length; i++) {
+                        decls[i].ensureSymbolIsBound();
+                    }
+
+                    this.symbolCache[cacheID] = symbol;
+                }
+            }
+
+            return symbol;
+        };
+
+        SemanticInfoChain.prototype.cacheGlobalSymbol = function (symbol, kind) {
+            var cacheID1 = this.getDeclPathCacheID([symbol.name], kind);
+            var cacheID2 = this.getDeclPathCacheID([symbol.name], symbol.kind);
+
+            if (!this.symbolCache[cacheID1]) {
+                this.symbolCache[cacheID1] = symbol;
+            }
+
+            if (!this.symbolCache[cacheID2]) {
+                this.symbolCache[cacheID2] = symbol;
+            }
+        };
+
+        SemanticInfoChain.prototype.invalidate = function (oldSettings, newSettings) {
+            if (typeof oldSettings === "undefined") { oldSettings = null; }
+            if (typeof newSettings === "undefined") { newSettings = null; }
+            TypeScript.PullTypeResolver.globalTypeCheckPhase++;
+
+            var cleanStart = new Date().getTime();
+
+            this.astSymbolMap.length = 0;
+            this.astAliasSymbolMap.length = 0;
+            this.astCallResolutionDataMap.length = 0;
+
+            this.declCache = TypeScript.createIntrinsicsObject();
+            this.symbolCache = TypeScript.createIntrinsicsObject();
+            this.fileNameToDiagnostics = TypeScript.createIntrinsicsObject();
+            this._binder = null;
+            this._resolver = null;
+            this._topLevelDecls = null;
+            this._fileNames = null;
+
+            this.declSymbolMap.length = 0;
+            this.declSignatureSymbolMap.length = 0;
+
+            if (oldSettings && newSettings) {
+                if (this.settingsChangeAffectsSyntax(oldSettings, newSettings)) {
+                    for (var i = 1, n = this.documents.length; i < n; i++) {
+                        this.documents[i].invalidate();
+                    }
+                }
+            }
+
+            TypeScript.pullSymbolID = 0;
+
+            this.resetGlobalSymbols();
+
+            var cleanEnd = new Date().getTime();
+        };
+
+        SemanticInfoChain.prototype.settingsChangeAffectsSyntax = function (before, after) {
+            return before.allowAutomaticSemicolonInsertion() !== after.allowAutomaticSemicolonInsertion() || before.codeGenTarget() !== after.codeGenTarget() || before.propagateEnumConstants() !== after.propagateEnumConstants();
+        };
+
+        SemanticInfoChain.prototype.setSymbolForAST = function (ast, symbol) {
+            this.astSymbolMap[ast.syntaxID()] = symbol;
+        };
+
+        SemanticInfoChain.prototype.getSymbolForAST = function (ast) {
+            return this.astSymbolMap[ast.syntaxID()] || null;
+        };
+
+        SemanticInfoChain.prototype.setAliasSymbolForAST = function (ast, symbol) {
+            this.astAliasSymbolMap[ast.syntaxID()] = symbol;
+        };
+
+        SemanticInfoChain.prototype.getAliasSymbolForAST = function (ast) {
+            return this.astAliasSymbolMap[ast.syntaxID()];
+        };
+
+        SemanticInfoChain.prototype.getCallResolutionDataForAST = function (ast) {
+            return this.astCallResolutionDataMap[ast.syntaxID()];
+        };
+
+        SemanticInfoChain.prototype.setCallResolutionDataForAST = function (ast, callResolutionData) {
+            if (callResolutionData) {
+                this.astCallResolutionDataMap[ast.syntaxID()] = callResolutionData;
+            }
+        };
+
+        SemanticInfoChain.prototype.setSymbolForDecl = function (decl, symbol) {
+            this.declSymbolMap[decl.declID] = symbol;
+        };
+
+        SemanticInfoChain.prototype.getSymbolForDecl = function (decl) {
+            return this.declSymbolMap[decl.declID];
+        };
+
+        SemanticInfoChain.prototype.setSignatureSymbolForDecl = function (decl, signatureSymbol) {
+            this.declSignatureSymbolMap[decl.declID] = signatureSymbol;
+        };
+
+        SemanticInfoChain.prototype.getSignatureSymbolForDecl = function (decl) {
+            return this.declSignatureSymbolMap[decl.declID];
+        };
+
+        SemanticInfoChain.prototype.addDiagnostic = function (diagnostic) {
+            var fileName = diagnostic.fileName();
+            var diagnostics = this.fileNameToDiagnostics[fileName];
+            if (!diagnostics) {
+                diagnostics = [];
+                this.fileNameToDiagnostics[fileName] = diagnostics;
+            }
+
+            diagnostics.push(diagnostic);
+        };
+
+        SemanticInfoChain.prototype.getDiagnostics = function (fileName) {
+            var diagnostics = this.fileNameToDiagnostics[fileName];
+            return diagnostics || [];
+        };
+
+        SemanticInfoChain.prototype.getBinder = function () {
+            if (!this._binder) {
+                this._binder = new TypeScript.PullSymbolBinder(this);
+            }
+
+            return this._binder;
+        };
+
+        SemanticInfoChain.prototype.getResolver = function () {
+            if (!this._resolver) {
+                this._resolver = new TypeScript.PullTypeResolver(this.compiler.compilationSettings(), this);
+            }
+
+            return this._resolver;
+        };
+
+        SemanticInfoChain.prototype.addSyntheticIndexSignature = function (containingDecl, containingSymbol, ast, indexParamName, indexParamType, returnType) {
+            var indexSignature = new TypeScript.PullSignatureSymbol(4194304 /* IndexSignature */);
+            var indexParameterSymbol = new TypeScript.PullSymbol(indexParamName, 2048 /* Parameter */);
+            indexParameterSymbol.type = indexParamType;
+            indexSignature.addParameter(indexParameterSymbol);
+            indexSignature.returnType = returnType;
+            indexSignature.setResolved();
+            indexParameterSymbol.setResolved();
+
+            containingSymbol.addIndexSignature(indexSignature);
+
+            var indexSigDecl = new TypeScript.PullSynthesizedDecl("", "", 4194304 /* IndexSignature */, 2048 /* Signature */, containingDecl, containingDecl.semanticInfoChain);
+            var indexParamDecl = new TypeScript.PullSynthesizedDecl(indexParamName, indexParamName, 2048 /* Parameter */, 0 /* None */, indexSigDecl, containingDecl.semanticInfoChain);
+            indexSigDecl.setSignatureSymbol(indexSignature);
+            indexParamDecl.setSymbol(indexParameterSymbol);
+            indexSignature.addDeclaration(indexSigDecl);
+            indexParameterSymbol.addDeclaration(indexParamDecl);
+        };
+
+        SemanticInfoChain.prototype.getDeclForAST = function (ast) {
+            var document = this.getDocument(ast.fileName());
+
+            if (document) {
+                return document._getDeclForAST(ast);
+            }
+
+            return null;
+        };
+
+        SemanticInfoChain.prototype.getEnclosingDecl = function (ast) {
+            return this.getDocument(ast.fileName()).getEnclosingDecl(ast);
+        };
+
+        SemanticInfoChain.prototype.setDeclForAST = function (ast, decl) {
+            this.getDocument(decl.fileName())._setDeclForAST(ast, decl);
+        };
+
+        SemanticInfoChain.prototype.getASTForDecl = function (decl) {
+            var document = this.getDocument(decl.fileName());
+            if (document) {
+                return document._getASTForDecl(decl);
+            }
+
+            return null;
+        };
+
+        SemanticInfoChain.prototype.setASTForDecl = function (decl, ast) {
+            this.getDocument(decl.fileName())._setASTForDecl(decl, ast);
+        };
+
+        SemanticInfoChain.prototype.topLevelDecl = function (fileName) {
+            var document = this.getDocument(fileName);
+            if (document) {
+                return document.topLevelDecl();
+            }
+
+            return null;
+        };
+
+        SemanticInfoChain.prototype.topLevelDecls = function () {
+            if (!this._topLevelDecls) {
+                this._topLevelDecls = TypeScript.ArrayUtilities.select(this.documents, function (u) {
+                    return u.topLevelDecl();
+                });
+            }
+
+            return this._topLevelDecls;
+        };
+
+        SemanticInfoChain.prototype.addDiagnosticFromAST = function (ast, diagnosticKey, _arguments, additionalLocations) {
+            if (typeof _arguments === "undefined") { _arguments = null; }
+            if (typeof additionalLocations === "undefined") { additionalLocations = null; }
+            this.addDiagnostic(this.diagnosticFromAST(ast, diagnosticKey, _arguments, additionalLocations));
+        };
+
+        SemanticInfoChain.prototype.diagnosticFromAST = function (ast, diagnosticKey, _arguments, additionalLocations) {
+            if (typeof _arguments === "undefined") { _arguments = null; }
+            if (typeof additionalLocations === "undefined") { additionalLocations = null; }
+            return new TypeScript.Diagnostic(ast.fileName(), this.lineMap(ast.fileName()), ast.start(), ast.width(), diagnosticKey, _arguments, additionalLocations);
+        };
+
+        SemanticInfoChain.prototype.locationFromAST = function (ast) {
+            return new TypeScript.Location(ast.fileName(), this.lineMap(ast.fileName()), ast.start(), ast.width());
+        };
+
+        SemanticInfoChain.prototype.duplicateIdentifierDiagnosticFromAST = function (ast, identifier, additionalLocationAST) {
+            return this.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Duplicate_identifier_0, [identifier], additionalLocationAST ? [this.locationFromAST(additionalLocationAST)] : null);
+        };
+
+        SemanticInfoChain.prototype.addDuplicateIdentifierDiagnosticFromAST = function (ast, identifier, additionalLocationAST) {
+            this.addDiagnostic(this.duplicateIdentifierDiagnosticFromAST(ast, identifier, additionalLocationAST));
+        };
+        return SemanticInfoChain;
+    })();
+    TypeScript.SemanticInfoChain = SemanticInfoChain;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var DeclCollectionContext = (function () {
+        function DeclCollectionContext(document, semanticInfoChain, propagateEnumConstants) {
+            this.document = document;
+            this.semanticInfoChain = semanticInfoChain;
+            this.propagateEnumConstants = propagateEnumConstants;
+            this.isDeclareFile = false;
+            this.parentChain = [];
+        }
+        DeclCollectionContext.prototype.getParent = function () {
+            return this.parentChain ? this.parentChain[this.parentChain.length - 1] : null;
+        };
+
+        DeclCollectionContext.prototype.pushParent = function (parentDecl) {
+            if (parentDecl) {
+                this.parentChain[this.parentChain.length] = parentDecl;
+            }
+        };
+
+        DeclCollectionContext.prototype.popParent = function () {
+            this.parentChain.length--;
+        };
+        return DeclCollectionContext;
+    })();
+
+    function moduleElementsHasExportAssignment(moduleElements) {
+        return moduleElements.any(function (m) {
+            return m.kind() === 134 /* ExportAssignment */;
+        });
+    }
+
+    function containingModuleHasExportAssignment(ast) {
+        ast = ast.parent;
+        while (ast) {
+            if (ast.kind() === 130 /* ModuleDeclaration */) {
+                var moduleDecl = ast;
+                return moduleElementsHasExportAssignment(moduleDecl.moduleElements);
+            } else if (ast.kind() === 120 /* SourceUnit */) {
+                var sourceUnit = ast;
+                return moduleElementsHasExportAssignment(sourceUnit.moduleElements);
+            }
+
+            ast = ast.parent;
+        }
+
+        return false;
+    }
+
+    function isParsingAmbientModule(ast, context) {
+        ast = ast.parent;
+        while (ast) {
+            if (ast.kind() === 130 /* ModuleDeclaration */) {
+                if (TypeScript.hasModifier(ast.modifiers, 8 /* Ambient */)) {
+                    return true;
+                }
+            }
+
+            ast = ast.parent;
+        }
+
+        return false;
+    }
+
+    function preCollectImportDecls(ast, context) {
+        var importDecl = ast;
+        var declFlags = 0 /* None */;
+
+        var parent = context.getParent();
+
+        if (TypeScript.hasModifier(importDecl.modifiers, 1 /* Exported */) && !containingModuleHasExportAssignment(ast)) {
+            declFlags |= 1 /* Exported */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(importDecl.identifier.valueText(), importDecl.identifier.text(), 128 /* TypeAlias */, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(ast, decl);
+        context.semanticInfoChain.setASTForDecl(decl, ast);
+    }
+
+    function preCollectScriptDecls(sourceUnit, context) {
+        var fileName = sourceUnit.fileName();
+
+        var isExternalModule = context.document.isExternalModule();
+
+        var decl = new TypeScript.RootPullDecl(fileName, fileName, 1 /* Script */, 0 /* None */, context.semanticInfoChain, isExternalModule);
+        context.semanticInfoChain.setDeclForAST(sourceUnit, decl);
+        context.semanticInfoChain.setASTForDecl(decl, sourceUnit);
+
+        context.isDeclareFile = context.document.isDeclareFile();
+
+        context.pushParent(decl);
+
+        if (isExternalModule) {
+            var declFlags = 1 /* Exported */;
+            if (TypeScript.isDTSFile(fileName)) {
+                declFlags |= 8 /* Ambient */;
+            }
+
+            var moduleContainsExecutableCode = containsExecutableCode(sourceUnit.moduleElements);
+            var kind = 32 /* DynamicModule */;
+            var valueText = TypeScript.quoteStr(fileName);
+
+            var decl = new TypeScript.NormalPullDecl(valueText, fileName, kind, declFlags, context.getParent());
+
+            context.semanticInfoChain.setASTForDecl(decl, sourceUnit);
+
+            context.semanticInfoChain.setDeclForAST(sourceUnit, decl);
+
+            if (!moduleElementsHasExportAssignment(sourceUnit.moduleElements) || moduleContainsExecutableCode) {
+                createModuleVariableDecl(decl, sourceUnit, context);
+            }
+
+            context.pushParent(decl);
+        }
+    }
+
+    function preCollectEnumDecls(enumDecl, context) {
+        var declFlags = 0 /* None */;
+        var enumName = enumDecl.identifier.valueText();
+
+        if ((TypeScript.hasModifier(enumDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(enumDecl, context)) && !containingModuleHasExportAssignment(enumDecl)) {
+            declFlags |= 1 /* Exported */;
+        }
+
+        if (TypeScript.hasModifier(enumDecl.modifiers, 8 /* Ambient */) || isParsingAmbientModule(enumDecl, context) || context.isDeclareFile) {
+            declFlags |= 8 /* Ambient */;
+        }
+
+        declFlags |= 4096 /* Enum */;
+        var kind = 64 /* Enum */;
+
+        var enumDeclaration = new TypeScript.NormalPullDecl(enumName, enumDecl.identifier.text(), kind, declFlags, context.getParent());
+        context.semanticInfoChain.setDeclForAST(enumDecl, enumDeclaration);
+        context.semanticInfoChain.setASTForDecl(enumDeclaration, enumDecl);
+
+        var valueDecl = new TypeScript.NormalPullDecl(enumDeclaration.name, enumDeclaration.getDisplayName(), 512 /* Variable */, enumDeclaration.flags, context.getParent());
+        enumDeclaration.setValueDecl(valueDecl);
+        context.semanticInfoChain.setASTForDecl(valueDecl, enumDecl);
+
+        context.pushParent(enumDeclaration);
+    }
+
+    function createEnumElementDecls(propertyDecl, context) {
+        var parent = context.getParent();
+
+        var decl = new TypeScript.PullEnumElementDecl(propertyDecl.propertyName.valueText(), propertyDecl.propertyName.text(), parent);
+        context.semanticInfoChain.setDeclForAST(propertyDecl, decl);
+        context.semanticInfoChain.setASTForDecl(decl, propertyDecl);
+    }
+
+    function preCollectModuleDecls(moduleDecl, context) {
+        var declFlags = 0 /* None */;
+
+        var moduleContainsExecutableCode = containsExecutableCode(moduleDecl.moduleElements);
+
+        var isDynamic = moduleDecl.stringLiteral !== null;
+
+        if ((TypeScript.hasModifier(moduleDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(moduleDecl, context)) && !containingModuleHasExportAssignment(moduleDecl)) {
+            declFlags |= 1 /* Exported */;
+        }
+
+        if (TypeScript.hasModifier(moduleDecl.modifiers, 8 /* Ambient */) || isParsingAmbientModule(moduleDecl, context) || context.isDeclareFile) {
+            declFlags |= 8 /* Ambient */;
+        }
+
+        var kind = isDynamic ? 32 /* DynamicModule */ : 4 /* Container */;
+
+        if (moduleDecl.stringLiteral) {
+            var valueText = TypeScript.quoteStr(moduleDecl.stringLiteral.valueText());
+            var text = moduleDecl.stringLiteral.text();
+
+            var decl = new TypeScript.NormalPullDecl(valueText, text, kind, declFlags, context.getParent());
+
+            context.semanticInfoChain.setDeclForAST(moduleDecl, decl);
+            context.semanticInfoChain.setDeclForAST(moduleDecl.stringLiteral, decl);
+            context.semanticInfoChain.setASTForDecl(decl, moduleDecl.stringLiteral);
+
+            if (!moduleElementsHasExportAssignment(moduleDecl.moduleElements) || moduleContainsExecutableCode) {
+                createModuleVariableDecl(decl, moduleDecl.stringLiteral, context);
+            }
+
+            context.pushParent(decl);
+        } else {
+            var moduleNames = TypeScript.ASTHelpers.getModuleNames(moduleDecl.name);
+            for (var i = 0, n = moduleNames.length; i < n; i++) {
+                var moduleName = moduleNames[i];
+
+                var specificFlags = declFlags;
+                if (i > 0) {
+                    specificFlags |= 1 /* Exported */;
+                }
+
+                var decl = new TypeScript.NormalPullDecl(moduleName.valueText(), moduleName.text(), kind, specificFlags, context.getParent());
+
+                context.semanticInfoChain.setDeclForAST(moduleDecl, decl);
+                context.semanticInfoChain.setDeclForAST(moduleName, decl);
+                context.semanticInfoChain.setASTForDecl(decl, moduleName);
+
+                if (moduleContainsExecutableCode) {
+                    createModuleVariableDecl(decl, moduleName, context);
+                }
+
+                context.pushParent(decl);
+            }
+        }
+    }
+
+    function createModuleVariableDecl(decl, moduleNameAST, context) {
+        decl.setFlags(decl.flags | getInitializationFlag(decl));
+
+        var valueDecl = new TypeScript.NormalPullDecl(decl.name, decl.getDisplayName(), 512 /* Variable */, decl.flags, context.getParent());
+        decl.setValueDecl(valueDecl);
+        context.semanticInfoChain.setASTForDecl(valueDecl, moduleNameAST);
+    }
+
+    function containsExecutableCode(members) {
+        for (var i = 0, n = members.childCount(); i < n; i++) {
+            var member = members.childAt(i);
+
+            if (member.kind() === 130 /* ModuleDeclaration */) {
+                var moduleDecl = member;
+
+                if (containsExecutableCode(moduleDecl.moduleElements)) {
+                    return true;
+                }
+            } else if (member.kind() === 133 /* ImportDeclaration */) {
+                if (TypeScript.hasModifier(member.modifiers, 1 /* Exported */)) {
+                    return true;
+                }
+            } else if (member.kind() !== 128 /* InterfaceDeclaration */ && member.kind() !== 134 /* ExportAssignment */) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    function preCollectClassDecls(classDecl, context) {
+        var declFlags = 0 /* None */;
+
+        if ((TypeScript.hasModifier(classDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(classDecl, context)) && !containingModuleHasExportAssignment(classDecl)) {
+            declFlags |= 1 /* Exported */;
+        }
+
+        if (TypeScript.hasModifier(classDecl.modifiers, 8 /* Ambient */) || isParsingAmbientModule(classDecl, context) || context.isDeclareFile) {
+            declFlags |= 8 /* Ambient */;
+        }
+
+        var parent = context.getParent();
+
+        var decl = new TypeScript.NormalPullDecl(classDecl.identifier.valueText(), classDecl.identifier.text(), 8 /* Class */, declFlags, parent);
+
+        var constructorDecl = new TypeScript.NormalPullDecl(classDecl.identifier.valueText(), classDecl.identifier.text(), 512 /* Variable */, declFlags | 16384 /* ClassConstructorVariable */, parent);
+
+        decl.setValueDecl(constructorDecl);
+
+        context.semanticInfoChain.setDeclForAST(classDecl, decl);
+        context.semanticInfoChain.setASTForDecl(decl, classDecl);
+        context.semanticInfoChain.setASTForDecl(constructorDecl, classDecl);
+
+        context.pushParent(decl);
+    }
+
+    function preCollectObjectTypeDecls(objectType, context) {
+        if (objectType.parent.kind() === 128 /* InterfaceDeclaration */) {
+            return;
+        }
+
+        var declFlags = 0 /* None */;
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl("", "", 8388608 /* ObjectType */, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(objectType, decl);
+        context.semanticInfoChain.setASTForDecl(decl, objectType);
+
+        context.pushParent(decl);
+    }
+
+    function preCollectInterfaceDecls(interfaceDecl, context) {
+        var declFlags = 0 /* None */;
+
+        if ((TypeScript.hasModifier(interfaceDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(interfaceDecl, context)) && !containingModuleHasExportAssignment(interfaceDecl)) {
+            declFlags |= 1 /* Exported */;
+        }
+
+        var parent = context.getParent();
+
+        var decl = new TypeScript.NormalPullDecl(interfaceDecl.identifier.valueText(), interfaceDecl.identifier.text(), 16 /* Interface */, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(interfaceDecl, decl);
+        context.semanticInfoChain.setASTForDecl(decl, interfaceDecl);
+
+        context.pushParent(decl);
+    }
+
+    function preCollectParameterDecl(argDecl, context) {
+        var declFlags = 0 /* None */;
+
+        if (TypeScript.hasModifier(argDecl.modifiers, 2 /* Private */)) {
+            declFlags |= 2 /* Private */;
+        } else {
+            declFlags |= 4 /* Public */;
+        }
+
+        if (argDecl.questionToken !== null || argDecl.equalsValueClause !== null || argDecl.dotDotDotToken !== null) {
+            declFlags |= 128 /* Optional */;
+        }
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(argDecl.identifier.valueText(), argDecl.identifier.text(), 2048 /* Parameter */, declFlags, parent);
+
+        if (argDecl.equalsValueClause) {
+            parent.flags |= 33554432 /* HasDefaultArgs */;
+        }
+
+        if (parent.kind === 32768 /* ConstructorMethod */) {
+            decl.setFlag(67108864 /* ConstructorParameter */);
+        }
+
+        var isPublicOrPrivate = TypeScript.hasModifier(argDecl.modifiers, 4 /* Public */ | 2 /* Private */);
+        var isInConstructor = parent.kind === 32768 /* ConstructorMethod */;
+        if (isPublicOrPrivate && isInConstructor) {
+            var parentsParent = context.parentChain[context.parentChain.length - 2];
+
+            var propDeclFlags = declFlags & ~128 /* Optional */;
+            var propDecl = new TypeScript.NormalPullDecl(argDecl.identifier.valueText(), argDecl.identifier.text(), 4096 /* Property */, propDeclFlags, parentsParent);
+            propDecl.setValueDecl(decl);
+            decl.setFlag(8388608 /* PropertyParameter */);
+            propDecl.setFlag(8388608 /* PropertyParameter */);
+
+            if (parent.kind === 32768 /* ConstructorMethod */) {
+                propDecl.setFlag(67108864 /* ConstructorParameter */);
+            }
+
+            context.semanticInfoChain.setASTForDecl(decl, argDecl);
+            context.semanticInfoChain.setASTForDecl(propDecl, argDecl);
+            context.semanticInfoChain.setDeclForAST(argDecl, propDecl);
+        } else {
+            context.semanticInfoChain.setASTForDecl(decl, argDecl);
+            context.semanticInfoChain.setDeclForAST(argDecl, decl);
+        }
+
+        parent.addVariableDeclToGroup(decl);
+    }
+
+    function preCollectTypeParameterDecl(typeParameterDecl, context) {
+        var declFlags = 0 /* None */;
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(typeParameterDecl.identifier.valueText(), typeParameterDecl.identifier.text(), 8192 /* TypeParameter */, declFlags, parent);
+        context.semanticInfoChain.setASTForDecl(decl, typeParameterDecl);
+        context.semanticInfoChain.setDeclForAST(typeParameterDecl, decl);
+    }
+
+    function createPropertySignature(propertyDecl, context) {
+        var declFlags = 4 /* Public */;
+        var parent = context.getParent();
+        var declType = 4096 /* Property */;
+
+        if (propertyDecl.questionToken !== null) {
+            declFlags |= 128 /* Optional */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(propertyDecl.propertyName.valueText(), propertyDecl.propertyName.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(propertyDecl, decl);
+        context.semanticInfoChain.setASTForDecl(decl, propertyDecl);
+    }
+
+    function createMemberVariableDeclaration(memberDecl, context) {
+        var declFlags = 0 /* None */;
+        var declType = 4096 /* Property */;
+
+        if (TypeScript.hasModifier(memberDecl.modifiers, 2 /* Private */)) {
+            declFlags |= 2 /* Private */;
+        } else {
+            declFlags |= 4 /* Public */;
+        }
+
+        if (TypeScript.hasModifier(memberDecl.modifiers, 16 /* Static */)) {
+            declFlags |= 16 /* Static */;
+        }
+
+        var parent = context.getParent();
+
+        var decl = new TypeScript.NormalPullDecl(memberDecl.variableDeclarator.propertyName.valueText(), memberDecl.variableDeclarator.propertyName.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(memberDecl, decl);
+        context.semanticInfoChain.setDeclForAST(memberDecl.variableDeclarator, decl);
+        context.semanticInfoChain.setASTForDecl(decl, memberDecl);
+    }
+
+    function createVariableDeclaration(varDecl, context) {
+        var declFlags = 0 /* None */;
+        var declType = 512 /* Variable */;
+
+        var modifiers = TypeScript.ASTHelpers.getVariableDeclaratorModifiers(varDecl);
+        if ((TypeScript.hasModifier(modifiers, 1 /* Exported */) || isParsingAmbientModule(varDecl, context)) && !containingModuleHasExportAssignment(varDecl)) {
+            declFlags |= 1 /* Exported */;
+        }
+
+        if (TypeScript.hasModifier(modifiers, 8 /* Ambient */) || isParsingAmbientModule(varDecl, context) || context.isDeclareFile) {
+            declFlags |= 8 /* Ambient */;
+        }
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(varDecl.propertyName.valueText(), varDecl.propertyName.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(varDecl, decl);
+        context.semanticInfoChain.setASTForDecl(decl, varDecl);
+
+        if (parent) {
+            parent.addVariableDeclToGroup(decl);
+        }
+    }
+
+    function preCollectVarDecls(ast, context) {
+        if (ast.parent.kind() === 136 /* MemberVariableDeclaration */) {
+            return;
+        }
+
+        var varDecl = ast;
+        createVariableDeclaration(varDecl, context);
+    }
+
+    function createFunctionTypeDeclaration(functionTypeDeclAST, context) {
+        var declFlags = 2048 /* Signature */;
+        var declType = 16777216 /* FunctionType */;
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(functionTypeDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, functionTypeDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function createConstructorTypeDeclaration(constructorTypeDeclAST, context) {
+        var declFlags = 0 /* None */;
+        var declType = 33554432 /* ConstructorType */;
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(constructorTypeDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, constructorTypeDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function createFunctionDeclaration(funcDeclAST, context) {
+        var declFlags = 0 /* None */;
+        var declType = 16384 /* Function */;
+
+        if ((TypeScript.hasModifier(funcDeclAST.modifiers, 1 /* Exported */) || isParsingAmbientModule(funcDeclAST, context)) && !containingModuleHasExportAssignment(funcDeclAST)) {
+            declFlags |= 1 /* Exported */;
+        }
+
+        if (TypeScript.hasModifier(funcDeclAST.modifiers, 8 /* Ambient */) || isParsingAmbientModule(funcDeclAST, context) || context.isDeclareFile) {
+            declFlags |= 8 /* Ambient */;
+        }
+
+        if (!funcDeclAST.block) {
+            declFlags |= 2048 /* Signature */;
+        }
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(funcDeclAST.identifier.valueText(), funcDeclAST.identifier.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(funcDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, funcDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function createAnyFunctionExpressionDeclaration(functionExpressionDeclAST, id, context, displayName) {
+        if (typeof displayName === "undefined") { displayName = null; }
+        var declFlags = 0 /* None */;
+
+        if (functionExpressionDeclAST.kind() === 219 /* SimpleArrowFunctionExpression */ || functionExpressionDeclAST.kind() === 218 /* ParenthesizedArrowFunctionExpression */) {
+            declFlags |= 8192 /* ArrowFunction */;
+        }
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var name = id ? id.text() : "";
+        var displayNameText = displayName ? displayName.text() : "";
+        var decl = new TypeScript.PullFunctionExpressionDecl(name, declFlags, parent, displayNameText);
+        context.semanticInfoChain.setDeclForAST(functionExpressionDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, functionExpressionDeclAST);
+
+        context.pushParent(decl);
+
+        if (functionExpressionDeclAST.kind() === 219 /* SimpleArrowFunctionExpression */) {
+            var simpleArrow = functionExpressionDeclAST;
+            var declFlags = 4 /* Public */;
+
+            var parent = context.getParent();
+
+            if (TypeScript.hasFlag(parent.flags, 2097152 /* DeclaredInAWithBlock */)) {
+                declFlags |= 2097152 /* DeclaredInAWithBlock */;
+            }
+
+            var decl = new TypeScript.NormalPullDecl(simpleArrow.identifier.valueText(), simpleArrow.identifier.text(), 2048 /* Parameter */, declFlags, parent);
+
+            context.semanticInfoChain.setASTForDecl(decl, simpleArrow.identifier);
+            context.semanticInfoChain.setDeclForAST(simpleArrow.identifier, decl);
+
+            parent.addVariableDeclToGroup(decl);
+        }
+    }
+
+    function createMemberFunctionDeclaration(funcDecl, context) {
+        var declFlags = 0 /* None */;
+        var declType = 65536 /* Method */;
+
+        if (TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */)) {
+            declFlags |= 16 /* Static */;
+        }
+
+        if (TypeScript.hasModifier(funcDecl.modifiers, 2 /* Private */)) {
+            declFlags |= 2 /* Private */;
+        } else {
+            declFlags |= 4 /* Public */;
+        }
+
+        if (!funcDecl.block) {
+            declFlags |= 2048 /* Signature */;
+        }
+
+        var parent = context.getParent();
+
+        var decl = new TypeScript.NormalPullDecl(funcDecl.propertyName.valueText(), funcDecl.propertyName.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(funcDecl, decl);
+        context.semanticInfoChain.setASTForDecl(decl, funcDecl);
+
+        context.pushParent(decl);
+    }
+
+    function createIndexSignatureDeclaration(indexSignatureDeclAST, context) {
+        var declFlags = 2048 /* Signature */;
+        var declType = 4194304 /* IndexSignature */;
+
+        var parent = context.getParent();
+
+        var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(indexSignatureDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, indexSignatureDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function createCallSignatureDeclaration(callSignature, context) {
+        var isChildOfObjectType = callSignature.parent && callSignature.parent.parent && callSignature.parent.kind() === 2 /* SeparatedList */ && callSignature.parent.parent.kind() === 122 /* ObjectType */;
+
+        if (!isChildOfObjectType) {
+            return;
+        }
+
+        var declFlags = 2048 /* Signature */;
+        var declType = 1048576 /* CallSignature */;
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(callSignature, decl);
+        context.semanticInfoChain.setASTForDecl(decl, callSignature);
+
+        context.pushParent(decl);
+    }
+
+    function createMethodSignatureDeclaration(method, context) {
+        var declFlags = 0 /* None */;
+        var declType = 65536 /* Method */;
+
+        declFlags |= 4 /* Public */;
+        declFlags |= 2048 /* Signature */;
+
+        if (method.questionToken !== null) {
+            declFlags |= 128 /* Optional */;
+        }
+
+        var parent = context.getParent();
+
+        var decl = new TypeScript.NormalPullDecl(method.propertyName.valueText(), method.propertyName.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(method, decl);
+        context.semanticInfoChain.setASTForDecl(decl, method);
+
+        context.pushParent(decl);
+    }
+
+    function createConstructSignatureDeclaration(constructSignatureDeclAST, context) {
+        var declFlags = 2048 /* Signature */;
+        var declType = 2097152 /* ConstructSignature */;
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(constructSignatureDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, constructSignatureDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function createClassConstructorDeclaration(constructorDeclAST, context) {
+        var declFlags = 0 /* None */;
+        var declType = 32768 /* ConstructorMethod */;
+
+        if (!constructorDeclAST.block) {
+            declFlags |= 2048 /* Signature */;
+        }
+
+        var parent = context.getParent();
+
+        if (parent) {
+            var parentFlags = parent.flags;
+
+            if (parentFlags & 1 /* Exported */) {
+                declFlags |= 1 /* Exported */;
+            }
+        }
+
+        var decl = new TypeScript.NormalPullDecl(parent.name, parent.getDisplayName(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(constructorDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, constructorDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function createGetAccessorDeclaration(getAccessorDeclAST, context) {
+        var declFlags = 4 /* Public */;
+        var declType = 262144 /* GetAccessor */;
+
+        if (TypeScript.hasModifier(getAccessorDeclAST.modifiers, 16 /* Static */)) {
+            declFlags |= 16 /* Static */;
+        }
+
+        if (TypeScript.hasModifier(getAccessorDeclAST.modifiers, 2 /* Private */)) {
+            declFlags |= 2 /* Private */;
+        } else {
+            declFlags |= 4 /* Public */;
+        }
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(getAccessorDeclAST.propertyName.valueText(), getAccessorDeclAST.propertyName.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(getAccessorDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, getAccessorDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function createFunctionExpressionDeclaration(expression, context) {
+        createAnyFunctionExpressionDeclaration(expression, expression.identifier, context);
+    }
+
+    function createSetAccessorDeclaration(setAccessorDeclAST, context) {
+        var declFlags = 4 /* Public */;
+        var declType = 524288 /* SetAccessor */;
+
+        if (TypeScript.hasModifier(setAccessorDeclAST.modifiers, 16 /* Static */)) {
+            declFlags |= 16 /* Static */;
+        }
+
+        if (TypeScript.hasModifier(setAccessorDeclAST.modifiers, 2 /* Private */)) {
+            declFlags |= 2 /* Private */;
+        } else {
+            declFlags |= 4 /* Public */;
+        }
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(setAccessorDeclAST.propertyName.valueText(), setAccessorDeclAST.propertyName.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(setAccessorDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, setAccessorDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function preCollectCatchDecls(ast, context) {
+        var declFlags = 0 /* None */;
+        var declType = 268435456 /* CatchBlock */;
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(ast, decl);
+        context.semanticInfoChain.setASTForDecl(decl, ast);
+
+        context.pushParent(decl);
+
+        var declFlags = 0 /* None */;
+        var declType = 1024 /* CatchVariable */;
+
+        var parent = context.getParent();
+
+        if (TypeScript.hasFlag(parent.flags, 2097152 /* DeclaredInAWithBlock */)) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(ast.identifier.valueText(), ast.identifier.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(ast.identifier, decl);
+        context.semanticInfoChain.setASTForDecl(decl, ast.identifier);
+
+        if (parent) {
+            parent.addVariableDeclToGroup(decl);
+        }
+    }
+
+    function preCollectWithDecls(ast, context) {
+        var declFlags = 0 /* None */;
+        var declType = 134217728 /* WithBlock */;
+
+        var parent = context.getParent();
+
+        var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(ast, decl);
+        context.semanticInfoChain.setASTForDecl(decl, ast);
+
+        context.pushParent(decl);
+    }
+
+    function preCollectObjectLiteralDecls(ast, context) {
+        var decl = new TypeScript.NormalPullDecl("", "", 256 /* ObjectLiteral */, 0 /* None */, context.getParent());
+
+        context.semanticInfoChain.setDeclForAST(ast, decl);
+        context.semanticInfoChain.setASTForDecl(decl, ast);
+
+        context.pushParent(decl);
+    }
+
+    function preCollectSimplePropertyAssignmentDecls(propertyAssignment, context) {
+        var assignmentText = TypeScript.getPropertyAssignmentNameTextFromIdentifier(propertyAssignment.propertyName);
+        var span = TypeScript.TextSpan.fromBounds(propertyAssignment.start(), propertyAssignment.end());
+
+        var decl = new TypeScript.NormalPullDecl(assignmentText.memberName, assignmentText.actualText, 4096 /* Property */, 4 /* Public */, context.getParent());
+
+        context.semanticInfoChain.setDeclForAST(propertyAssignment, decl);
+        context.semanticInfoChain.setASTForDecl(decl, propertyAssignment);
+    }
+
+    function preCollectFunctionPropertyAssignmentDecls(propertyAssignment, context) {
+        var assignmentText = TypeScript.getPropertyAssignmentNameTextFromIdentifier(propertyAssignment.propertyName);
+
+        var decl = new TypeScript.NormalPullDecl(assignmentText.memberName, assignmentText.actualText, 4096 /* Property */, 4 /* Public */, context.getParent());
+
+        context.semanticInfoChain.setDeclForAST(propertyAssignment, decl);
+        context.semanticInfoChain.setASTForDecl(decl, propertyAssignment);
+
+        createAnyFunctionExpressionDeclaration(propertyAssignment, propertyAssignment.propertyName, context, propertyAssignment.propertyName);
+    }
+
+    function preCollectDecls(ast, context) {
+        switch (ast.kind()) {
+            case 120 /* SourceUnit */:
+                preCollectScriptDecls(ast, context);
+                break;
+            case 132 /* EnumDeclaration */:
+                preCollectEnumDecls(ast, context);
+                break;
+            case 243 /* EnumElement */:
+                createEnumElementDecls(ast, context);
+                break;
+            case 130 /* ModuleDeclaration */:
+                preCollectModuleDecls(ast, context);
+                break;
+            case 131 /* ClassDeclaration */:
+                preCollectClassDecls(ast, context);
+                break;
+            case 128 /* InterfaceDeclaration */:
+                preCollectInterfaceDecls(ast, context);
+                break;
+            case 122 /* ObjectType */:
+                preCollectObjectTypeDecls(ast, context);
+                break;
+            case 242 /* Parameter */:
+                preCollectParameterDecl(ast, context);
+                break;
+            case 136 /* MemberVariableDeclaration */:
+                createMemberVariableDeclaration(ast, context);
+                break;
+            case 141 /* PropertySignature */:
+                createPropertySignature(ast, context);
+                break;
+            case 225 /* VariableDeclarator */:
+                preCollectVarDecls(ast, context);
+                break;
+            case 137 /* ConstructorDeclaration */:
+                createClassConstructorDeclaration(ast, context);
+                break;
+            case 139 /* GetAccessor */:
+                createGetAccessorDeclaration(ast, context);
+                break;
+            case 140 /* SetAccessor */:
+                createSetAccessorDeclaration(ast, context);
+                break;
+            case 222 /* FunctionExpression */:
+                createFunctionExpressionDeclaration(ast, context);
+                break;
+            case 135 /* MemberFunctionDeclaration */:
+                createMemberFunctionDeclaration(ast, context);
+                break;
+            case 144 /* IndexSignature */:
+                createIndexSignatureDeclaration(ast, context);
+                break;
+            case 123 /* FunctionType */:
+                createFunctionTypeDeclaration(ast, context);
+                break;
+            case 125 /* ConstructorType */:
+                createConstructorTypeDeclaration(ast, context);
+                break;
+            case 142 /* CallSignature */:
+                createCallSignatureDeclaration(ast, context);
+                break;
+            case 143 /* ConstructSignature */:
+                createConstructSignatureDeclaration(ast, context);
+                break;
+            case 145 /* MethodSignature */:
+                createMethodSignatureDeclaration(ast, context);
+                break;
+            case 129 /* FunctionDeclaration */:
+                createFunctionDeclaration(ast, context);
+                break;
+            case 219 /* SimpleArrowFunctionExpression */:
+            case 218 /* ParenthesizedArrowFunctionExpression */:
+                createAnyFunctionExpressionDeclaration(ast, null, context);
+                break;
+            case 133 /* ImportDeclaration */:
+                preCollectImportDecls(ast, context);
+                break;
+            case 238 /* TypeParameter */:
+                preCollectTypeParameterDecl(ast, context);
+                break;
+            case 236 /* CatchClause */:
+                preCollectCatchDecls(ast, context);
+                break;
+            case 163 /* WithStatement */:
+                preCollectWithDecls(ast, context);
+                break;
+            case 215 /* ObjectLiteralExpression */:
+                preCollectObjectLiteralDecls(ast, context);
+                break;
+            case 240 /* SimplePropertyAssignment */:
+                preCollectSimplePropertyAssignmentDecls(ast, context);
+                break;
+            case 241 /* FunctionPropertyAssignment */:
+                preCollectFunctionPropertyAssignmentDecls(ast, context);
+                break;
+        }
+    }
+
+    function isContainer(decl) {
+        return decl.kind === 4 /* Container */ || decl.kind === 32 /* DynamicModule */ || decl.kind === 64 /* Enum */;
+    }
+
+    function getInitializationFlag(decl) {
+        if (decl.kind & 4 /* Container */) {
+            return 32768 /* InitializedModule */;
+        } else if (decl.kind & 32 /* DynamicModule */) {
+            return 65536 /* InitializedDynamicModule */;
+        }
+
+        return 0 /* None */;
+    }
+
+    function hasInitializationFlag(decl) {
+        var kind = decl.kind;
+
+        if (kind & 4 /* Container */) {
+            return (decl.flags & 32768 /* InitializedModule */) !== 0;
+        } else if (kind & 32 /* DynamicModule */) {
+            return (decl.flags & 65536 /* InitializedDynamicModule */) !== 0;
+        }
+
+        return false;
+    }
+
+    function postCollectDecls(ast, context) {
+        var currentDecl = context.getParent();
+
+        if (ast.kind() === 11 /* IdentifierName */ || ast.kind() === 14 /* StringLiteral */) {
+            if (currentDecl.kind === 4 /* Container */ || currentDecl.kind === 32 /* DynamicModule */) {
+                return;
+            }
+        }
+
+        if (ast.kind() === 130 /* ModuleDeclaration */) {
+            var moduleDeclaration = ast;
+            if (moduleDeclaration.stringLiteral) {
+                TypeScript.Debug.assert(currentDecl.ast() === moduleDeclaration.stringLiteral);
+                context.popParent();
+            } else {
+                var moduleNames = TypeScript.ASTHelpers.getModuleNames(moduleDeclaration.name);
+                for (var i = moduleNames.length - 1; i >= 0; i--) {
+                    var moduleName = moduleNames[i];
+                    TypeScript.Debug.assert(currentDecl.ast() === moduleName);
+                    context.popParent();
+                    currentDecl = context.getParent();
+                }
+            }
+        }
+
+        if (ast.kind() === 132 /* EnumDeclaration */) {
+            computeEnumElementConstantValues(ast, currentDecl, context);
+        }
+
+        while (currentDecl.getParentDecl() && currentDecl.ast() === ast) {
+            context.popParent();
+            currentDecl = context.getParent();
+        }
+    }
+
+    function computeEnumElementConstantValues(ast, enumDecl, context) {
+        TypeScript.Debug.assert(enumDecl.kind === 64 /* Enum */);
+
+        var isAmbientEnum = TypeScript.hasFlag(enumDecl.flags, 8 /* Ambient */);
+        var inConstantSection = !isAmbientEnum;
+        var currentConstantValue = 0;
+        var enumMemberDecls = enumDecl.getChildDecls();
+
+        for (var i = 0, n = ast.enumElements.nonSeparatorCount(); i < n; i++) {
+            var enumElement = ast.enumElements.nonSeparatorAt(i);
+            var enumElementDecl = TypeScript.ArrayUtilities.first(enumMemberDecls, function (d) {
+                return context.semanticInfoChain.getASTForDecl(d) === enumElement;
+            });
+
+            TypeScript.Debug.assert(enumElementDecl.kind === 67108864 /* EnumMember */);
+
+            if (enumElement.equalsValueClause === null) {
+                if (inConstantSection) {
+                    enumElementDecl.constantValue = currentConstantValue;
+                    currentConstantValue++;
+                }
+            } else {
+                enumElementDecl.constantValue = computeEnumElementConstantValue(enumElement.equalsValueClause.value, enumMemberDecls, context);
+                if (enumElementDecl.constantValue !== null && !isAmbientEnum) {
+                    inConstantSection = true;
+                    currentConstantValue = enumElementDecl.constantValue + 1;
+                } else {
+                    inConstantSection = false;
+                }
+            }
+
+            TypeScript.Debug.assert(enumElementDecl.constantValue !== undefined);
+        }
+    }
+
+    function computeEnumElementConstantValue(expression, enumMemberDecls, context) {
+        TypeScript.Debug.assert(expression);
+
+        if (TypeScript.ASTHelpers.isIntegerLiteralAST(expression)) {
+            var token;
+            switch (expression.kind()) {
+                case 164 /* PlusExpression */:
+                case 165 /* NegateExpression */:
+                    token = expression.operand;
+                    break;
+                default:
+                    token = expression;
+            }
+
+            var value = token.value();
+            return value && expression.kind() === 165 /* NegateExpression */ ? -value : value;
+        } else if (context.propagateEnumConstants) {
+            switch (expression.kind()) {
+                case 11 /* IdentifierName */:
+                    var name = expression;
+                    var matchingEnumElement = TypeScript.ArrayUtilities.firstOrDefault(enumMemberDecls, function (d) {
+                        return d.name === name.valueText();
+                    });
+
+                    return matchingEnumElement ? matchingEnumElement.constantValue : null;
+
+                case 202 /* LeftShiftExpression */:
+                    var binaryExpression = expression;
+                    var left = computeEnumElementConstantValue(binaryExpression.left, enumMemberDecls, context);
+                    var right = computeEnumElementConstantValue(binaryExpression.right, enumMemberDecls, context);
+                    if (left === null || right === null) {
+                        return null;
+                    }
+
+                    return left << right;
+
+                case 189 /* BitwiseOrExpression */:
+                    var binaryExpression = expression;
+                    var left = computeEnumElementConstantValue(binaryExpression.left, enumMemberDecls, context);
+                    var right = computeEnumElementConstantValue(binaryExpression.right, enumMemberDecls, context);
+                    if (left === null || right === null) {
+                        return null;
+                    }
+
+                    return left | right;
+            }
+
+            return null;
+        } else {
+            return null;
+        }
+    }
+
+    (function (DeclarationCreator) {
+        function create(document, semanticInfoChain, compilationSettings) {
+            var declCollectionContext = new DeclCollectionContext(document, semanticInfoChain, compilationSettings.propagateEnumConstants());
+
+            TypeScript.getAstWalkerFactory().simpleWalk(document.sourceUnit(), preCollectDecls, postCollectDecls, declCollectionContext);
+
+            return declCollectionContext.getParent();
+        }
+        DeclarationCreator.create = create;
+    })(TypeScript.DeclarationCreator || (TypeScript.DeclarationCreator = {}));
+    var DeclarationCreator = TypeScript.DeclarationCreator;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var PullSymbolBinder = (function () {
+        function PullSymbolBinder(semanticInfoChain) {
+            this.semanticInfoChain = semanticInfoChain;
+            this.declsBeingBound = [];
+            this.inBindingOtherDeclsWalker = new TypeScript.PullHelpers.OtherPullDeclsWalker();
+        }
+        PullSymbolBinder.prototype.getParent = function (decl, returnInstanceType) {
+            if (typeof returnInstanceType === "undefined") { returnInstanceType = false; }
+            var parentDecl = decl.getParentDecl();
+
+            if (parentDecl.kind === 1 /* Script */) {
+                return null;
+            }
+
+            var parent = parentDecl.getSymbol();
+
+            if (!parent && parentDecl && !parentDecl.hasBeenBound()) {
+                this.bindDeclToPullSymbol(parentDecl);
+            }
+
+            parent = parentDecl.getSymbol();
+            if (parent) {
+                var parentDeclKind = parentDecl.kind;
+                if (parentDeclKind === 262144 /* GetAccessor */) {
+                    parent = parent.getGetter();
+                } else if (parentDeclKind === 524288 /* SetAccessor */) {
+                    parent = parent.getSetter();
+                }
+            }
+
+            if (parent) {
+                if (returnInstanceType && parent.isType() && parent.isContainer()) {
+                    var instanceSymbol = parent.getInstanceSymbol();
+
+                    if (instanceSymbol) {
+                        return instanceSymbol.type;
+                    }
+                }
+
+                return parent.type;
+            }
+
+            return null;
+        };
+
+        PullSymbolBinder.prototype.findDeclsInContext = function (startingDecl, declKind, searchGlobally) {
+            if (!searchGlobally) {
+                var parentDecl = startingDecl.getParentDecl();
+                return parentDecl.searchChildDecls(startingDecl.name, declKind);
+            }
+
+            var contextSymbolPath = startingDecl.getParentPath();
+
+            if (contextSymbolPath.length) {
+                var copyOfContextSymbolPath = [];
+
+                for (var i = 0; i < contextSymbolPath.length; i++) {
+                    if (contextSymbolPath[i].kind & 1 /* Script */) {
+                        continue;
+                    }
+                    copyOfContextSymbolPath[copyOfContextSymbolPath.length] = contextSymbolPath[i].name;
+                }
+
+                return this.semanticInfoChain.findDecls(copyOfContextSymbolPath, declKind);
+            }
+        };
+
+        PullSymbolBinder.prototype.getExistingSymbol = function (decl, searchKind, parent) {
+            var lookingForValue = (searchKind & 68147712 /* SomeValue */) !== 0;
+            var lookingForType = (searchKind & 58728795 /* SomeType */) !== 0;
+            var lookingForContainer = (searchKind & 164 /* SomeContainer */) !== 0;
+            var name = decl.name;
+            if (parent) {
+                var isExported = (decl.flags & 1 /* Exported */) !== 0;
+
+                var prevSymbol = null;
+                if (lookingForValue) {
+                    prevSymbol = parent.findContainedNonMember(name);
+                } else if (lookingForType) {
+                    prevSymbol = parent.findContainedNonMemberType(name, searchKind);
+                } else if (lookingForContainer) {
+                    prevSymbol = parent.findContainedNonMemberContainer(name, searchKind);
+                }
+                var prevIsExported = !prevSymbol;
+                if (!prevSymbol) {
+                    if (lookingForValue) {
+                        prevSymbol = parent.findMember(name, false);
+                    } else if (lookingForType) {
+                        prevSymbol = parent.findNestedType(name, searchKind);
+                    } else if (lookingForContainer) {
+                        prevSymbol = parent.findNestedContainer(name, searchKind);
+                    }
+                }
+
+                if (isExported && prevIsExported) {
+                    return prevSymbol;
+                }
+                if (prevSymbol) {
+                    var prevDecls = prevSymbol.getDeclarations();
+                    var lastPrevDecl = prevDecls[prevDecls.length - 1];
+                    var parentDecl = decl.getParentDecl();
+                    var prevParentDecl = lastPrevDecl && lastPrevDecl.getParentDecl();
+                    if (parentDecl !== prevParentDecl) {
+                        return null;
+                    }
+
+                    return prevSymbol;
+                }
+            } else {
+                var parentDecl = decl.getParentDecl();
+                if (parentDecl && parentDecl.kind === 1 /* Script */) {
+                    return this.semanticInfoChain.findTopLevelSymbol(name, searchKind, decl);
+                } else {
+                    var prevDecls = parentDecl && parentDecl.searchChildDecls(name, searchKind);
+                    return prevDecls[0] && prevDecls[0].getSymbol();
+                }
+            }
+
+            return null;
+        };
+
+        PullSymbolBinder.prototype.checkThatExportsMatch = function (decl, prevSymbol, reportError) {
+            if (typeof reportError === "undefined") { reportError = true; }
+            var isExported = (decl.flags & 1 /* Exported */) !== 0;
+            var prevDecls = prevSymbol.getDeclarations();
+            var prevIsExported = (prevDecls[prevDecls.length - 1].flags & 1 /* Exported */) !== 0;
+            if ((isExported !== prevIsExported) && !prevSymbol.isSignature() && (decl.kind & 7340032 /* SomeSignature */) === 0) {
+                if (reportError) {
+                    var ast = this.semanticInfoChain.getASTForDecl(decl);
+                    this.semanticInfoChain.addDiagnosticFromAST(ast, TypeScript.DiagnosticCode.All_declarations_of_merged_declaration_0_must_be_exported_or_not_exported, [decl.getDisplayName()]);
+                }
+                return false;
+            }
+
+            return true;
+        };
+
+        PullSymbolBinder.prototype.getIndexForInsertingSignatureAtEndOfEnclosingDeclInSignatureList = function (signature, currentSignatures) {
+            var signatureDecl = signature.getDeclarations()[0];
+            TypeScript.Debug.assert(signatureDecl);
+            var enclosingDecl = signatureDecl.getParentDecl();
+            var indexToInsert = TypeScript.ArrayUtilities.indexOf(currentSignatures, function (someSignature) {
+                return someSignature.getDeclarations()[0].getParentDecl() !== enclosingDecl;
+            });
+            return indexToInsert < 0 ? currentSignatures.length : indexToInsert;
+        };
+
+        PullSymbolBinder.prototype.bindEnumDeclarationToPullSymbol = function (enumContainerDecl) {
+            var enumName = enumContainerDecl.name;
+
+            var enumContainerSymbol = null;
+            var enumInstanceSymbol = null;
+            var moduleInstanceTypeSymbol = null;
+
+            var enumInstanceDecl = enumContainerDecl.getValueDecl();
+
+            var enumDeclKind = enumContainerDecl.kind;
+
+            var parent = this.getParent(enumContainerDecl);
+            var parentInstanceSymbol = this.getParent(enumContainerDecl, true);
+            var parentDecl = enumContainerDecl.getParentDecl();
+            var enumAST = this.semanticInfoChain.getASTForDecl(enumContainerDecl);
+
+            var isExported = enumContainerDecl.flags & 1 /* Exported */;
+
+            var createdNewSymbol = false;
+
+            enumContainerSymbol = this.getExistingSymbol(enumContainerDecl, 64 /* Enum */, parent);
+
+            if (enumContainerSymbol) {
+                if (enumContainerSymbol.kind !== enumDeclKind) {
+                    this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(enumAST.identifier, enumContainerDecl.getDisplayName(), enumContainerSymbol.getDeclarations()[0].ast());
+                    enumContainerSymbol = null;
+                } else if (!this.checkThatExportsMatch(enumContainerDecl, enumContainerSymbol)) {
+                    enumContainerSymbol = null;
+                }
+            }
+
+            if (enumContainerSymbol) {
+                enumInstanceSymbol = enumContainerSymbol.getInstanceSymbol();
+            } else {
+                enumContainerSymbol = new TypeScript.PullContainerSymbol(enumName, enumDeclKind);
+                createdNewSymbol = true;
+
+                if (!parent) {
+                    this.semanticInfoChain.cacheGlobalSymbol(enumContainerSymbol, 64 /* Enum */);
+                }
+            }
+
+            enumContainerSymbol.addDeclaration(enumContainerDecl);
+            enumContainerDecl.setSymbol(enumContainerSymbol);
+
+            this.semanticInfoChain.setSymbolForAST(enumAST.identifier, enumContainerSymbol);
+            this.semanticInfoChain.setSymbolForAST(enumAST, enumContainerSymbol);
+
+            if (!enumInstanceSymbol) {
+                var variableSymbol = null;
+                if (parentInstanceSymbol) {
+                    if (isExported) {
+                        variableSymbol = parentInstanceSymbol.findMember(enumName, false);
+
+                        if (!variableSymbol) {
+                            variableSymbol = parentInstanceSymbol.findContainedNonMember(enumName);
+                        }
+                    } else {
+                        variableSymbol = parentInstanceSymbol.findContainedNonMember(enumName);
+
+                        if (!variableSymbol) {
+                            variableSymbol = parentInstanceSymbol.findMember(enumName, false);
+                        }
+                    }
+
+                    if (variableSymbol) {
+                        var declarations = variableSymbol.getDeclarations();
+
+                        if (declarations.length) {
+                            var variableSymbolParentDecl = declarations[0].getParentDecl();
+
+                            if (parentDecl !== variableSymbolParentDecl) {
+                                variableSymbol = null;
+                            }
+                        }
+                    }
+                } else if (!(enumContainerDecl.flags & 1 /* Exported */)) {
+                    var siblingDecls = parentDecl.getChildDecls();
+                    var augmentedDecl = null;
+
+                    for (var i = 0; i < siblingDecls.length; i++) {
+                        if (siblingDecls[i] === enumContainerDecl) {
+                            break;
+                        }
+
+                        if ((siblingDecls[i].name === enumName) && (siblingDecls[i].kind & 68147712 /* SomeValue */)) {
+                            augmentedDecl = siblingDecls[i];
+                            break;
+                        }
+                    }
+
+                    if (augmentedDecl) {
+                        variableSymbol = augmentedDecl.getSymbol();
+
+                        if (variableSymbol) {
+                            if (variableSymbol.isContainer()) {
+                                variableSymbol = variableSymbol.getInstanceSymbol();
+                            } else if (variableSymbol && variableSymbol.isType()) {
+                                variableSymbol = variableSymbol.getConstructorMethod();
+                            }
+                        }
+                    }
+                }
+
+                if (variableSymbol) {
+                    enumInstanceSymbol = variableSymbol;
+                    moduleInstanceTypeSymbol = variableSymbol.type;
+                } else {
+                    enumInstanceSymbol = new TypeScript.PullSymbol(enumName, 512 /* Variable */);
+                }
+
+                enumContainerSymbol.setInstanceSymbol(enumInstanceSymbol);
+
+                if (!moduleInstanceTypeSymbol) {
+                    moduleInstanceTypeSymbol = new TypeScript.PullTypeSymbol("", 8388608 /* ObjectType */);
+                    enumInstanceSymbol.type = moduleInstanceTypeSymbol;
+                }
+
+                moduleInstanceTypeSymbol.addDeclaration(enumContainerDecl);
+
+                if (!moduleInstanceTypeSymbol.getAssociatedContainerType()) {
+                    moduleInstanceTypeSymbol.setAssociatedContainerType(enumContainerSymbol);
+                }
+            }
+
+            if (createdNewSymbol && parent) {
+                if (enumContainerDecl.flags & 1 /* Exported */) {
+                    parent.addEnclosedMemberType(enumContainerSymbol);
+                } else {
+                    parent.addEnclosedNonMemberType(enumContainerSymbol);
+                }
+            }
+
+            if (createdNewSymbol) {
+                this.bindEnumIndexerDeclsToPullSymbols(enumContainerSymbol);
+            }
+            var valueDecl = enumContainerDecl.getValueDecl();
+
+            if (valueDecl) {
+                valueDecl.ensureSymbolIsBound();
+            }
+        };
+
+        PullSymbolBinder.prototype.bindEnumIndexerDeclsToPullSymbols = function (enumContainerSymbol) {
+            var enumContainerInstanceTypeSymbol = enumContainerSymbol.getInstanceSymbol().type;
+
+            var syntheticIndexerParameterSymbol = new TypeScript.PullSymbol("x", 2048 /* Parameter */);
+            syntheticIndexerParameterSymbol.type = this.semanticInfoChain.numberTypeSymbol;
+            syntheticIndexerParameterSymbol.setResolved();
+            syntheticIndexerParameterSymbol.setIsSynthesized();
+
+            var syntheticIndexerSignatureSymbol = new TypeScript.PullSignatureSymbol(4194304 /* IndexSignature */);
+            syntheticIndexerSignatureSymbol.addParameter(syntheticIndexerParameterSymbol);
+            syntheticIndexerSignatureSymbol.returnType = this.semanticInfoChain.stringTypeSymbol;
+            syntheticIndexerSignatureSymbol.setResolved();
+            syntheticIndexerSignatureSymbol.setIsSynthesized();
+
+            enumContainerInstanceTypeSymbol.addIndexSignature(syntheticIndexerSignatureSymbol);
+        };
+
+        PullSymbolBinder.prototype.findExistingVariableSymbolForModuleValueDecl = function (decl) {
+            var isExported = TypeScript.hasFlag(decl.flags, 1 /* Exported */);
+            var modName = decl.name;
+            var parentInstanceSymbol = this.getParent(decl, true);
+            var parentDecl = decl.getParentDecl();
+
+            var variableSymbol = null;
+
+            if (parentInstanceSymbol) {
+                if (isExported) {
+                    variableSymbol = parentInstanceSymbol.findMember(modName, false);
+
+                    if (!variableSymbol) {
+                        variableSymbol = parentInstanceSymbol.findContainedNonMember(modName);
+                    }
+                } else {
+                    variableSymbol = parentInstanceSymbol.findContainedNonMember(modName);
+
+                    if (!variableSymbol) {
+                        variableSymbol = parentInstanceSymbol.findMember(modName, false);
+                    }
+                }
+
+                if (variableSymbol) {
+                    var declarations = variableSymbol.getDeclarations();
+
+                    if (declarations.length) {
+                        var variableSymbolParentDecl = declarations[0].getParentDecl();
+                        var isExportedOrHasTheSameParent = isExported || (parentDecl === variableSymbolParentDecl);
+
+                        var canReuseVariableSymbol = isExportedOrHasTheSameParent && this.checkThatExportsMatch(decl, variableSymbol, false);
+
+                        if (!canReuseVariableSymbol) {
+                            variableSymbol = null;
+                        }
+                    }
+                }
+            } else if (!isExported) {
+                var siblingDecls = parentDecl.getChildDecls();
+
+                for (var i = 0; i < siblingDecls.length; i++) {
+                    var sibling = siblingDecls[i];
+
+                    var siblingIsSomeValue = TypeScript.hasFlag(sibling.kind, 68147712 /* SomeValue */);
+                    var siblingIsFunctionOrHasImplictVarFlag = TypeScript.hasFlag(sibling.kind, 1032192 /* SomeFunction */) || TypeScript.hasFlag(sibling.flags, 118784 /* ImplicitVariable */);
+
+                    var isSiblingAnAugmentableVariable = sibling !== decl && sibling !== decl.getValueDecl() && sibling.name === modName && siblingIsSomeValue && siblingIsFunctionOrHasImplictVarFlag;
+
+                    if (isSiblingAnAugmentableVariable) {
+                        if (sibling.hasSymbol()) {
+                            variableSymbol = sibling.getSymbol();
+                            if (variableSymbol.isContainer()) {
+                                variableSymbol = variableSymbol.getInstanceSymbol();
+                            } else if (variableSymbol && variableSymbol.isType()) {
+                                variableSymbol = variableSymbol.getConstructorMethod();
+                            }
+
+                            break;
+                        }
+                    }
+                }
+            }
+            return variableSymbol;
+        };
+
+        PullSymbolBinder.prototype.bindModuleDeclarationToPullSymbol = function (moduleContainerDecl) {
+            var modName = moduleContainerDecl.name;
+
+            var moduleContainerTypeSymbol = null;
+            var moduleKind = moduleContainerDecl.kind;
+
+            var parent = this.getParent(moduleContainerDecl);
+            var parentInstanceSymbol = this.getParent(moduleContainerDecl, true);
+            var parentDecl = moduleContainerDecl.getParentDecl();
+            var moduleNameAST = this.semanticInfoChain.getASTForDecl(moduleContainerDecl);
+            var moduleDeclAST = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(moduleNameAST);
+            if (!moduleDeclAST) {
+                TypeScript.Debug.assert(moduleKind === 32 /* DynamicModule */);
+                TypeScript.Debug.assert(moduleNameAST.kind() === 120 /* SourceUnit */);
+
+                moduleDeclAST = moduleNameAST;
+            }
+
+            var isExported = TypeScript.hasFlag(moduleContainerDecl.flags, 1 /* Exported */);
+            var searchKind = 164 /* SomeContainer */;
+            var isInitializedModule = (moduleContainerDecl.flags & 102400 /* SomeInitializedModule */) !== 0;
+
+            if (parent && moduleKind === 32 /* DynamicModule */) {
+                this.semanticInfoChain.addDiagnosticFromAST(moduleNameAST, TypeScript.DiagnosticCode.Ambient_external_module_declaration_must_be_defined_in_global_context, null);
+            }
+
+            var createdNewSymbol = false;
+
+            moduleContainerTypeSymbol = this.getExistingSymbol(moduleContainerDecl, searchKind, parent);
+
+            if (moduleContainerTypeSymbol) {
+                if (moduleContainerTypeSymbol.kind !== moduleKind) {
+                    if (isInitializedModule) {
+                        this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(moduleNameAST, moduleContainerDecl.getDisplayName(), moduleContainerTypeSymbol.getDeclarations()[0].ast());
+                    }
+
+                    moduleContainerTypeSymbol = null;
+                } else if (moduleKind === 32 /* DynamicModule */) {
+                    this.semanticInfoChain.addDiagnosticFromAST(moduleNameAST, TypeScript.DiagnosticCode.Ambient_external_module_declaration_cannot_be_reopened);
+                } else if (!this.checkThatExportsMatch(moduleContainerDecl, moduleContainerTypeSymbol)) {
+                    moduleContainerTypeSymbol = null;
+                }
+            }
+
+            if (!moduleContainerTypeSymbol) {
+                moduleContainerTypeSymbol = new TypeScript.PullContainerSymbol(modName, moduleKind);
+                createdNewSymbol = true;
+
+                if (!parent) {
+                    this.semanticInfoChain.cacheGlobalSymbol(moduleContainerTypeSymbol, searchKind);
+                }
+            }
+
+            moduleContainerTypeSymbol.addDeclaration(moduleContainerDecl);
+            moduleContainerDecl.setSymbol(moduleContainerTypeSymbol);
+
+            this.semanticInfoChain.setSymbolForAST(moduleNameAST, moduleContainerTypeSymbol);
+            this.semanticInfoChain.setSymbolForAST(moduleDeclAST, moduleContainerTypeSymbol);
+
+            var currentModuleValueDecl = moduleContainerDecl.getValueDecl();
+
+            var moduleDeclarations = moduleContainerTypeSymbol.getDeclarations();
+
+            if (createdNewSymbol) {
+                if (parent) {
+                    if (moduleContainerDecl.flags & 1 /* Exported */) {
+                        parent.addEnclosedMemberContainer(moduleContainerTypeSymbol);
+                    } else {
+                        parent.addEnclosedNonMemberContainer(moduleContainerTypeSymbol);
+                    }
+                }
+            }
+
+            if (currentModuleValueDecl) {
+                currentModuleValueDecl.ensureSymbolIsBound();
+
+                var instanceSymbol = null;
+                var instanceTypeSymbol = null;
+                if (currentModuleValueDecl.hasSymbol()) {
+                    instanceSymbol = currentModuleValueDecl.getSymbol();
+                } else {
+                    instanceSymbol = new TypeScript.PullSymbol(modName, 512 /* Variable */);
+                    currentModuleValueDecl.setSymbol(instanceSymbol);
+                    if (!instanceSymbol.hasDeclaration(currentModuleValueDecl)) {
+                        instanceSymbol.addDeclaration(currentModuleValueDecl);
+                    }
+                }
+
+                if (!instanceSymbol.type) {
+                    instanceSymbol.type = new TypeScript.PullTypeSymbol("", 8388608 /* ObjectType */);
+                }
+
+                moduleContainerTypeSymbol.setInstanceSymbol(instanceSymbol);
+
+                if (!instanceSymbol.type.getAssociatedContainerType()) {
+                    instanceSymbol.type.setAssociatedContainerType(moduleContainerTypeSymbol);
+                }
+            }
+        };
+
+        PullSymbolBinder.prototype.bindImportDeclaration = function (importDeclaration) {
+            var declFlags = importDeclaration.flags;
+            var declKind = importDeclaration.kind;
+            var importDeclAST = this.semanticInfoChain.getASTForDecl(importDeclaration);
+
+            var isExported = false;
+            var importSymbol = null;
+            var declName = importDeclaration.name;
+            var parentHadSymbol = false;
+            var parent = this.getParent(importDeclaration);
+
+            importSymbol = this.getExistingSymbol(importDeclaration, 164 /* SomeContainer */, parent);
+
+            if (importSymbol) {
+                parentHadSymbol = true;
+            }
+
+            if (importSymbol) {
+                this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(importDeclAST, importDeclaration.getDisplayName(), importSymbol.getDeclarations()[0].ast());
+                importSymbol = null;
+            }
+
+            if (!importSymbol) {
+                importSymbol = new TypeScript.PullTypeAliasSymbol(declName);
+
+                if (!parent) {
+                    this.semanticInfoChain.cacheGlobalSymbol(importSymbol, 164 /* SomeContainer */);
+                }
+            }
+
+            importSymbol.addDeclaration(importDeclaration);
+            importDeclaration.setSymbol(importSymbol);
+
+            this.semanticInfoChain.setSymbolForAST(importDeclAST, importSymbol);
+
+            if (parent && !parentHadSymbol) {
+                if (declFlags & 1 /* Exported */) {
+                    parent.addEnclosedMemberContainer(importSymbol);
+                } else {
+                    parent.addEnclosedNonMemberContainer(importSymbol);
+                }
+            }
+        };
+
+        PullSymbolBinder.prototype.ensurePriorDeclarationsAreBound = function (container, currentDecl) {
+            if (!container) {
+                return;
+            }
+
+            var parentDecls = container.getDeclarations();
+            for (var i = 0; i < parentDecls.length; ++i) {
+                var parentDecl = parentDecls[i];
+                var childDecls = parentDecl.getChildDecls();
+                for (var j = 0; j < childDecls.length; ++j) {
+                    var childDecl = childDecls[j];
+                    if (childDecl === currentDecl) {
+                        return;
+                    }
+
+                    if (childDecl.name === currentDecl.name) {
+                        childDecl.ensureSymbolIsBound();
+                    }
+                }
+            }
+        };
+
+        PullSymbolBinder.prototype.bindClassDeclarationToPullSymbol = function (classDecl) {
+            var className = classDecl.name;
+            var classSymbol = null;
+
+            var constructorSymbol = null;
+            var constructorTypeSymbol = null;
+
+            var classAST = this.semanticInfoChain.getASTForDecl(classDecl);
+
+            var parent = this.getParent(classDecl);
+
+            this.ensurePriorDeclarationsAreBound(parent, classDecl);
+
+            var parentDecl = classDecl.getParentDecl();
+            var isExported = classDecl.flags & 1 /* Exported */;
+            var isGeneric = false;
+
+            classSymbol = this.getExistingSymbol(classDecl, 58728795 /* SomeType */, parent);
+
+            if (classSymbol && classSymbol.kind === 16 /* Interface */) {
+                this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(classAST.identifier, classDecl.getDisplayName(), classSymbol.getDeclarations()[0].ast());
+                classSymbol = null;
+            }
+
+            classSymbol = new TypeScript.PullTypeSymbol(className, 8 /* Class */);
+
+            if (!parent) {
+                this.semanticInfoChain.cacheGlobalSymbol(classSymbol, 8 /* Class */);
+            }
+
+            classSymbol.addDeclaration(classDecl);
+
+            classDecl.setSymbol(classSymbol);
+
+            this.semanticInfoChain.setSymbolForAST(classAST.identifier, classSymbol);
+            this.semanticInfoChain.setSymbolForAST(classAST, classSymbol);
+
+            if (parent) {
+                if (classDecl.flags & 1 /* Exported */) {
+                    parent.addEnclosedMemberType(classSymbol);
+                } else {
+                    parent.addEnclosedNonMemberType(classSymbol);
+                }
+            }
+
+            var typeParameterDecls = classDecl.getTypeParameters();
+
+            for (var i = 0; i < typeParameterDecls.length; i++) {
+                var typeParameterSymbol = classSymbol.findTypeParameter(typeParameterDecls[i].name);
+
+                if (typeParameterSymbol) {
+                    var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameterSymbol.getDeclarations()[0]);
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameterSymbol.getName()]);
+                }
+
+                typeParameterSymbol = new TypeScript.PullTypeParameterSymbol(typeParameterDecls[i].name);
+
+                classSymbol.addTypeParameter(typeParameterSymbol);
+                typeParameterSymbol.addDeclaration(typeParameterDecls[i]);
+                typeParameterDecls[i].setSymbol(typeParameterSymbol);
+            }
+
+            constructorSymbol = classSymbol.getConstructorMethod();
+            constructorTypeSymbol = constructorSymbol ? constructorSymbol.type : null;
+
+            if (!constructorSymbol) {
+                var siblingValueDecls = null;
+                if (parentDecl) {
+                    siblingValueDecls = parentDecl.searchChildDecls(className, 68147712 /* SomeValue */);
+
+                    if (siblingValueDecls && siblingValueDecls[0] && siblingValueDecls[0].hasSymbol()) {
+                        constructorSymbol = siblingValueDecls[0].getSymbol();
+                    }
+                }
+
+                if (constructorSymbol) {
+                    constructorTypeSymbol = constructorSymbol.type;
+                } else {
+                    constructorSymbol = new TypeScript.PullSymbol(className, 32768 /* ConstructorMethod */);
+                    constructorTypeSymbol = new TypeScript.PullTypeSymbol("", 33554432 /* ConstructorType */);
+                    constructorSymbol.setIsSynthesized();
+                    constructorSymbol.type = constructorTypeSymbol;
+                }
+
+                classSymbol.setConstructorMethod(constructorSymbol);
+                classSymbol.setHasDefaultConstructor();
+            }
+
+            if (constructorSymbol.getIsSynthesized()) {
+                constructorSymbol.addDeclaration(classDecl.getValueDecl());
+                constructorTypeSymbol.addDeclaration(classDecl);
+            } else {
+                classSymbol.setHasDefaultConstructor(false);
+            }
+
+            constructorTypeSymbol.setAssociatedContainerType(classSymbol);
+
+            var valueDecl = classDecl.getValueDecl();
+
+            if (valueDecl) {
+                valueDecl.ensureSymbolIsBound();
+            }
+
+            this.bindStaticPrototypePropertyOfClass(classAST, classSymbol, constructorTypeSymbol);
+        };
+
+        PullSymbolBinder.prototype.bindInterfaceDeclarationToPullSymbol = function (interfaceDecl) {
+            var interfaceName = interfaceDecl.name;
+            var interfaceSymbol = null;
+
+            var interfaceAST = this.semanticInfoChain.getASTForDecl(interfaceDecl);
+            var createdNewSymbol = false;
+            var parent = this.getParent(interfaceDecl);
+
+            var acceptableSharedKind = 16 /* Interface */;
+
+            interfaceSymbol = this.getExistingSymbol(interfaceDecl, 58728795 /* SomeType */, parent);
+
+            if (interfaceSymbol) {
+                if (!(interfaceSymbol.kind & acceptableSharedKind)) {
+                    this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(interfaceAST.identifier, interfaceDecl.getDisplayName(), interfaceSymbol.getDeclarations()[0].ast());
+                    interfaceSymbol = null;
+                } else if (!this.checkThatExportsMatch(interfaceDecl, interfaceSymbol)) {
+                    interfaceSymbol = null;
+                }
+            }
+
+            if (!interfaceSymbol) {
+                interfaceSymbol = new TypeScript.PullTypeSymbol(interfaceName, 16 /* Interface */);
+                createdNewSymbol = true;
+
+                if (!parent) {
+                    this.semanticInfoChain.cacheGlobalSymbol(interfaceSymbol, acceptableSharedKind);
+                }
+            }
+
+            interfaceSymbol.addDeclaration(interfaceDecl);
+            interfaceDecl.setSymbol(interfaceSymbol);
+
+            if (createdNewSymbol) {
+                if (parent) {
+                    if (interfaceDecl.flags & 1 /* Exported */) {
+                        parent.addEnclosedMemberType(interfaceSymbol);
+                    } else {
+                        parent.addEnclosedNonMemberType(interfaceSymbol);
+                    }
+                }
+            }
+
+            var typeParameters = interfaceDecl.getTypeParameters();
+            var typeParameter;
+            var typeParameterDecls = null;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameter = interfaceSymbol.findTypeParameter(typeParameters[i].name);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name);
+
+                    interfaceSymbol.addTypeParameter(typeParameter);
+                } else {
+                    typeParameterDecls = typeParameter.getDeclarations();
+
+                    for (var j = 0; j < typeParameterDecls.length; j++) {
+                        var typeParameterDeclParent = typeParameterDecls[j].getParentDecl();
+
+                        if (typeParameterDeclParent && typeParameterDeclParent === interfaceDecl) {
+                            var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameterDecls[0]);
+                            this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]);
+
+                            break;
+                        }
+                    }
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+        };
+
+        PullSymbolBinder.prototype.bindObjectTypeDeclarationToPullSymbol = function (objectDecl) {
+            var objectSymbolAST = this.semanticInfoChain.getASTForDecl(objectDecl);
+
+            var objectSymbol = new TypeScript.PullTypeSymbol("", 8388608 /* ObjectType */);
+
+            objectSymbol.addDeclaration(objectDecl);
+            objectDecl.setSymbol(objectSymbol);
+
+            this.semanticInfoChain.setSymbolForAST(objectSymbolAST, objectSymbol);
+
+            var childDecls = objectDecl.getChildDecls();
+
+            for (var i = 0; i < childDecls.length; i++) {
+                this.bindDeclToPullSymbol(childDecls[i]);
+            }
+        };
+
+        PullSymbolBinder.prototype.bindConstructorTypeDeclarationToPullSymbol = function (constructorTypeDeclaration) {
+            var declKind = constructorTypeDeclaration.kind;
+            var declFlags = constructorTypeDeclaration.flags;
+            var constructorTypeAST = this.semanticInfoChain.getASTForDecl(constructorTypeDeclaration);
+
+            var constructorTypeSymbol = new TypeScript.PullTypeSymbol("", 33554432 /* ConstructorType */);
+
+            constructorTypeDeclaration.setSymbol(constructorTypeSymbol);
+            constructorTypeSymbol.addDeclaration(constructorTypeDeclaration);
+            this.semanticInfoChain.setSymbolForAST(constructorTypeAST, constructorTypeSymbol);
+
+            var signature = new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */);
+
+            var funcDecl = this.semanticInfoChain.getASTForDecl(constructorTypeDeclaration);
+            if (TypeScript.lastParameterIsRest(funcDecl.parameterList)) {
+                signature.hasVarArgs = true;
+            }
+
+            signature.addDeclaration(constructorTypeDeclaration);
+            constructorTypeDeclaration.setSignatureSymbol(signature);
+
+            this.bindParameterSymbols(funcDecl, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.parameterList), constructorTypeSymbol, signature);
+
+            var typeParameters = constructorTypeDeclaration.getTypeParameters();
+            var typeParameter;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameter = constructorTypeSymbol.findTypeParameter(typeParameters[i].name);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name);
+
+                    signature.addTypeParameter(typeParameter);
+                } else {
+                    var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]);
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.name]);
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+
+            constructorTypeSymbol.appendConstructSignature(signature);
+        };
+
+        PullSymbolBinder.prototype.bindVariableDeclarationToPullSymbol = function (variableDeclaration) {
+            var declFlags = variableDeclaration.flags;
+            var declKind = variableDeclaration.kind;
+            var varDeclAST = this.semanticInfoChain.getASTForDecl(variableDeclaration);
+            var nameAST = varDeclAST.kind() === 131 /* ClassDeclaration */ ? varDeclAST.identifier : varDeclAST.kind() === 225 /* VariableDeclarator */ ? varDeclAST.propertyName : varDeclAST.kind() === 132 /* EnumDeclaration */ ? varDeclAST.identifier : varDeclAST;
+
+            var isExported = (declFlags & 1 /* Exported */) !== 0;
+
+            var variableSymbol = null;
+
+            var declName = variableDeclaration.name;
+
+            var parentHadSymbol = false;
+
+            var parent = this.getParent(variableDeclaration, true);
+
+            var parentDecl = variableDeclaration.getParentDecl();
+
+            var isImplicit = (declFlags & 118784 /* ImplicitVariable */) !== 0;
+            var isModuleValue = (declFlags & (32768 /* InitializedModule */)) !== 0;
+            var isEnumValue = (declFlags & 4096 /* Enum */) !== 0;
+            var isClassConstructorVariable = (declFlags & 16384 /* ClassConstructorVariable */) !== 0;
+            variableSymbol = this.getExistingSymbol(variableDeclaration, 68147712 /* SomeValue */, parent);
+
+            if (!variableSymbol && isModuleValue) {
+                variableSymbol = this.findExistingVariableSymbolForModuleValueDecl(variableDeclaration.getContainerDecl());
+            }
+
+            if (variableSymbol && !variableSymbol.isType()) {
+                parentHadSymbol = true;
+            }
+
+            var decl;
+            var decls;
+            var ast;
+            var members;
+
+            if (variableSymbol) {
+                var prevKind = variableSymbol.kind;
+                var prevIsEnum = variableSymbol.anyDeclHasFlag(4096 /* Enum */);
+                var prevIsClassConstructorVariable = variableSymbol.anyDeclHasFlag(16384 /* ClassConstructorVariable */);
+                var prevIsModuleValue = variableSymbol.allDeclsHaveFlag(32768 /* InitializedModule */);
+                var prevIsImplicit = variableSymbol.anyDeclHasFlag(118784 /* ImplicitVariable */);
+                var prevIsFunction = TypeScript.ArrayUtilities.any(variableSymbol.getDeclarations(), function (decl) {
+                    return decl.kind === 16384 /* Function */;
+                });
+                var prevIsAmbient = variableSymbol.allDeclsHaveFlag(8 /* Ambient */);
+                var isAmbientOrPrevIsAmbient = prevIsAmbient || (variableDeclaration.flags & 8 /* Ambient */) !== 0;
+                var prevDecl = variableSymbol.getDeclarations()[0];
+                var prevParentDecl = prevDecl.getParentDecl();
+                var bothAreGlobal = parentDecl && (parentDecl.kind === 1 /* Script */) && (prevParentDecl.kind === 1 /* Script */);
+                var shareParent = bothAreGlobal || prevDecl.getParentDecl() === variableDeclaration.getParentDecl();
+                var prevIsParam = shareParent && prevKind === 2048 /* Parameter */ && declKind == 512 /* Variable */;
+
+                var acceptableRedeclaration = prevIsParam || (isImplicit && ((!isEnumValue && !isClassConstructorVariable && prevIsFunction) || ((isModuleValue || isEnumValue) && (prevIsModuleValue || prevIsEnum)) || (isClassConstructorVariable && prevIsModuleValue && isAmbientOrPrevIsAmbient) || (isModuleValue && prevIsClassConstructorVariable)));
+
+                if (acceptableRedeclaration && (prevIsClassConstructorVariable || prevIsFunction) && !isAmbientOrPrevIsAmbient) {
+                    if (prevDecl.fileName() !== variableDeclaration.fileName()) {
+                        this.semanticInfoChain.addDiagnostic(TypeScript.PullHelpers.diagnosticFromDecl(variableDeclaration, TypeScript.DiagnosticCode.Module_0_cannot_merge_with_previous_declaration_of_1_in_a_different_file_2, [declName, declName, prevDecl.fileName()]));
+                        variableSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(declName);
+                    }
+                }
+
+                if (!acceptableRedeclaration || prevIsParam) {
+                    if (!prevIsParam && (isImplicit || prevIsImplicit || TypeScript.hasFlag(prevKind, 1032192 /* SomeFunction */)) || !shareParent) {
+                        this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(nameAST, variableDeclaration.getDisplayName(), variableSymbol.getDeclarations()[0].ast());
+                        variableSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(declName);
+                    } else {
+                        this.checkThatExportsMatch(variableDeclaration, variableSymbol);
+                        variableSymbol = null;
+                        parentHadSymbol = false;
+                    }
+                }
+
+                if (variableSymbol && !(variableSymbol.type && variableSymbol.type.isError()) && !this.checkThatExportsMatch(variableDeclaration, variableSymbol, !(isModuleValue && prevIsModuleValue))) {
+                    variableSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(declName);
+                }
+            }
+
+            if ((declFlags & 118784 /* ImplicitVariable */) === 0) {
+                if (!variableSymbol) {
+                    variableSymbol = new TypeScript.PullSymbol(declName, declKind);
+                    if (!parent && parentDecl.kind === 1 /* Script */) {
+                        this.semanticInfoChain.cacheGlobalSymbol(variableSymbol, declKind);
+                    }
+                }
+
+                variableSymbol.addDeclaration(variableDeclaration);
+                variableDeclaration.setSymbol(variableSymbol);
+
+                this.semanticInfoChain.setSymbolForAST(nameAST, variableSymbol);
+                this.semanticInfoChain.setSymbolForAST(varDeclAST, variableSymbol);
+            } else if (!parentHadSymbol) {
+                if (isClassConstructorVariable) {
+                    var classTypeSymbol = variableSymbol;
+
+                    if (parent) {
+                        members = parent.getMembers();
+
+                        for (var i = 0; i < members.length; i++) {
+                            if ((members[i].name === declName) && (members[i].kind === 8 /* Class */)) {
+                                classTypeSymbol = members[i];
+                                break;
+                            }
+                        }
+                    }
+
+                    if (!classTypeSymbol) {
+                        var containerDecl = variableDeclaration.getContainerDecl();
+                        classTypeSymbol = containerDecl.getSymbol();
+                        if (!classTypeSymbol) {
+                            classTypeSymbol = this.semanticInfoChain.findTopLevelSymbol(declName, 58728795 /* SomeType */, variableDeclaration);
+                        }
+                    }
+
+                    if (classTypeSymbol && (classTypeSymbol.kind !== 8 /* Class */)) {
+                        classTypeSymbol = null;
+                    }
+
+                    if (classTypeSymbol && classTypeSymbol.isClass()) {
+                        variableSymbol = classTypeSymbol.getConstructorMethod();
+                        variableDeclaration.setSymbol(variableSymbol);
+
+                        decls = classTypeSymbol.getDeclarations();
+
+                        if (decls.length) {
+                            decl = decls[decls.length - 1];
+                            ast = this.semanticInfoChain.getASTForDecl(decl);
+                        }
+                    } else {
+                        if (!variableSymbol) {
+                            variableSymbol = new TypeScript.PullSymbol(declName, declKind);
+                        }
+
+                        variableSymbol.addDeclaration(variableDeclaration);
+                        variableDeclaration.setSymbol(variableSymbol);
+
+                        variableSymbol.type = this.semanticInfoChain.anyTypeSymbol;
+                    }
+                } else if (declFlags & 102400 /* SomeInitializedModule */) {
+                    var moduleContainerTypeSymbol = null;
+                    var moduleParent = this.getParent(variableDeclaration);
+
+                    if (moduleParent) {
+                        members = moduleParent.getMembers();
+
+                        for (var i = 0; i < members.length; i++) {
+                            if ((members[i].name === declName) && (members[i].isContainer())) {
+                                moduleContainerTypeSymbol = members[i];
+                                break;
+                            }
+                        }
+                    }
+
+                    if (!moduleContainerTypeSymbol) {
+                        var containerDecl = variableDeclaration.getContainerDecl();
+                        moduleContainerTypeSymbol = containerDecl.getSymbol();
+                        if (!moduleContainerTypeSymbol) {
+                            moduleContainerTypeSymbol = this.semanticInfoChain.findTopLevelSymbol(declName, 164 /* SomeContainer */, variableDeclaration);
+
+                            if (!moduleContainerTypeSymbol) {
+                                moduleContainerTypeSymbol = this.semanticInfoChain.findTopLevelSymbol(declName, 64 /* Enum */, variableDeclaration);
+                            }
+                        }
+                    }
+
+                    if (moduleContainerTypeSymbol && (!moduleContainerTypeSymbol.isContainer())) {
+                        moduleContainerTypeSymbol = null;
+                    }
+
+                    if (moduleContainerTypeSymbol) {
+                        variableSymbol = moduleContainerTypeSymbol.getInstanceSymbol();
+                        if (!variableSymbol) {
+                            variableSymbol = new TypeScript.PullSymbol(declName, declKind);
+                            variableSymbol.type = new TypeScript.PullTypeSymbol("", 8388608 /* ObjectType */);
+                        }
+
+                        if (!variableSymbol.hasDeclaration(variableDeclaration)) {
+                            variableSymbol.addDeclaration(variableDeclaration);
+                        }
+                        variableDeclaration.setSymbol(variableSymbol);
+                    } else {
+                        TypeScript.Debug.assert(false, "Attempted to bind invalid implicit variable symbol");
+                    }
+                }
+            } else {
+                if (!variableSymbol.hasDeclaration(variableDeclaration)) {
+                    variableSymbol.addDeclaration(variableDeclaration);
+                }
+                variableDeclaration.setSymbol(variableSymbol);
+            }
+
+            var containerDecl = variableDeclaration.getContainerDecl();
+            if (variableSymbol && variableSymbol.type && containerDecl && !variableSymbol.type.hasDeclaration(containerDecl)) {
+                variableSymbol.type.addDeclaration(containerDecl);
+            }
+
+            if (parent && !parentHadSymbol) {
+                if (declFlags & 1 /* Exported */) {
+                    parent.addMember(variableSymbol);
+                } else {
+                    parent.addEnclosedNonMember(variableSymbol);
+                }
+            }
+        };
+
+        PullSymbolBinder.prototype.bindCatchVariableToPullSymbol = function (variableDeclaration) {
+            var declFlags = variableDeclaration.flags;
+            var declKind = variableDeclaration.kind;
+            var identifier = this.semanticInfoChain.getASTForDecl(variableDeclaration);
+
+            var declName = variableDeclaration.name;
+
+            var variableSymbol = new TypeScript.PullSymbol(declName, declKind);
+
+            variableSymbol.addDeclaration(variableDeclaration);
+            variableDeclaration.setSymbol(variableSymbol);
+
+            variableSymbol.type = this.semanticInfoChain.anyTypeSymbol;
+
+            this.semanticInfoChain.setSymbolForAST(identifier, variableSymbol);
+        };
+
+        PullSymbolBinder.prototype.bindEnumMemberDeclarationToPullSymbol = function (propertyDeclaration) {
+            var declFlags = propertyDeclaration.flags;
+            var declKind = propertyDeclaration.kind;
+            var propDeclAST = this.semanticInfoChain.getASTForDecl(propertyDeclaration);
+
+            var declName = propertyDeclaration.name;
+
+            var parentHadSymbol = false;
+
+            var parent = this.getParent(propertyDeclaration, true);
+
+            var propertySymbol = parent.findMember(declName, false);
+
+            if (propertySymbol) {
+                this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(propDeclAST.propertyName, propertyDeclaration.getDisplayName(), propertySymbol.getDeclarations()[0].ast());
+            }
+
+            if (propertySymbol) {
+                parentHadSymbol = true;
+            }
+
+            if (!parentHadSymbol) {
+                propertySymbol = new TypeScript.PullSymbol(declName, declKind);
+            }
+
+            propertySymbol.addDeclaration(propertyDeclaration);
+            propertyDeclaration.setSymbol(propertySymbol);
+
+            this.semanticInfoChain.setSymbolForAST(propDeclAST.propertyName, propertySymbol);
+            this.semanticInfoChain.setSymbolForAST(propDeclAST, propertySymbol);
+
+            if (parent && !parentHadSymbol) {
+                parent.addMember(propertySymbol);
+            }
+        };
+
+        PullSymbolBinder.prototype.bindPropertyDeclarationToPullSymbol = function (propertyDeclaration) {
+            var declFlags = propertyDeclaration.flags;
+            var declKind = propertyDeclaration.kind;
+
+            var ast = this.semanticInfoChain.getASTForDecl(propertyDeclaration);
+            var astName = ast.kind() === 136 /* MemberVariableDeclaration */ ? ast.variableDeclarator.propertyName : ast.kind() === 141 /* PropertySignature */ ? ast.propertyName : ast.kind() === 242 /* Parameter */ ? ast.identifier : ast.propertyName;
+
+            var isStatic = false;
+            var isOptional = false;
+
+            var propertySymbol = null;
+
+            if (TypeScript.hasFlag(declFlags, 16 /* Static */)) {
+                isStatic = true;
+            }
+
+            if (TypeScript.hasFlag(declFlags, 128 /* Optional */)) {
+                isOptional = true;
+            }
+
+            var declName = propertyDeclaration.name;
+
+            var parentHadSymbol = false;
+
+            var parent = this.getParent(propertyDeclaration, true);
+
+            if (parent.isClass() && isStatic) {
+                parent = parent.getConstructorMethod().type;
+            }
+
+            propertySymbol = parent.findMember(declName, false);
+
+            if (propertySymbol) {
+                this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(astName, propertyDeclaration.getDisplayName(), propertySymbol.getDeclarations()[0].ast());
+            }
+
+            if (propertySymbol) {
+                parentHadSymbol = true;
+            }
+
+            var classTypeSymbol;
+
+            if (!parentHadSymbol) {
+                propertySymbol = new TypeScript.PullSymbol(declName, declKind);
+            }
+
+            propertySymbol.addDeclaration(propertyDeclaration);
+            propertyDeclaration.setSymbol(propertySymbol);
+
+            this.semanticInfoChain.setSymbolForAST(astName, propertySymbol);
+            this.semanticInfoChain.setSymbolForAST(ast, propertySymbol);
+
+            if (isOptional) {
+                propertySymbol.isOptional = true;
+            }
+
+            if (parent && !parentHadSymbol) {
+                parent.addMember(propertySymbol);
+            }
+        };
+
+        PullSymbolBinder.prototype.bindParameterSymbols = function (functionDeclaration, parameterList, funcType, signatureSymbol) {
+            var parameters = [];
+            var params = TypeScript.createIntrinsicsObject();
+            var funcDecl = this.semanticInfoChain.getDeclForAST(functionDeclaration);
+
+            if (parameterList) {
+                for (var i = 0, n = parameterList.length; i < n; i++) {
+                    var argDecl = parameterList.astAt(i);
+                    var id = parameterList.identifierAt(i);
+                    var decl = this.semanticInfoChain.getDeclForAST(argDecl);
+                    var isProperty = TypeScript.hasFlag(decl.flags, 8388608 /* PropertyParameter */);
+                    var parameterSymbol = new TypeScript.PullSymbol(id.valueText(), 2048 /* Parameter */);
+
+                    if ((i === (n - 1)) && parameterList.lastParameterIsRest()) {
+                        parameterSymbol.isVarArg = true;
+                    }
+
+                    if (params[id.valueText()]) {
+                        this.semanticInfoChain.addDiagnosticFromAST(argDecl, TypeScript.DiagnosticCode.Duplicate_identifier_0, [id.text()]);
+                    } else {
+                        params[id.valueText()] = true;
+                    }
+
+                    if (decl) {
+                        var isParameterOptional = false;
+
+                        if (isProperty) {
+                            decl.ensureSymbolIsBound();
+                            var valDecl = decl.getValueDecl();
+
+                            if (valDecl) {
+                                isParameterOptional = TypeScript.hasFlag(valDecl.flags, 128 /* Optional */);
+
+                                valDecl.setSymbol(parameterSymbol);
+                                parameterSymbol.addDeclaration(valDecl);
+                            }
+                        } else {
+                            isParameterOptional = TypeScript.hasFlag(decl.flags, 128 /* Optional */);
+
+                            parameterSymbol.addDeclaration(decl);
+                            decl.setSymbol(parameterSymbol);
+                        }
+
+                        parameterSymbol.isOptional = isParameterOptional;
+                    }
+
+                    signatureSymbol.addParameter(parameterSymbol, parameterSymbol.isOptional);
+
+                    if (signatureSymbol.isDefinition()) {
+                        funcType.addEnclosedNonMember(parameterSymbol);
+                    }
+                }
+            }
+        };
+
+        PullSymbolBinder.prototype.bindFunctionDeclarationToPullSymbol = function (functionDeclaration) {
+            var declKind = functionDeclaration.kind;
+            var declFlags = functionDeclaration.flags;
+            var funcDeclAST = this.semanticInfoChain.getASTForDecl(functionDeclaration);
+
+            var isExported = (declFlags & 1 /* Exported */) !== 0;
+
+            var funcName = functionDeclaration.name;
+
+            var isSignature = (declFlags & 2048 /* Signature */) !== 0;
+
+            var parent = this.getParent(functionDeclaration, true);
+
+            var parentDecl = functionDeclaration.getParentDecl();
+            var parentHadSymbol = false;
+
+            var functionSymbol = null;
+            var functionTypeSymbol = null;
+
+            functionSymbol = this.getExistingSymbol(functionDeclaration, 68147712 /* SomeValue */, parent);
+
+            if (functionSymbol) {
+                var acceptableRedeclaration;
+
+                if (functionSymbol.kind === 16384 /* Function */) {
+                    acceptableRedeclaration = isSignature || functionSymbol.allDeclsHaveFlag(2048 /* Signature */);
+                } else {
+                    var isCurrentDeclAmbient = TypeScript.hasFlag(functionDeclaration.flags, 8 /* Ambient */);
+                    acceptableRedeclaration = TypeScript.ArrayUtilities.all(functionSymbol.getDeclarations(), function (decl) {
+                        var isInitializedModuleOrAmbientDecl = TypeScript.hasFlag(decl.flags, 32768 /* InitializedModule */) && (isCurrentDeclAmbient || TypeScript.hasFlag(decl.flags, 8 /* Ambient */));
+                        var isSignature = TypeScript.hasFlag(decl.flags, 2048 /* Signature */);
+                        return isInitializedModuleOrAmbientDecl || isSignature;
+                    });
+                }
+
+                if (!acceptableRedeclaration) {
+                    this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(funcDeclAST.identifier, functionDeclaration.getDisplayName(), functionSymbol.getDeclarations()[0].ast());
+                    functionSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(funcName);
+                }
+            }
+
+            if (functionSymbol) {
+                functionTypeSymbol = functionSymbol.type;
+                parentHadSymbol = true;
+            }
+
+            if (!functionSymbol) {
+                functionSymbol = new TypeScript.PullSymbol(funcName, 16384 /* Function */);
+            }
+
+            if (!functionTypeSymbol) {
+                functionTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */);
+                functionSymbol.type = functionTypeSymbol;
+                functionTypeSymbol.setFunctionSymbol(functionSymbol);
+            }
+
+            functionDeclaration.setSymbol(functionSymbol);
+            functionSymbol.addDeclaration(functionDeclaration);
+            functionTypeSymbol.addDeclaration(functionDeclaration);
+
+            this.semanticInfoChain.setSymbolForAST(funcDeclAST.identifier, functionSymbol);
+            this.semanticInfoChain.setSymbolForAST(funcDeclAST, functionSymbol);
+
+            if (parent && !parentHadSymbol) {
+                if (isExported) {
+                    parent.addMember(functionSymbol);
+                } else {
+                    parent.addEnclosedNonMember(functionSymbol);
+                }
+            }
+
+            var signature = new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */, !isSignature);
+
+            signature.addDeclaration(functionDeclaration);
+            functionDeclaration.setSignatureSymbol(signature);
+
+            if (TypeScript.lastParameterIsRest(funcDeclAST.callSignature.parameterList)) {
+                signature.hasVarArgs = true;
+            }
+
+            var funcDecl = this.semanticInfoChain.getASTForDecl(functionDeclaration);
+            this.bindParameterSymbols(funcDecl, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList), functionTypeSymbol, signature);
+
+            var typeParameters = functionDeclaration.getTypeParameters();
+            var typeParameter;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameter = signature.findTypeParameter(typeParameters[i].name);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name);
+
+                    signature.addTypeParameter(typeParameter);
+                } else {
+                    var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]);
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.name]);
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+
+            functionTypeSymbol.appendCallSignature(signature);
+        };
+
+        PullSymbolBinder.prototype.bindFunctionExpressionToPullSymbol = function (functionExpressionDeclaration) {
+            var declKind = functionExpressionDeclaration.kind;
+            var declFlags = functionExpressionDeclaration.flags;
+            var ast = this.semanticInfoChain.getASTForDecl(functionExpressionDeclaration);
+
+            var parameters = ast.kind() === 219 /* SimpleArrowFunctionExpression */ ? TypeScript.ASTHelpers.parametersFromIdentifier(ast.identifier) : TypeScript.ASTHelpers.parametersFromParameterList(TypeScript.ASTHelpers.getParameterList(ast));
+            var funcExpAST = ast;
+
+            var functionName = declKind === 131072 /* FunctionExpression */ ? functionExpressionDeclaration.getFunctionExpressionName() : functionExpressionDeclaration.name;
+            var functionSymbol = new TypeScript.PullSymbol(functionName, declKind);
+            var functionTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */);
+            functionTypeSymbol.setFunctionSymbol(functionSymbol);
+
+            functionSymbol.type = functionTypeSymbol;
+
+            functionExpressionDeclaration.setSymbol(functionSymbol);
+            functionSymbol.addDeclaration(functionExpressionDeclaration);
+            functionTypeSymbol.addDeclaration(functionExpressionDeclaration);
+
+            var name = funcExpAST.kind() === 222 /* FunctionExpression */ ? funcExpAST.identifier : funcExpAST.kind() === 241 /* FunctionPropertyAssignment */ ? funcExpAST.propertyName : null;
+            if (name) {
+                this.semanticInfoChain.setSymbolForAST(name, functionSymbol);
+            }
+
+            this.semanticInfoChain.setSymbolForAST(funcExpAST, functionSymbol);
+
+            var signature = new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */, true);
+
+            if (parameters.lastParameterIsRest()) {
+                signature.hasVarArgs = true;
+            }
+
+            var typeParameters = functionExpressionDeclaration.getTypeParameters();
+            var typeParameter;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameter = signature.findTypeParameter(typeParameters[i].name);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name);
+
+                    signature.addTypeParameter(typeParameter);
+                } else {
+                    var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]);
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]);
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+
+            signature.addDeclaration(functionExpressionDeclaration);
+            functionExpressionDeclaration.setSignatureSymbol(signature);
+
+            this.bindParameterSymbols(funcExpAST, parameters, functionTypeSymbol, signature);
+
+            functionTypeSymbol.appendCallSignature(signature);
+        };
+
+        PullSymbolBinder.prototype.bindFunctionTypeDeclarationToPullSymbol = function (functionTypeDeclaration) {
+            var declKind = functionTypeDeclaration.kind;
+            var declFlags = functionTypeDeclaration.flags;
+            var funcTypeAST = this.semanticInfoChain.getASTForDecl(functionTypeDeclaration);
+
+            var functionTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */);
+
+            functionTypeDeclaration.setSymbol(functionTypeSymbol);
+            functionTypeSymbol.addDeclaration(functionTypeDeclaration);
+            this.semanticInfoChain.setSymbolForAST(funcTypeAST, functionTypeSymbol);
+
+            var isSignature = (declFlags & 2048 /* Signature */) !== 0;
+            var signature = new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */, !isSignature);
+
+            if (TypeScript.lastParameterIsRest(funcTypeAST.parameterList)) {
+                signature.hasVarArgs = true;
+            }
+
+            var typeParameters = functionTypeDeclaration.getTypeParameters();
+            var typeParameter;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameter = signature.findTypeParameter(typeParameters[i].name);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name);
+
+                    signature.addTypeParameter(typeParameter);
+                } else {
+                    var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]);
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.name]);
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+
+            signature.addDeclaration(functionTypeDeclaration);
+            functionTypeDeclaration.setSignatureSymbol(signature);
+
+            this.bindParameterSymbols(funcTypeAST, TypeScript.ASTHelpers.parametersFromParameterList(funcTypeAST.parameterList), functionTypeSymbol, signature);
+
+            functionTypeSymbol.appendCallSignature(signature);
+        };
+
+        PullSymbolBinder.prototype.bindMethodDeclarationToPullSymbol = function (methodDeclaration) {
+            var declKind = methodDeclaration.kind;
+            var declFlags = methodDeclaration.flags;
+            var methodAST = this.semanticInfoChain.getASTForDecl(methodDeclaration);
+
+            var isPrivate = (declFlags & 2 /* Private */) !== 0;
+            var isStatic = (declFlags & 16 /* Static */) !== 0;
+            var isOptional = (declFlags & 128 /* Optional */) !== 0;
+
+            var methodName = methodDeclaration.name;
+
+            var isSignature = (declFlags & 2048 /* Signature */) !== 0;
+
+            var parent = this.getParent(methodDeclaration, true);
+            var parentHadSymbol = false;
+
+            var methodSymbol = null;
+            var methodTypeSymbol = null;
+
+            if (parent.isClass() && isStatic) {
+                parent = parent.getConstructorMethod().type;
+            }
+
+            methodSymbol = parent.findMember(methodName, false);
+
+            if (methodSymbol && (methodSymbol.kind !== 65536 /* Method */ || (!isSignature && !methodSymbol.allDeclsHaveFlag(2048 /* Signature */)))) {
+                this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(methodAST, methodDeclaration.getDisplayName(), methodSymbol.getDeclarations()[0].ast());
+                methodSymbol = null;
+            }
+
+            if (methodSymbol) {
+                methodTypeSymbol = methodSymbol.type;
+                parentHadSymbol = true;
+            }
+
+            if (!methodSymbol) {
+                methodSymbol = new TypeScript.PullSymbol(methodName, 65536 /* Method */);
+            }
+
+            if (!methodTypeSymbol) {
+                methodTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */);
+                methodSymbol.type = methodTypeSymbol;
+                methodTypeSymbol.setFunctionSymbol(methodSymbol);
+            }
+
+            methodDeclaration.setSymbol(methodSymbol);
+            methodSymbol.addDeclaration(methodDeclaration);
+            methodTypeSymbol.addDeclaration(methodDeclaration);
+
+            var nameAST = methodAST.kind() === 135 /* MemberFunctionDeclaration */ ? methodAST.propertyName : methodAST.propertyName;
+
+            TypeScript.Debug.assert(nameAST);
+
+            this.semanticInfoChain.setSymbolForAST(nameAST, methodSymbol);
+            this.semanticInfoChain.setSymbolForAST(methodAST, methodSymbol);
+
+            if (isOptional) {
+                methodSymbol.isOptional = true;
+            }
+
+            if (!parentHadSymbol) {
+                parent.addMember(methodSymbol);
+            }
+
+            var sigKind = 1048576 /* CallSignature */;
+
+            var signature = new TypeScript.PullSignatureSymbol(sigKind, !isSignature);
+
+            var parameterList = TypeScript.ASTHelpers.getParameterList(methodAST);
+            if (TypeScript.lastParameterIsRest(parameterList)) {
+                signature.hasVarArgs = true;
+            }
+
+            var typeParameters = methodDeclaration.getTypeParameters();
+            var typeParameter;
+            var typeParameterName;
+            var typeParameterAST;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameterName = typeParameters[i].name;
+                typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameters[i]);
+
+                typeParameter = signature.findTypeParameter(typeParameterName);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameterName);
+                    signature.addTypeParameter(typeParameter);
+                } else {
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]);
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+
+            signature.addDeclaration(methodDeclaration);
+            methodDeclaration.setSignatureSymbol(signature);
+
+            var funcDecl = this.semanticInfoChain.getASTForDecl(methodDeclaration);
+            this.bindParameterSymbols(funcDecl, TypeScript.ASTHelpers.parametersFromParameterList(TypeScript.ASTHelpers.getParameterList(funcDecl)), methodTypeSymbol, signature);
+
+            var signatureIndex = this.getIndexForInsertingSignatureAtEndOfEnclosingDeclInSignatureList(signature, methodTypeSymbol.getOwnCallSignatures());
+            methodTypeSymbol.insertCallSignatureAtIndex(signature, signatureIndex);
+        };
+
+        PullSymbolBinder.prototype.bindStaticPrototypePropertyOfClass = function (classAST, classTypeSymbol, constructorTypeSymbol) {
+            var prototypeStr = "prototype";
+
+            var prototypeSymbol = constructorTypeSymbol.findMember(prototypeStr, false);
+            if (prototypeSymbol && !prototypeSymbol.getIsSynthesized()) {
+                this.semanticInfoChain.addDiagnostic(TypeScript.PullHelpers.diagnosticFromDecl(prototypeSymbol.getDeclarations()[0], TypeScript.DiagnosticCode.Duplicate_identifier_0, [prototypeSymbol.getDisplayName()]));
+            }
+
+            if (!prototypeSymbol || !prototypeSymbol.getIsSynthesized()) {
+                var prototypeDecl = new TypeScript.PullSynthesizedDecl(prototypeStr, prototypeStr, 4096 /* Property */, 4 /* Public */ | 16 /* Static */, constructorTypeSymbol.getDeclarations()[0], this.semanticInfoChain);
+
+                prototypeSymbol = new TypeScript.PullSymbol(prototypeStr, 4096 /* Property */);
+                prototypeSymbol.setIsSynthesized();
+                prototypeSymbol.addDeclaration(prototypeDecl);
+                prototypeSymbol.type = classTypeSymbol;
+                constructorTypeSymbol.addMember(prototypeSymbol);
+
+                if (prototypeSymbol.type && prototypeSymbol.type.isGeneric()) {
+                    var resolver = this.semanticInfoChain.getResolver();
+                    prototypeSymbol.type = resolver.instantiateTypeToAny(prototypeSymbol.type, new TypeScript.PullTypeResolutionContext(resolver));
+                }
+                prototypeSymbol.setResolved();
+            }
+        };
+
+        PullSymbolBinder.prototype.bindConstructorDeclarationToPullSymbol = function (constructorDeclaration) {
+            var declKind = constructorDeclaration.kind;
+            var declFlags = constructorDeclaration.flags;
+            var constructorAST = this.semanticInfoChain.getASTForDecl(constructorDeclaration);
+
+            var constructorName = constructorDeclaration.name;
+
+            var isSignature = (declFlags & 2048 /* Signature */) !== 0;
+
+            var parent = this.getParent(constructorDeclaration, true);
+
+            var parentHadSymbol = false;
+
+            var constructorSymbol = parent.getConstructorMethod();
+            var constructorTypeSymbol = null;
+
+            if (constructorSymbol && (constructorSymbol.kind !== 32768 /* ConstructorMethod */ || (!isSignature && constructorSymbol.type && constructorSymbol.type.hasOwnConstructSignatures()))) {
+                var hasDefinitionSignature = false;
+                var constructorSigs = constructorSymbol.type.getOwnDeclaredConstructSignatures();
+
+                for (var i = 0; i < constructorSigs.length; i++) {
+                    if (!constructorSigs[i].anyDeclHasFlag(2048 /* Signature */)) {
+                        hasDefinitionSignature = true;
+                        break;
+                    }
+                }
+
+                if (hasDefinitionSignature) {
+                    this.semanticInfoChain.addDiagnosticFromAST(constructorAST, TypeScript.DiagnosticCode.Multiple_constructor_implementations_are_not_allowed);
+
+                    constructorSymbol = null;
+                }
+            }
+
+            if (constructorSymbol) {
+                constructorTypeSymbol = constructorSymbol.type;
+            } else {
+                constructorSymbol = new TypeScript.PullSymbol(constructorName, 32768 /* ConstructorMethod */);
+                constructorTypeSymbol = new TypeScript.PullTypeSymbol("", 33554432 /* ConstructorType */);
+            }
+
+            parent.setConstructorMethod(constructorSymbol);
+            constructorSymbol.type = constructorTypeSymbol;
+
+            constructorDeclaration.setSymbol(constructorSymbol);
+            constructorSymbol.addDeclaration(constructorDeclaration);
+            constructorTypeSymbol.addDeclaration(constructorDeclaration);
+            constructorSymbol.setIsSynthesized(false);
+            this.semanticInfoChain.setSymbolForAST(constructorAST, constructorSymbol);
+
+            var constructSignature = new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */, !isSignature);
+            constructSignature.returnType = parent;
+            constructSignature.addTypeParametersFromReturnType();
+
+            constructSignature.addDeclaration(constructorDeclaration);
+            constructorDeclaration.setSignatureSymbol(constructSignature);
+
+            this.bindParameterSymbols(constructorAST, TypeScript.ASTHelpers.parametersFromParameterList(constructorAST.callSignature.parameterList), constructorTypeSymbol, constructSignature);
+
+            if (TypeScript.lastParameterIsRest(constructorAST.callSignature.parameterList)) {
+                constructSignature.hasVarArgs = true;
+            }
+
+            constructorTypeSymbol.appendConstructSignature(constructSignature);
+        };
+
+        PullSymbolBinder.prototype.bindConstructSignatureDeclarationToPullSymbol = function (constructSignatureDeclaration) {
+            var parent = this.getParent(constructSignatureDeclaration, true);
+            var constructorAST = this.semanticInfoChain.getASTForDecl(constructSignatureDeclaration);
+
+            var constructSignature = new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */);
+
+            if (TypeScript.lastParameterIsRest(constructorAST.callSignature.parameterList)) {
+                constructSignature.hasVarArgs = true;
+            }
+
+            var typeParameters = constructSignatureDeclaration.getTypeParameters();
+            var typeParameter;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameter = constructSignature.findTypeParameter(typeParameters[i].name);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name);
+
+                    constructSignature.addTypeParameter(typeParameter);
+                } else {
+                    var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]);
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]);
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+
+            constructSignature.addDeclaration(constructSignatureDeclaration);
+            constructSignatureDeclaration.setSignatureSymbol(constructSignature);
+
+            var funcDecl = this.semanticInfoChain.getASTForDecl(constructSignatureDeclaration);
+            this.bindParameterSymbols(funcDecl, TypeScript.ASTHelpers.parametersFromParameterList(TypeScript.ASTHelpers.getParameterList(funcDecl)), null, constructSignature);
+
+            this.semanticInfoChain.setSymbolForAST(this.semanticInfoChain.getASTForDecl(constructSignatureDeclaration), constructSignature);
+
+            var signatureIndex = this.getIndexForInsertingSignatureAtEndOfEnclosingDeclInSignatureList(constructSignature, parent.getOwnDeclaredConstructSignatures());
+            parent.insertConstructSignatureAtIndex(constructSignature, signatureIndex);
+        };
+
+        PullSymbolBinder.prototype.bindCallSignatureDeclarationToPullSymbol = function (callSignatureDeclaration) {
+            var parent = this.getParent(callSignatureDeclaration, true);
+            var callSignatureAST = this.semanticInfoChain.getASTForDecl(callSignatureDeclaration);
+
+            var callSignature = new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */);
+
+            if (TypeScript.lastParameterIsRest(callSignatureAST.parameterList)) {
+                callSignature.hasVarArgs = true;
+            }
+
+            var typeParameters = callSignatureDeclaration.getTypeParameters();
+            var typeParameter;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameter = callSignature.findTypeParameter(typeParameters[i].name);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name);
+
+                    callSignature.addTypeParameter(typeParameter);
+                } else {
+                    var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]);
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]);
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+
+            callSignature.addDeclaration(callSignatureDeclaration);
+            callSignatureDeclaration.setSignatureSymbol(callSignature);
+
+            var funcDecl = this.semanticInfoChain.getASTForDecl(callSignatureDeclaration);
+            this.bindParameterSymbols(funcDecl, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.parameterList), null, callSignature);
+
+            this.semanticInfoChain.setSymbolForAST(this.semanticInfoChain.getASTForDecl(callSignatureDeclaration), callSignature);
+
+            var signatureIndex = this.getIndexForInsertingSignatureAtEndOfEnclosingDeclInSignatureList(callSignature, parent.getOwnCallSignatures());
+            parent.insertCallSignatureAtIndex(callSignature, signatureIndex);
+        };
+
+        PullSymbolBinder.prototype.bindIndexSignatureDeclarationToPullSymbol = function (indexSignatureDeclaration) {
+            var indexSignature = new TypeScript.PullSignatureSymbol(4194304 /* IndexSignature */);
+
+            indexSignature.addDeclaration(indexSignatureDeclaration);
+            indexSignatureDeclaration.setSignatureSymbol(indexSignature);
+
+            var funcDecl = this.semanticInfoChain.getASTForDecl(indexSignatureDeclaration);
+            this.bindParameterSymbols(funcDecl, TypeScript.ASTHelpers.parametersFromParameter(funcDecl.parameter), null, indexSignature);
+
+            this.semanticInfoChain.setSymbolForAST(this.semanticInfoChain.getASTForDecl(indexSignatureDeclaration), indexSignature);
+
+            var parent = this.getParent(indexSignatureDeclaration);
+            parent.addIndexSignature(indexSignature);
+            indexSignature.setContainer(parent);
+        };
+
+        PullSymbolBinder.prototype.bindGetAccessorDeclarationToPullSymbol = function (getAccessorDeclaration) {
+            var declKind = getAccessorDeclaration.kind;
+            var declFlags = getAccessorDeclaration.flags;
+            var funcDeclAST = this.semanticInfoChain.getASTForDecl(getAccessorDeclaration);
+
+            var isExported = (declFlags & 1 /* Exported */) !== 0;
+
+            var funcName = getAccessorDeclaration.name;
+
+            var isSignature = (declFlags & 2048 /* Signature */) !== 0;
+            var isStatic = false;
+
+            if (TypeScript.hasFlag(declFlags, 16 /* Static */)) {
+                isStatic = true;
+            }
+
+            var parent = this.getParent(getAccessorDeclaration, true);
+            var parentHadSymbol = false;
+
+            var accessorSymbol = null;
+            var getterSymbol = null;
+            var getterTypeSymbol = null;
+
+            if (isStatic) {
+                parent = parent.getConstructorMethod().type;
+            }
+
+            accessorSymbol = parent.findMember(funcName, false);
+
+            if (accessorSymbol) {
+                if (!accessorSymbol.isAccessor()) {
+                    this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(funcDeclAST.propertyName, getAccessorDeclaration.getDisplayName(), accessorSymbol.getDeclarations()[0].ast());
+                    accessorSymbol = null;
+                } else {
+                    getterSymbol = accessorSymbol.getGetter();
+
+                    if (getterSymbol) {
+                        this.semanticInfoChain.addDiagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Getter_0_already_declared, [getAccessorDeclaration.getDisplayName()]);
+                        accessorSymbol = null;
+                        getterSymbol = null;
+                    }
+                }
+            }
+
+            if (accessorSymbol) {
+                parentHadSymbol = true;
+            }
+
+            if (accessorSymbol && getterSymbol) {
+                getterTypeSymbol = getterSymbol.type;
+            }
+
+            if (!accessorSymbol) {
+                accessorSymbol = new TypeScript.PullAccessorSymbol(funcName);
+            }
+
+            if (!getterSymbol) {
+                getterSymbol = new TypeScript.PullSymbol(funcName, 16384 /* Function */);
+                getterTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */);
+                getterTypeSymbol.setFunctionSymbol(getterSymbol);
+
+                getterSymbol.type = getterTypeSymbol;
+
+                accessorSymbol.setGetter(getterSymbol);
+            }
+
+            getAccessorDeclaration.setSymbol(accessorSymbol);
+            accessorSymbol.addDeclaration(getAccessorDeclaration);
+            getterSymbol.addDeclaration(getAccessorDeclaration);
+
+            var nameAST = funcDeclAST.propertyName;
+            this.semanticInfoChain.setSymbolForAST(nameAST, accessorSymbol);
+            this.semanticInfoChain.setSymbolForAST(funcDeclAST, getterSymbol);
+
+            if (!parentHadSymbol) {
+                parent.addMember(accessorSymbol);
+            }
+
+            var signature = new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */, !isSignature);
+
+            signature.addDeclaration(getAccessorDeclaration);
+            getAccessorDeclaration.setSignatureSymbol(signature);
+
+            this.bindParameterSymbols(funcDeclAST, TypeScript.ASTHelpers.parametersFromParameterList(funcDeclAST.parameterList), getterTypeSymbol, signature);
+
+            getterTypeSymbol.appendCallSignature(signature);
+        };
+
+        PullSymbolBinder.prototype.bindSetAccessorDeclarationToPullSymbol = function (setAccessorDeclaration) {
+            var declKind = setAccessorDeclaration.kind;
+            var declFlags = setAccessorDeclaration.flags;
+            var funcDeclAST = this.semanticInfoChain.getASTForDecl(setAccessorDeclaration);
+
+            var isExported = (declFlags & 1 /* Exported */) !== 0;
+
+            var funcName = setAccessorDeclaration.name;
+
+            var isSignature = (declFlags & 2048 /* Signature */) !== 0;
+            var isStatic = false;
+
+            if (TypeScript.hasFlag(declFlags, 16 /* Static */)) {
+                isStatic = true;
+            }
+
+            var parent = this.getParent(setAccessorDeclaration, true);
+            var parentHadSymbol = false;
+
+            var accessorSymbol = null;
+            var setterSymbol = null;
+            var setterTypeSymbol = null;
+
+            if (isStatic) {
+                parent = parent.getConstructorMethod().type;
+            }
+
+            accessorSymbol = parent.findMember(funcName, false);
+
+            if (accessorSymbol) {
+                if (!accessorSymbol.isAccessor()) {
+                    this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(funcDeclAST.propertyName, setAccessorDeclaration.getDisplayName(), accessorSymbol.getDeclarations()[0].ast());
+                    accessorSymbol = null;
+                } else {
+                    setterSymbol = accessorSymbol.getSetter();
+
+                    if (setterSymbol) {
+                        this.semanticInfoChain.addDiagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Setter_0_already_declared, [setAccessorDeclaration.getDisplayName()]);
+                        accessorSymbol = null;
+                        setterSymbol = null;
+                    }
+                }
+            }
+
+            if (accessorSymbol) {
+                parentHadSymbol = true;
+
+                if (setterSymbol) {
+                    setterTypeSymbol = setterSymbol.type;
+                }
+            }
+
+            if (!accessorSymbol) {
+                accessorSymbol = new TypeScript.PullAccessorSymbol(funcName);
+            }
+
+            if (!setterSymbol) {
+                setterSymbol = new TypeScript.PullSymbol(funcName, 16384 /* Function */);
+                setterTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */);
+                setterTypeSymbol.setFunctionSymbol(setterSymbol);
+
+                setterSymbol.type = setterTypeSymbol;
+
+                accessorSymbol.setSetter(setterSymbol);
+            }
+
+            setAccessorDeclaration.setSymbol(accessorSymbol);
+            accessorSymbol.addDeclaration(setAccessorDeclaration);
+            setterSymbol.addDeclaration(setAccessorDeclaration);
+
+            var nameAST = funcDeclAST.propertyName;
+            this.semanticInfoChain.setSymbolForAST(nameAST, accessorSymbol);
+            this.semanticInfoChain.setSymbolForAST(funcDeclAST, setterSymbol);
+
+            if (!parentHadSymbol) {
+                parent.addMember(accessorSymbol);
+            }
+
+            var signature = new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */, !isSignature);
+
+            signature.addDeclaration(setAccessorDeclaration);
+            setAccessorDeclaration.setSignatureSymbol(signature);
+
+            this.bindParameterSymbols(funcDeclAST, TypeScript.ASTHelpers.parametersFromParameterList(funcDeclAST.parameterList), setterTypeSymbol, signature);
+
+            setterTypeSymbol.appendCallSignature(signature);
+        };
+
+        PullSymbolBinder.prototype.getDeclsToBind = function (decl) {
+            var decls;
+            switch (decl.kind) {
+                case 64 /* Enum */:
+                case 32 /* DynamicModule */:
+                case 4 /* Container */:
+                case 16 /* Interface */:
+                    decls = this.findDeclsInContext(decl, decl.kind, true);
+                    break;
+
+                case 512 /* Variable */:
+                case 16384 /* Function */:
+                case 65536 /* Method */:
+                case 32768 /* ConstructorMethod */:
+                    decls = this.findDeclsInContext(decl, decl.kind, false);
+                    break;
+
+                default:
+                    decls = [decl];
+            }
+            TypeScript.Debug.assert(decls && decls.length > 0);
+            TypeScript.Debug.assert(TypeScript.ArrayUtilities.contains(decls, decl));
+            return decls;
+        };
+
+        PullSymbolBinder.prototype.shouldBindDeclaration = function (decl) {
+            return !decl.hasBeenBound() && this.declsBeingBound.indexOf(decl.declID) < 0;
+        };
+
+        PullSymbolBinder.prototype.bindDeclToPullSymbol = function (decl) {
+            if (this.shouldBindDeclaration(decl)) {
+                this.bindAllDeclsToPullSymbol(decl);
+            }
+        };
+
+        PullSymbolBinder.prototype.bindAllDeclsToPullSymbol = function (askedDecl) {
+            var allDecls = this.getDeclsToBind(askedDecl);
+            for (var i = 0; i < allDecls.length; i++) {
+                var decl = allDecls[i];
+
+                if (this.shouldBindDeclaration(decl)) {
+                    this.bindSingleDeclToPullSymbol(decl);
+                }
+            }
+        };
+
+        PullSymbolBinder.prototype.bindSingleDeclToPullSymbol = function (decl) {
+            this.declsBeingBound.push(decl.declID);
+
+            switch (decl.kind) {
+                case 1 /* Script */:
+                    var childDecls = decl.getChildDecls();
+                    for (var i = 0; i < childDecls.length; i++) {
+                        this.bindDeclToPullSymbol(childDecls[i]);
+                    }
+                    break;
+
+                case 64 /* Enum */:
+                    this.bindEnumDeclarationToPullSymbol(decl);
+                    break;
+
+                case 32 /* DynamicModule */:
+                case 4 /* Container */:
+                    this.bindModuleDeclarationToPullSymbol(decl);
+                    break;
+
+                case 16 /* Interface */:
+                    this.bindInterfaceDeclarationToPullSymbol(decl);
+                    break;
+
+                case 8 /* Class */:
+                    this.bindClassDeclarationToPullSymbol(decl);
+                    break;
+
+                case 16384 /* Function */:
+                    this.bindFunctionDeclarationToPullSymbol(decl);
+                    break;
+
+                case 512 /* Variable */:
+                    this.bindVariableDeclarationToPullSymbol(decl);
+                    break;
+
+                case 1024 /* CatchVariable */:
+                    this.bindCatchVariableToPullSymbol(decl);
+                    break;
+
+                case 67108864 /* EnumMember */:
+                    this.bindEnumMemberDeclarationToPullSymbol(decl);
+                    break;
+
+                case 4096 /* Property */:
+                    this.bindPropertyDeclarationToPullSymbol(decl);
+                    break;
+
+                case 65536 /* Method */:
+                    this.bindMethodDeclarationToPullSymbol(decl);
+                    break;
+
+                case 32768 /* ConstructorMethod */:
+                    this.bindConstructorDeclarationToPullSymbol(decl);
+                    break;
+
+                case 1048576 /* CallSignature */:
+                    this.bindCallSignatureDeclarationToPullSymbol(decl);
+                    break;
+
+                case 2097152 /* ConstructSignature */:
+                    this.bindConstructSignatureDeclarationToPullSymbol(decl);
+                    break;
+
+                case 4194304 /* IndexSignature */:
+                    this.bindIndexSignatureDeclarationToPullSymbol(decl);
+                    break;
+
+                case 262144 /* GetAccessor */:
+                    this.bindGetAccessorDeclarationToPullSymbol(decl);
+                    break;
+
+                case 524288 /* SetAccessor */:
+                    this.bindSetAccessorDeclarationToPullSymbol(decl);
+                    break;
+
+                case 8388608 /* ObjectType */:
+                    this.bindObjectTypeDeclarationToPullSymbol(decl);
+                    break;
+
+                case 16777216 /* FunctionType */:
+                    this.bindFunctionTypeDeclarationToPullSymbol(decl);
+                    break;
+
+                case 33554432 /* ConstructorType */:
+                    this.bindConstructorTypeDeclarationToPullSymbol(decl);
+                    break;
+
+                case 131072 /* FunctionExpression */:
+                    this.bindFunctionExpressionToPullSymbol(decl);
+                    break;
+
+                case 128 /* TypeAlias */:
+                    this.bindImportDeclaration(decl);
+                    break;
+
+                case 2048 /* Parameter */:
+                case 8192 /* TypeParameter */:
+                    decl.getParentDecl().getSymbol();
+                    break;
+
+                case 268435456 /* CatchBlock */:
+                case 134217728 /* WithBlock */:
+                    break;
+
+                default:
+                    TypeScript.CompilerDiagnostics.assert(false, "Unrecognized type declaration");
+            }
+
+            TypeScript.Debug.assert(TypeScript.ArrayUtilities.last(this.declsBeingBound) === decl.declID);
+            this.declsBeingBound.pop();
+        };
+        return PullSymbolBinder;
+    })();
+    TypeScript.PullSymbolBinder = PullSymbolBinder;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (PullHelpers) {
+        function diagnosticFromDecl(decl, diagnosticKey, _arguments, additionalLocations) {
+            if (typeof _arguments === "undefined") { _arguments = null; }
+            if (typeof additionalLocations === "undefined") { additionalLocations = null; }
+            var ast = decl.ast();
+            return decl.semanticInfoChain.diagnosticFromAST(ast, diagnosticKey, _arguments, additionalLocations);
+        }
+        PullHelpers.diagnosticFromDecl = diagnosticFromDecl;
+
+        function resolveDeclaredSymbolToUseType(symbol) {
+            if (symbol.isSignature()) {
+                if (!symbol.returnType) {
+                    symbol._resolveDeclaredSymbol();
+                }
+            } else if (!symbol.type) {
+                symbol._resolveDeclaredSymbol();
+            }
+        }
+        PullHelpers.resolveDeclaredSymbolToUseType = resolveDeclaredSymbolToUseType;
+
+        function getSignatureForFuncDecl(functionDecl) {
+            var funcDecl = functionDecl.ast();
+            var funcSymbol = functionDecl.getSymbol();
+
+            if (!funcSymbol) {
+                funcSymbol = functionDecl.getSignatureSymbol();
+            }
+
+            var functionSignature = null;
+            var typeSymbolWithAllSignatures = null;
+            if (funcSymbol.isSignature()) {
+                functionSignature = funcSymbol;
+                var parent = functionDecl.getParentDecl();
+                typeSymbolWithAllSignatures = parent.getSymbol().type;
+            } else {
+                functionSignature = functionDecl.getSignatureSymbol();
+                typeSymbolWithAllSignatures = funcSymbol.type;
+            }
+            var signatures;
+
+            if (funcDecl.kind() === 137 /* ConstructorDeclaration */ || functionDecl.kind === 2097152 /* ConstructSignature */) {
+                signatures = typeSymbolWithAllSignatures.getConstructSignatures();
+            } else if (functionDecl.kind === 4194304 /* IndexSignature */) {
+                signatures = typeSymbolWithAllSignatures.getIndexSignatures();
+            } else {
+                signatures = typeSymbolWithAllSignatures.getCallSignatures();
+            }
+
+            return {
+                signature: functionSignature,
+                allSignatures: signatures
+            };
+        }
+        PullHelpers.getSignatureForFuncDecl = getSignatureForFuncDecl;
+
+        function getAccessorSymbol(getterOrSetter, semanticInfoChain) {
+            var functionDecl = semanticInfoChain.getDeclForAST(getterOrSetter);
+            var getterOrSetterSymbol = functionDecl.getSymbol();
+
+            return getterOrSetterSymbol;
+        }
+        PullHelpers.getAccessorSymbol = getAccessorSymbol;
+
+        function getGetterAndSetterFunction(funcDecl, semanticInfoChain) {
+            var accessorSymbol = PullHelpers.getAccessorSymbol(funcDecl, semanticInfoChain);
+            var result = {
+                getter: null,
+                setter: null
+            };
+            var getter = accessorSymbol.getGetter();
+            if (getter) {
+                var getterDecl = getter.getDeclarations()[0];
+                result.getter = semanticInfoChain.getASTForDecl(getterDecl);
+            }
+            var setter = accessorSymbol.getSetter();
+            if (setter) {
+                var setterDecl = setter.getDeclarations()[0];
+                result.setter = semanticInfoChain.getASTForDecl(setterDecl);
+            }
+
+            return result;
+        }
+        PullHelpers.getGetterAndSetterFunction = getGetterAndSetterFunction;
+
+        function symbolIsEnum(source) {
+            return source && (source.kind & (64 /* Enum */ | 67108864 /* EnumMember */)) !== 0;
+        }
+        PullHelpers.symbolIsEnum = symbolIsEnum;
+
+        function symbolIsModule(symbol) {
+            return symbol && (symbol.kind === 4 /* Container */ || isOneDeclarationOfKind(symbol, 4 /* Container */));
+        }
+        PullHelpers.symbolIsModule = symbolIsModule;
+
+        function isOneDeclarationOfKind(symbol, kind) {
+            var decls = symbol.getDeclarations();
+            for (var i = 0; i < decls.length; i++) {
+                if (decls[i].kind === kind) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        function isNameNumeric(name) {
+            return isFinite(+name);
+        }
+        PullHelpers.isNameNumeric = isNameNumeric;
+
+        function typeSymbolsAreIdentical(a, b) {
+            if (a.isTypeReference() && !a.getIsSpecialized()) {
+                a = a.referencedTypeSymbol;
+            }
+
+            if (b.isTypeReference() && !b.getIsSpecialized()) {
+                b = b.referencedTypeSymbol;
+            }
+
+            return a === b;
+        }
+        PullHelpers.typeSymbolsAreIdentical = typeSymbolsAreIdentical;
+
+        function getRootType(type) {
+            var rootType = type.getRootSymbol();
+
+            while (true) {
+                if (type === rootType) {
+                    return type;
+                }
+
+                type = rootType;
+                rootType = type.getRootSymbol();
+            }
+        }
+        PullHelpers.getRootType = getRootType;
+
+        function isSymbolLocal(symbol) {
+            var container = symbol.getContainer();
+            if (container) {
+                var containerKind = container.kind;
+                if (containerKind & (1032192 /* SomeFunction */ | 16777216 /* FunctionType */)) {
+                    return true;
+                }
+
+                if (containerKind === 33554432 /* ConstructorType */ && !symbol.anyDeclHasFlag(16 /* Static */ | 1 /* Exported */)) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+        PullHelpers.isSymbolLocal = isSymbolLocal;
+
+        function isExportedSymbolInClodule(symbol) {
+            var container = symbol.getContainer();
+            return container && container.kind === 33554432 /* ConstructorType */ && symbolIsModule(container) && symbol.anyDeclHasFlag(1 /* Exported */);
+        }
+        PullHelpers.isExportedSymbolInClodule = isExportedSymbolInClodule;
+
+        function isSymbolDeclaredInScopeChain(symbol, scopeSymbol) {
+            TypeScript.Debug.assert(symbol);
+            var symbolDeclarationScope = symbol.getContainer();
+
+            while (scopeSymbol) {
+                if (scopeSymbol === symbolDeclarationScope) {
+                    return true;
+                }
+
+                scopeSymbol = scopeSymbol.getContainer();
+            }
+
+            if (scopeSymbol === null && symbolDeclarationScope === null) {
+                return true;
+            }
+
+            return false;
+        }
+        PullHelpers.isSymbolDeclaredInScopeChain = isSymbolDeclaredInScopeChain;
+
+        
+
+        function walkSignatureSymbol(signatureSymbol, walker) {
+            var continueWalk = true;
+            var parameters = signatureSymbol.parameters;
+            if (parameters) {
+                for (var i = 0; continueWalk && i < parameters.length; i++) {
+                    continueWalk = walker.signatureParameterWalk(parameters[i]);
+                }
+            }
+
+            if (continueWalk) {
+                continueWalk = walker.signatureReturnTypeWalk(signatureSymbol.returnType);
+            }
+
+            return continueWalk;
+        }
+
+        function walkPullTypeSymbolStructure(typeSymbol, walker) {
+            var continueWalk = true;
+
+            var members = typeSymbol.getMembers();
+            for (var i = 0; continueWalk && i < members.length; i++) {
+                continueWalk = walker.memberSymbolWalk(members[i]);
+            }
+
+            if (continueWalk) {
+                var callSigantures = typeSymbol.getCallSignatures();
+                for (var i = 0; continueWalk && i < callSigantures.length; i++) {
+                    continueWalk = walker.callSignatureWalk(callSigantures[i]);
+                    if (continueWalk) {
+                        continueWalk = walkSignatureSymbol(callSigantures[i], walker);
+                    }
+                }
+            }
+
+            if (continueWalk) {
+                var constructSignatures = typeSymbol.getConstructSignatures();
+                for (var i = 0; continueWalk && i < constructSignatures.length; i++) {
+                    continueWalk = walker.constructSignatureWalk(constructSignatures[i]);
+                    if (continueWalk) {
+                        continueWalk = walkSignatureSymbol(constructSignatures[i], walker);
+                    }
+                }
+            }
+
+            if (continueWalk) {
+                var indexSignatures = typeSymbol.getIndexSignatures();
+                for (var i = 0; continueWalk && i < indexSignatures.length; i++) {
+                    continueWalk = walker.indexSignatureWalk(indexSignatures[i]);
+                    if (continueWalk) {
+                        continueWalk = walkSignatureSymbol(indexSignatures[i], walker);
+                    }
+                }
+            }
+        }
+        PullHelpers.walkPullTypeSymbolStructure = walkPullTypeSymbolStructure;
+
+        var OtherPullDeclsWalker = (function () {
+            function OtherPullDeclsWalker() {
+                this.currentlyWalkingOtherDecls = [];
+            }
+            OtherPullDeclsWalker.prototype.walkOtherPullDecls = function (currentDecl, otherDecls, callBack) {
+                if (otherDecls) {
+                    var isAlreadyWalkingOtherDecl = TypeScript.ArrayUtilities.any(this.currentlyWalkingOtherDecls, function (inWalkingOtherDecl) {
+                        return TypeScript.ArrayUtilities.contains(otherDecls, inWalkingOtherDecl);
+                    });
+
+                    if (!isAlreadyWalkingOtherDecl) {
+                        this.currentlyWalkingOtherDecls.push(currentDecl);
+                        for (var i = 0; i < otherDecls.length; i++) {
+                            if (otherDecls[i] !== currentDecl) {
+                                callBack(otherDecls[i]);
+                            }
+                        }
+                        var currentlyWalkingOtherDeclsDecl = this.currentlyWalkingOtherDecls.pop();
+                        TypeScript.Debug.assert(currentlyWalkingOtherDeclsDecl == currentDecl);
+                    }
+                }
+            };
+            return OtherPullDeclsWalker;
+        })();
+        PullHelpers.OtherPullDeclsWalker = OtherPullDeclsWalker;
+    })(TypeScript.PullHelpers || (TypeScript.PullHelpers = {}));
+    var PullHelpers = TypeScript.PullHelpers;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var WrapsTypeParameterCache = (function () {
+        function WrapsTypeParameterCache() {
+            this._wrapsTypeParameterCache = TypeScript.BitVector.getBitVector(true);
+        }
+        WrapsTypeParameterCache.prototype.getWrapsTypeParameter = function (typeParameterArgumentMap) {
+            var mapHasTypeParameterNotCached = false;
+            for (var typeParameterID in typeParameterArgumentMap) {
+                if (typeParameterArgumentMap.hasOwnProperty(typeParameterID)) {
+                    var cachedValue = this._wrapsTypeParameterCache.valueAt(typeParameterID);
+                    if (cachedValue) {
+                        return typeParameterID;
+                    }
+                    mapHasTypeParameterNotCached = mapHasTypeParameterNotCached || cachedValue === undefined;
+                }
+            }
+
+            if (!mapHasTypeParameterNotCached) {
+                return 0;
+            }
+
+            return undefined;
+        };
+
+        WrapsTypeParameterCache.prototype.setWrapsTypeParameter = function (typeParameterArgumentMap, wrappingTypeParameterID) {
+            if (wrappingTypeParameterID) {
+                this._wrapsTypeParameterCache.setValueAt(wrappingTypeParameterID, true);
+            } else {
+                for (var typeParameterID in typeParameterArgumentMap) {
+                    if (typeParameterArgumentMap.hasOwnProperty(typeParameterID)) {
+                        this._wrapsTypeParameterCache.setValueAt(typeParameterID, false);
+                    }
+                }
+            }
+        };
+        return WrapsTypeParameterCache;
+    })();
+    TypeScript.WrapsTypeParameterCache = WrapsTypeParameterCache;
+
+    (function (PullInstantiationHelpers) {
+        var MutableTypeArgumentMap = (function () {
+            function MutableTypeArgumentMap(typeParameterArgumentMap) {
+                this.typeParameterArgumentMap = typeParameterArgumentMap;
+                this.createdDuplicateTypeArgumentMap = false;
+            }
+            MutableTypeArgumentMap.prototype.ensureTypeArgumentCopy = function () {
+                if (!this.createdDuplicateTypeArgumentMap) {
+                    var passedInTypeArgumentMap = this.typeParameterArgumentMap;
+                    this.typeParameterArgumentMap = [];
+                    for (var typeParameterID in passedInTypeArgumentMap) {
+                        if (passedInTypeArgumentMap.hasOwnProperty(typeParameterID)) {
+                            this.typeParameterArgumentMap[typeParameterID] = passedInTypeArgumentMap[typeParameterID];
+                        }
+                    }
+                    this.createdDuplicateTypeArgumentMap = true;
+                }
+            };
+            return MutableTypeArgumentMap;
+        })();
+        PullInstantiationHelpers.MutableTypeArgumentMap = MutableTypeArgumentMap;
+
+        function instantiateTypeArgument(resolver, symbol, mutableTypeParameterMap) {
+            if (symbol.getIsSpecialized()) {
+                var rootTypeArgumentMap = symbol.getTypeParameterArgumentMap();
+                var newTypeArgumentMap = [];
+                var allowedTypeParameters = symbol.getAllowedToReferenceTypeParameters();
+                for (var i = 0; i < allowedTypeParameters.length; i++) {
+                    var typeParameterID = allowedTypeParameters[i].pullSymbolID;
+                    var typeArg = rootTypeArgumentMap[typeParameterID];
+                    if (typeArg) {
+                        newTypeArgumentMap[typeParameterID] = resolver.instantiateType(typeArg, mutableTypeParameterMap.typeParameterArgumentMap);
+                    }
+                }
+
+                for (var i = 0; i < allowedTypeParameters.length; i++) {
+                    var typeParameterID = allowedTypeParameters[i].pullSymbolID;
+                    if (newTypeArgumentMap[typeParameterID] && mutableTypeParameterMap.typeParameterArgumentMap[typeParameterID] != newTypeArgumentMap[typeParameterID]) {
+                        mutableTypeParameterMap.ensureTypeArgumentCopy();
+                        mutableTypeParameterMap.typeParameterArgumentMap[typeParameterID] = newTypeArgumentMap[typeParameterID];
+                    }
+                }
+            }
+        }
+        PullInstantiationHelpers.instantiateTypeArgument = instantiateTypeArgument;
+
+        function cleanUpTypeArgumentMap(symbol, mutableTypeArgumentMap) {
+            var allowedToReferenceTypeParameters = symbol.getAllowedToReferenceTypeParameters();
+            for (var typeParameterID in mutableTypeArgumentMap.typeParameterArgumentMap) {
+                if (mutableTypeArgumentMap.typeParameterArgumentMap.hasOwnProperty(typeParameterID)) {
+                    if (!TypeScript.ArrayUtilities.any(allowedToReferenceTypeParameters, function (typeParameter) {
+                        return typeParameter.pullSymbolID == typeParameterID;
+                    })) {
+                        mutableTypeArgumentMap.ensureTypeArgumentCopy();
+                        delete mutableTypeArgumentMap.typeParameterArgumentMap[typeParameterID];
+                    }
+                }
+            }
+        }
+        PullInstantiationHelpers.cleanUpTypeArgumentMap = cleanUpTypeArgumentMap;
+
+        function getAllowedToReferenceTypeParametersFromDecl(decl) {
+            var allowedToReferenceTypeParameters = [];
+
+            var allowedToUseDeclTypeParameters = false;
+            var getTypeParametersFromParentDecl = false;
+
+            switch (decl.kind) {
+                case 65536 /* Method */:
+                    if (TypeScript.hasFlag(decl.flags, 16 /* Static */)) {
+                        allowedToUseDeclTypeParameters = true;
+                        break;
+                    }
+
+                case 16777216 /* FunctionType */:
+                case 33554432 /* ConstructorType */:
+                case 2097152 /* ConstructSignature */:
+                case 1048576 /* CallSignature */:
+                case 131072 /* FunctionExpression */:
+                case 16384 /* Function */:
+                    allowedToUseDeclTypeParameters = true;
+                    getTypeParametersFromParentDecl = true;
+                    break;
+
+                case 4096 /* Property */:
+                    if (TypeScript.hasFlag(decl.flags, 16 /* Static */)) {
+                        break;
+                    }
+
+                case 2048 /* Parameter */:
+                case 262144 /* GetAccessor */:
+                case 524288 /* SetAccessor */:
+                case 32768 /* ConstructorMethod */:
+                case 4194304 /* IndexSignature */:
+                case 8388608 /* ObjectType */:
+                case 256 /* ObjectLiteral */:
+                case 8192 /* TypeParameter */:
+                    getTypeParametersFromParentDecl = true;
+                    break;
+
+                case 8 /* Class */:
+                case 16 /* Interface */:
+                    allowedToUseDeclTypeParameters = true;
+                    break;
+            }
+
+            if (getTypeParametersFromParentDecl) {
+                allowedToReferenceTypeParameters = allowedToReferenceTypeParameters.concat(getAllowedToReferenceTypeParametersFromDecl(decl.getParentDecl()));
+            }
+
+            if (allowedToUseDeclTypeParameters) {
+                var typeParameterDecls = decl.getTypeParameters();
+                for (var i = 0; i < typeParameterDecls.length; i++) {
+                    allowedToReferenceTypeParameters.push(typeParameterDecls[i].getSymbol());
+                }
+            }
+
+            return allowedToReferenceTypeParameters;
+        }
+        PullInstantiationHelpers.getAllowedToReferenceTypeParametersFromDecl = getAllowedToReferenceTypeParametersFromDecl;
+
+        function createTypeParameterArgumentMap(typeParameters, typeArguments) {
+            return updateTypeParameterArgumentMap(typeParameters, typeArguments, {});
+        }
+        PullInstantiationHelpers.createTypeParameterArgumentMap = createTypeParameterArgumentMap;
+
+        function updateTypeParameterArgumentMap(typeParameters, typeArguments, typeParameterArgumentMap) {
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameterArgumentMap[typeParameters[i].getRootSymbol().pullSymbolID] = typeArguments[i];
+            }
+            return typeParameterArgumentMap;
+        }
+        PullInstantiationHelpers.updateTypeParameterArgumentMap = updateTypeParameterArgumentMap;
+
+        function updateMutableTypeParameterArgumentMap(typeParameters, typeArguments, mutableMap) {
+            for (var i = 0; i < typeParameters.length; i++) {
+                var typeParameterId = typeParameters[i].getRootSymbol().pullSymbolID;
+                if (mutableMap.typeParameterArgumentMap[typeParameterId] !== typeArguments[i]) {
+                    mutableMap.ensureTypeArgumentCopy();
+                    mutableMap.typeParameterArgumentMap[typeParameterId] = typeArguments[i];
+                }
+            }
+        }
+        PullInstantiationHelpers.updateMutableTypeParameterArgumentMap = updateMutableTypeParameterArgumentMap;
+
+        function twoTypesAreInstantiationsOfSameNamedGenericType(type1, type2) {
+            var type1IsGeneric = type1.isGeneric() && type1.getTypeArguments() !== null;
+            var type2IsGeneric = type2.isGeneric() && type2.getTypeArguments() !== null;
+
+            if (type1IsGeneric && type2IsGeneric) {
+                var type1Root = TypeScript.PullHelpers.getRootType(type1);
+                var type2Root = TypeScript.PullHelpers.getRootType(type2);
+                return type1Root === type2Root;
+            }
+
+            return false;
+        }
+        PullInstantiationHelpers.twoTypesAreInstantiationsOfSameNamedGenericType = twoTypesAreInstantiationsOfSameNamedGenericType;
+    })(TypeScript.PullInstantiationHelpers || (TypeScript.PullInstantiationHelpers = {}));
+    var PullInstantiationHelpers = TypeScript.PullInstantiationHelpers;
+})(TypeScript || (TypeScript = {}));
+if (Error)
+    Error.stackTraceLimit = 1000;
+
+var TypeScript;
+(function (TypeScript) {
+    TypeScript.fileResolutionTime = 0;
+    TypeScript.fileResolutionIOTime = 0;
+    TypeScript.fileResolutionScanImportsTime = 0;
+    TypeScript.fileResolutionImportFileSearchTime = 0;
+    TypeScript.fileResolutionGetDefaultLibraryTime = 0;
+    TypeScript.sourceCharactersCompiled = 0;
+    TypeScript.syntaxTreeParseTime = 0;
+    TypeScript.syntaxDiagnosticsTime = 0;
+    TypeScript.astTranslationTime = 0;
+    TypeScript.typeCheckTime = 0;
+
+    TypeScript.compilerResolvePathTime = 0;
+    TypeScript.compilerDirectoryNameTime = 0;
+    TypeScript.compilerDirectoryExistsTime = 0;
+    TypeScript.compilerFileExistsTime = 0;
+
+    TypeScript.emitTime = 0;
+    TypeScript.emitWriteFileTime = 0;
+
+    TypeScript.declarationEmitTime = 0;
+    TypeScript.declarationEmitIsExternallyVisibleTime = 0;
+    TypeScript.declarationEmitTypeSignatureTime = 0;
+    TypeScript.declarationEmitGetBoundDeclTypeTime = 0;
+    TypeScript.declarationEmitIsOverloadedCallSignatureTime = 0;
+    TypeScript.declarationEmitFunctionDeclarationGetSymbolTime = 0;
+    TypeScript.declarationEmitGetBaseTypeTime = 0;
+    TypeScript.declarationEmitGetAccessorFunctionTime = 0;
+    TypeScript.declarationEmitGetTypeParameterSymbolTime = 0;
+    TypeScript.declarationEmitGetImportDeclarationSymbolTime = 0;
+
+    TypeScript.ioHostResolvePathTime = 0;
+    TypeScript.ioHostDirectoryNameTime = 0;
+    TypeScript.ioHostCreateDirectoryStructureTime = 0;
+    TypeScript.ioHostWriteFileTime = 0;
+
+    (function (EmitOutputResult) {
+        EmitOutputResult[EmitOutputResult["Succeeded"] = 0] = "Succeeded";
+        EmitOutputResult[EmitOutputResult["FailedBecauseOfSyntaxErrors"] = 1] = "FailedBecauseOfSyntaxErrors";
+        EmitOutputResult[EmitOutputResult["FailedBecauseOfCompilerOptionsErrors"] = 2] = "FailedBecauseOfCompilerOptionsErrors";
+        EmitOutputResult[EmitOutputResult["FailedToGenerateDeclarationsBecauseOfSemanticErrors"] = 3] = "FailedToGenerateDeclarationsBecauseOfSemanticErrors";
+    })(TypeScript.EmitOutputResult || (TypeScript.EmitOutputResult = {}));
+    var EmitOutputResult = TypeScript.EmitOutputResult;
+
+    var EmitOutput = (function () {
+        function EmitOutput(emitOutputResult) {
+            if (typeof emitOutputResult === "undefined") { emitOutputResult = 0 /* Succeeded */; }
+            this.outputFiles = [];
+            this.emitOutputResult = emitOutputResult;
+        }
+        return EmitOutput;
+    })();
+    TypeScript.EmitOutput = EmitOutput;
+
+    (function (OutputFileType) {
+        OutputFileType[OutputFileType["JavaScript"] = 0] = "JavaScript";
+        OutputFileType[OutputFileType["SourceMap"] = 1] = "SourceMap";
+        OutputFileType[OutputFileType["Declaration"] = 2] = "Declaration";
+    })(TypeScript.OutputFileType || (TypeScript.OutputFileType = {}));
+    var OutputFileType = TypeScript.OutputFileType;
+
+    var OutputFile = (function () {
+        function OutputFile(name, writeByteOrderMark, text, fileType, sourceMapEntries) {
+            if (typeof sourceMapEntries === "undefined") { sourceMapEntries = []; }
+            this.name = name;
+            this.writeByteOrderMark = writeByteOrderMark;
+            this.text = text;
+            this.fileType = fileType;
+            this.sourceMapEntries = sourceMapEntries;
+        }
+        return OutputFile;
+    })();
+    TypeScript.OutputFile = OutputFile;
+
+    var CompileResult = (function () {
+        function CompileResult() {
+            this.diagnostics = [];
+            this.outputFiles = [];
+        }
+        CompileResult.fromDiagnostics = function (diagnostics) {
+            var result = new CompileResult();
+            result.diagnostics = diagnostics;
+            return result;
+        };
+
+        CompileResult.fromOutputFiles = function (outputFiles) {
+            var result = new CompileResult();
+            result.outputFiles = outputFiles;
+            return result;
+        };
+        return CompileResult;
+    })();
+    TypeScript.CompileResult = CompileResult;
+
+    var TypeScriptCompiler = (function () {
+        function TypeScriptCompiler(logger, _settings) {
+            if (typeof logger === "undefined") { logger = new TypeScript.NullLogger(); }
+            if (typeof _settings === "undefined") { _settings = TypeScript.ImmutableCompilationSettings.defaultSettings(); }
+            this.logger = logger;
+            this._settings = _settings;
+            this.semanticInfoChain = null;
+            this.semanticInfoChain = new TypeScript.SemanticInfoChain(this, logger);
+        }
+        TypeScriptCompiler.prototype.compilationSettings = function () {
+            return this._settings;
+        };
+
+        TypeScriptCompiler.prototype.setCompilationSettings = function (newSettings) {
+            var oldSettings = this._settings;
+            this._settings = newSettings;
+
+            if (!compareDataObjects(oldSettings, newSettings)) {
+                this.semanticInfoChain.invalidate(oldSettings, newSettings);
+            }
+        };
+
+        TypeScriptCompiler.prototype.getDocument = function (fileName) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+            return this.semanticInfoChain.getDocument(fileName);
+        };
+
+        TypeScriptCompiler.prototype.cleanupSemanticCache = function () {
+            this.semanticInfoChain.invalidate();
+        };
+
+        TypeScriptCompiler.prototype.addFile = function (fileName, scriptSnapshot, byteOrderMark, version, isOpen, referencedFiles) {
+            if (typeof referencedFiles === "undefined") { referencedFiles = []; }
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+
+            TypeScript.sourceCharactersCompiled += scriptSnapshot.getLength();
+
+            var document = TypeScript.Document.create(this, this.semanticInfoChain, fileName, scriptSnapshot, byteOrderMark, version, isOpen, referencedFiles);
+
+            this.semanticInfoChain.addDocument(document);
+        };
+
+        TypeScriptCompiler.prototype.updateFile = function (fileName, scriptSnapshot, version, isOpen, textChangeRange) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+
+            var document = this.getDocument(fileName);
+            var updatedDocument = document.update(scriptSnapshot, version, isOpen, textChangeRange);
+
+            this.semanticInfoChain.addDocument(updatedDocument);
+        };
+
+        TypeScriptCompiler.prototype.removeFile = function (fileName) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+            this.semanticInfoChain.removeDocument(fileName);
+        };
+
+        TypeScriptCompiler.prototype.mapOutputFileName = function (document, emitOptions, extensionChanger) {
+            if (document.emitToOwnOutputFile()) {
+                var updatedFileName = document.fileName;
+                if (emitOptions.outputDirectory() !== "") {
+                    updatedFileName = document.fileName.replace(emitOptions.commonDirectoryPath(), "");
+                    updatedFileName = emitOptions.outputDirectory() + updatedFileName;
+                }
+                return extensionChanger(updatedFileName, false);
+            } else {
+                return extensionChanger(emitOptions.sharedOutputFile(), true);
+            }
+        };
+
+        TypeScriptCompiler.prototype.writeByteOrderMarkForDocument = function (document) {
+            var printReason = false;
+
+            if (document.emitToOwnOutputFile()) {
+                var result = document.byteOrderMark !== 0 /* None */;
+                if (printReason) {
+                    TypeScript.Environment.standardOut.WriteLine("Emitting byte order mark because of: " + document.fileName);
+                }
+                return result;
+            } else {
+                var fileNames = this.fileNames();
+
+                var result = false;
+                for (var i = 0, n = fileNames.length; i < n; i++) {
+                    var document = this.getDocument(fileNames[i]);
+
+                    if (document.isExternalModule()) {
+                        continue;
+                    }
+
+                    if (document.byteOrderMark !== 0 /* None */) {
+                        if (printReason) {
+                            TypeScript.Environment.standardOut.WriteLine("Emitting byte order mark because of: " + document.fileName);
+                            result = true;
+                        } else {
+                            return true;
+                        }
+                    }
+                }
+
+                return result;
+            }
+        };
+
+        TypeScriptCompiler.mapToDTSFileName = function (fileName, wholeFileNameReplaced) {
+            return TypeScript.getDeclareFilePath(fileName);
+        };
+
+        TypeScriptCompiler.prototype._shouldEmit = function (document) {
+            return !document.isDeclareFile();
+        };
+
+        TypeScriptCompiler.prototype._shouldEmitDeclarations = function (document) {
+            if (!this.compilationSettings().generateDeclarationFiles()) {
+                return false;
+            }
+
+            return this._shouldEmit(document);
+        };
+
+        TypeScriptCompiler.prototype.emitDocumentDeclarationsWorker = function (document, emitOptions, declarationEmitter) {
+            var sourceUnit = document.sourceUnit();
+            TypeScript.Debug.assert(this._shouldEmitDeclarations(document));
+
+            if (declarationEmitter) {
+                declarationEmitter.document = document;
+            } else {
+                var declareFileName = this.mapOutputFileName(document, emitOptions, TypeScriptCompiler.mapToDTSFileName);
+                declarationEmitter = new TypeScript.DeclarationEmitter(declareFileName, document, this, emitOptions, this.semanticInfoChain);
+            }
+
+            declarationEmitter.emitDeclarations(sourceUnit);
+            return declarationEmitter;
+        };
+
+        TypeScriptCompiler.prototype._emitDocumentDeclarations = function (document, emitOptions, onSingleFileEmitComplete, sharedEmitter) {
+            if (this._shouldEmitDeclarations(document)) {
+                if (document.emitToOwnOutputFile()) {
+                    var singleEmitter = this.emitDocumentDeclarationsWorker(document, emitOptions);
+                    if (singleEmitter) {
+                        onSingleFileEmitComplete(singleEmitter.getOutputFile());
+                    }
+                } else {
+                    sharedEmitter = this.emitDocumentDeclarationsWorker(document, emitOptions, sharedEmitter);
+                }
+            }
+
+            return sharedEmitter;
+        };
+
+        TypeScriptCompiler.prototype.emitAllDeclarations = function (resolvePath) {
+            var start = new Date().getTime();
+            var emitOutput = new EmitOutput();
+
+            var emitOptions = new TypeScript.EmitOptions(this, resolvePath);
+            if (emitOptions.diagnostic()) {
+                emitOutput.emitOutputResult = 2 /* FailedBecauseOfCompilerOptionsErrors */;
+                return emitOutput;
+            }
+
+            var sharedEmitter = null;
+            var fileNames = this.fileNames();
+
+            for (var i = 0, n = fileNames.length; i < n; i++) {
+                var fileName = fileNames[i];
+
+                var document = this.getDocument(fileNames[i]);
+
+                sharedEmitter = this._emitDocumentDeclarations(document, emitOptions, function (file) {
+                    return emitOutput.outputFiles.push(file);
+                }, sharedEmitter);
+            }
+
+            if (sharedEmitter) {
+                emitOutput.outputFiles.push(sharedEmitter.getOutputFile());
+            }
+
+            TypeScript.declarationEmitTime += new Date().getTime() - start;
+
+            return emitOutput;
+        };
+
+        TypeScriptCompiler.prototype.emitDeclarations = function (fileName, resolvePath) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+            var emitOutput = new EmitOutput();
+
+            var emitOptions = new TypeScript.EmitOptions(this, resolvePath);
+            if (emitOptions.diagnostic()) {
+                emitOutput.emitOutputResult = 2 /* FailedBecauseOfCompilerOptionsErrors */;
+                return emitOutput;
+            }
+
+            var document = this.getDocument(fileName);
+
+            if (document.emitToOwnOutputFile()) {
+                this._emitDocumentDeclarations(document, emitOptions, function (file) {
+                    return emitOutput.outputFiles.push(file);
+                }, null);
+                return emitOutput;
+            } else {
+                return this.emitAllDeclarations(resolvePath);
+            }
+        };
+
+        TypeScriptCompiler.prototype.canEmitDeclarations = function (fileName) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+            var document = this.getDocument(fileName);
+            return this._shouldEmitDeclarations(document);
+        };
+
+        TypeScriptCompiler.mapToFileNameExtension = function (extension, fileName, wholeFileNameReplaced) {
+            if (wholeFileNameReplaced) {
+                return fileName;
+            } else {
+                var splitFname = fileName.split(".");
+                splitFname.pop();
+                return splitFname.join(".") + extension;
+            }
+        };
+
+        TypeScriptCompiler.mapToJSFileName = function (fileName, wholeFileNameReplaced) {
+            return TypeScriptCompiler.mapToFileNameExtension(".js", fileName, wholeFileNameReplaced);
+        };
+
+        TypeScriptCompiler.prototype.emitDocumentWorker = function (document, emitOptions, emitter) {
+            var sourceUnit = document.sourceUnit();
+            TypeScript.Debug.assert(this._shouldEmit(document));
+
+            var typeScriptFileName = document.fileName;
+            if (!emitter) {
+                var javaScriptFileName = this.mapOutputFileName(document, emitOptions, TypeScriptCompiler.mapToJSFileName);
+                var outFile = new TypeScript.TextWriter(javaScriptFileName, this.writeByteOrderMarkForDocument(document), 0 /* JavaScript */);
+
+                emitter = new TypeScript.Emitter(javaScriptFileName, outFile, emitOptions, this.semanticInfoChain);
+
+                if (this.compilationSettings().mapSourceFiles()) {
+                    var sourceMapFile = new TypeScript.TextWriter(javaScriptFileName + TypeScript.SourceMapper.MapFileExtension, false, 1 /* SourceMap */);
+                    emitter.createSourceMapper(document, javaScriptFileName, outFile, sourceMapFile, emitOptions.resolvePath);
+                }
+            } else if (this.compilationSettings().mapSourceFiles()) {
+                emitter.setSourceMapperNewSourceFile(document);
+            }
+
+            emitter.setDocument(document);
+            emitter.emitJavascript(sourceUnit, false);
+
+            return emitter;
+        };
+
+        TypeScriptCompiler.prototype._emitDocument = function (document, emitOptions, onSingleFileEmitComplete, sharedEmitter) {
+            if (this._shouldEmit(document)) {
+                if (document.emitToOwnOutputFile()) {
+                    var singleEmitter = this.emitDocumentWorker(document, emitOptions);
+                    if (singleEmitter) {
+                        onSingleFileEmitComplete(singleEmitter.getOutputFiles());
+                    }
+                } else {
+                    sharedEmitter = this.emitDocumentWorker(document, emitOptions, sharedEmitter);
+                }
+            }
+
+            return sharedEmitter;
+        };
+
+        TypeScriptCompiler.prototype.emitAll = function (resolvePath) {
+            var start = new Date().getTime();
+            var emitOutput = new EmitOutput();
+
+            var emitOptions = new TypeScript.EmitOptions(this, resolvePath);
+            if (emitOptions.diagnostic()) {
+                emitOutput.emitOutputResult = 2 /* FailedBecauseOfCompilerOptionsErrors */;
+                return emitOutput;
+            }
+
+            var fileNames = this.fileNames();
+            var sharedEmitter = null;
+
+            for (var i = 0, n = fileNames.length; i < n; i++) {
+                var fileName = fileNames[i];
+
+                var document = this.getDocument(fileName);
+
+                sharedEmitter = this._emitDocument(document, emitOptions, function (files) {
+                    return emitOutput.outputFiles.push.apply(emitOutput.outputFiles, files);
+                }, sharedEmitter);
+            }
+
+            if (sharedEmitter) {
+                emitOutput.outputFiles.push.apply(emitOutput.outputFiles, sharedEmitter.getOutputFiles());
+            }
+
+            TypeScript.emitTime += new Date().getTime() - start;
+            return emitOutput;
+        };
+
+        TypeScriptCompiler.prototype.emit = function (fileName, resolvePath) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+            var emitOutput = new EmitOutput();
+
+            var emitOptions = new TypeScript.EmitOptions(this, resolvePath);
+            if (emitOptions.diagnostic()) {
+                emitOutput.emitOutputResult = 2 /* FailedBecauseOfCompilerOptionsErrors */;
+                return emitOutput;
+            }
+
+            var document = this.getDocument(fileName);
+
+            if (document.emitToOwnOutputFile()) {
+                this._emitDocument(document, emitOptions, function (files) {
+                    return emitOutput.outputFiles.push.apply(emitOutput.outputFiles, files);
+                }, null);
+                return emitOutput;
+            } else {
+                return this.emitAll(resolvePath);
+            }
+        };
+
+        TypeScriptCompiler.prototype.compile = function (resolvePath, continueOnDiagnostics) {
+            if (typeof continueOnDiagnostics === "undefined") { continueOnDiagnostics = false; }
+            return new CompilerIterator(this, resolvePath, continueOnDiagnostics);
+        };
+
+        TypeScriptCompiler.prototype.getSyntacticDiagnostics = function (fileName) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+            return this.getDocument(fileName).diagnostics();
+        };
+
+        TypeScriptCompiler.prototype.getSyntaxTree = function (fileName) {
+            return this.getDocument(fileName).syntaxTree();
+        };
+
+        TypeScriptCompiler.prototype.getSourceUnit = function (fileName) {
+            return this.getDocument(fileName).sourceUnit();
+        };
+
+        TypeScriptCompiler.prototype.getSemanticDiagnostics = function (fileName) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+
+            var document = this.getDocument(fileName);
+
+            var startTime = (new Date()).getTime();
+            TypeScript.PullTypeResolver.typeCheck(this.compilationSettings(), this.semanticInfoChain, document);
+            var endTime = (new Date()).getTime();
+
+            TypeScript.typeCheckTime += endTime - startTime;
+
+            var errors = this.semanticInfoChain.getDiagnostics(fileName);
+
+            errors = TypeScript.ArrayUtilities.distinct(errors, TypeScript.Diagnostic.equals);
+            errors.sort(function (d1, d2) {
+                if (d1.fileName() < d2.fileName()) {
+                    return -1;
+                } else if (d1.fileName() > d2.fileName()) {
+                    return 1;
+                }
+
+                if (d1.start() < d2.start()) {
+                    return -1;
+                } else if (d1.start() > d2.start()) {
+                    return 1;
+                }
+
+                var code1 = TypeScript.diagnosticInformationMap[d1.diagnosticKey()].code;
+                var code2 = TypeScript.diagnosticInformationMap[d2.diagnosticKey()].code;
+                if (code1 < code2) {
+                    return -1;
+                } else if (code1 > code2) {
+                    return 1;
+                }
+
+                return 0;
+            });
+
+            return errors;
+        };
+
+        TypeScriptCompiler.prototype.getCompilerOptionsDiagnostics = function (resolvePath) {
+            var emitOptions = new TypeScript.EmitOptions(this, resolvePath);
+            var emitDiagnostic = emitOptions.diagnostic();
+            if (emitDiagnostic) {
+                return [emitDiagnostic];
+            }
+            return TypeScript.sentinelEmptyArray;
+        };
+
+        TypeScriptCompiler.prototype.resolveAllFiles = function () {
+            var fileNames = this.fileNames();
+            for (var i = 0, n = fileNames.length; i < n; i++) {
+                this.getSemanticDiagnostics(fileNames[i]);
+            }
+        };
+
+        TypeScriptCompiler.prototype.getSymbolOfDeclaration = function (decl) {
+            if (!decl) {
+                return null;
+            }
+
+            var resolver = this.semanticInfoChain.getResolver();
+            var ast = this.semanticInfoChain.getASTForDecl(decl);
+            if (!ast) {
+                return null;
+            }
+
+            var enclosingDecl = resolver.getEnclosingDecl(decl);
+            if (ast.kind() === 139 /* GetAccessor */ || ast.kind() === 140 /* SetAccessor */) {
+                return this.getSymbolOfDeclaration(enclosingDecl);
+            }
+
+            return resolver.resolveAST(ast, false, new TypeScript.PullTypeResolutionContext(resolver));
+        };
+
+        TypeScriptCompiler.prototype.extractResolutionContextFromAST = function (resolver, ast, document, propagateContextualTypes) {
+            var scriptName = document.fileName;
+
+            var enclosingDecl = null;
+            var enclosingDeclAST = null;
+            var inContextuallyTypedAssignment = false;
+            var inWithBlock = false;
+
+            var resolutionContext = new TypeScript.PullTypeResolutionContext(resolver);
+
+            if (!ast) {
+                return null;
+            }
+
+            var path = this.getASTPath(ast);
+
+            for (var i = 0, n = path.length; i < n; i++) {
+                var current = path[i];
+
+                switch (current.kind()) {
+                    case 222 /* FunctionExpression */:
+                    case 219 /* SimpleArrowFunctionExpression */:
+                    case 218 /* ParenthesizedArrowFunctionExpression */:
+                        if (propagateContextualTypes) {
+                            resolver.resolveAST(current, true, resolutionContext);
+                        }
+                        break;
+
+                    case 136 /* MemberVariableDeclaration */:
+                        var memberVariable = current;
+                        inContextuallyTypedAssignment = memberVariable.variableDeclarator.typeAnnotation !== null;
+
+                        this.extractResolutionContextForVariable(inContextuallyTypedAssignment, propagateContextualTypes, resolver, resolutionContext, enclosingDecl, memberVariable, memberVariable.variableDeclarator.equalsValueClause);
+                        break;
+
+                    case 225 /* VariableDeclarator */:
+                        var variableDeclarator = current;
+                        inContextuallyTypedAssignment = variableDeclarator.typeAnnotation !== null;
+
+                        this.extractResolutionContextForVariable(inContextuallyTypedAssignment, propagateContextualTypes, resolver, resolutionContext, enclosingDecl, variableDeclarator, variableDeclarator.equalsValueClause);
+                        break;
+
+                    case 213 /* InvocationExpression */:
+                    case 216 /* ObjectCreationExpression */:
+                        if (propagateContextualTypes) {
+                            var isNew = current.kind() === 216 /* ObjectCreationExpression */;
+                            var callExpression = current;
+                            var contextualType = null;
+
+                            if ((i + 2 < n) && callExpression.argumentList === path[i + 1] && callExpression.argumentList.arguments === path[i + 2]) {
+                                var callResolutionResults = new TypeScript.PullAdditionalCallResolutionData();
+                                if (isNew) {
+                                    resolver.resolveObjectCreationExpression(callExpression, resolutionContext, callResolutionResults);
+                                } else {
+                                    resolver.resolveInvocationExpression(callExpression, resolutionContext, callResolutionResults);
+                                }
+
+                                if (callResolutionResults.actualParametersContextTypeSymbols) {
+                                    var argExpression = path[i + 3];
+                                    if (argExpression) {
+                                        for (var j = 0, m = callExpression.argumentList.arguments.nonSeparatorCount(); j < m; j++) {
+                                            if (callExpression.argumentList.arguments.nonSeparatorAt(j) === argExpression) {
+                                                var callContextualType = callResolutionResults.actualParametersContextTypeSymbols[j];
+                                                if (callContextualType) {
+                                                    contextualType = callContextualType;
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            } else {
+                                if (isNew) {
+                                    resolver.resolveObjectCreationExpression(callExpression, resolutionContext);
+                                } else {
+                                    resolver.resolveInvocationExpression(callExpression, resolutionContext);
+                                }
+                            }
+
+                            resolutionContext.pushNewContextualType(contextualType);
+                        }
+
+                        break;
+
+                    case 214 /* ArrayLiteralExpression */:
+                        if (propagateContextualTypes) {
+                            var contextualType = null;
+                            var currentContextualType = resolutionContext.getContextualType();
+                            if (currentContextualType && currentContextualType.isArrayNamedTypeReference()) {
+                                contextualType = currentContextualType.getElementType();
+                            }
+
+                            resolutionContext.pushNewContextualType(contextualType);
+                        }
+
+                        break;
+
+                    case 215 /* ObjectLiteralExpression */:
+                        if (propagateContextualTypes) {
+                            var objectLiteralExpression = current;
+                            var objectLiteralResolutionContext = new TypeScript.PullAdditionalObjectLiteralResolutionData();
+                            resolver.resolveObjectLiteralExpression(objectLiteralExpression, inContextuallyTypedAssignment, resolutionContext, objectLiteralResolutionContext);
+
+                            var memeberAST = (path[i + 1] && path[i + 1].kind() === 2 /* SeparatedList */) ? path[i + 2] : path[i + 1];
+                            if (memeberAST) {
+                                var contextualType = null;
+                                var memberDecls = objectLiteralExpression.propertyAssignments;
+                                if (memberDecls && objectLiteralResolutionContext.membersContextTypeSymbols) {
+                                    for (var j = 0, m = memberDecls.nonSeparatorCount(); j < m; j++) {
+                                        if (memberDecls.nonSeparatorAt(j) === memeberAST) {
+                                            var memberContextualType = objectLiteralResolutionContext.membersContextTypeSymbols[j];
+                                            if (memberContextualType) {
+                                                contextualType = memberContextualType;
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+
+                                resolutionContext.pushNewContextualType(contextualType);
+                            }
+                        }
+
+                        break;
+
+                    case 174 /* AssignmentExpression */:
+                        if (propagateContextualTypes) {
+                            var assignmentExpression = current;
+                            var contextualType = null;
+
+                            if (path[i + 1] && path[i + 1] === assignmentExpression.right) {
+                                var leftType = resolver.resolveAST(assignmentExpression.left, inContextuallyTypedAssignment, resolutionContext).type;
+                                if (leftType) {
+                                    inContextuallyTypedAssignment = true;
+                                    contextualType = leftType;
+                                }
+                            }
+
+                            resolutionContext.pushNewContextualType(contextualType);
+                        }
+
+                        break;
+
+                    case 220 /* CastExpression */:
+                        var castExpression = current;
+                        if (!(i + 1 < n && path[i + 1] === castExpression.type)) {
+                            if (propagateContextualTypes) {
+                                var contextualType = null;
+                                var typeSymbol = resolver.resolveAST(castExpression, inContextuallyTypedAssignment, resolutionContext).type;
+
+                                if (typeSymbol) {
+                                    inContextuallyTypedAssignment = true;
+                                    contextualType = typeSymbol;
+                                }
+
+                                resolutionContext.pushNewContextualType(contextualType);
+                            }
+                        }
+
+                        break;
+
+                    case 150 /* ReturnStatement */:
+                        if (propagateContextualTypes) {
+                            var returnStatement = current;
+                            var contextualType = null;
+
+                            if (enclosingDecl && (enclosingDecl.kind & 1032192 /* SomeFunction */)) {
+                                var typeAnnotation = TypeScript.ASTHelpers.getType(enclosingDeclAST);
+                                if (typeAnnotation) {
+                                    var returnTypeSymbol = resolver.resolveTypeReference(typeAnnotation, resolutionContext);
+                                    if (returnTypeSymbol) {
+                                        inContextuallyTypedAssignment = true;
+                                        contextualType = returnTypeSymbol;
+                                    }
+                                } else {
+                                    var currentContextualType = resolutionContext.getContextualType();
+                                    if (currentContextualType && currentContextualType.isFunction()) {
+                                        var contextualSignatures = currentContextualType.kind == 33554432 /* ConstructorType */ ? currentContextualType.getConstructSignatures() : currentContextualType.getCallSignatures();
+                                        var currentContextualTypeSignatureSymbol = contextualSignatures[0];
+                                        var currentContextualTypeReturnTypeSymbol = currentContextualTypeSignatureSymbol.returnType;
+                                        if (currentContextualTypeReturnTypeSymbol) {
+                                            inContextuallyTypedAssignment = true;
+                                            contextualType = currentContextualTypeReturnTypeSymbol;
+                                        }
+                                    }
+                                }
+                            }
+
+                            resolutionContext.pushNewContextualType(contextualType);
+                        }
+
+                        break;
+
+                    case 122 /* ObjectType */:
+                        if (propagateContextualTypes && TypeScript.isTypesOnlyLocation(current)) {
+                            resolver.resolveAST(current, false, resolutionContext);
+                        }
+
+                        break;
+
+                    case 163 /* WithStatement */:
+                        inWithBlock = true;
+                        break;
+
+                    case 146 /* Block */:
+                        inContextuallyTypedAssignment = false;
+                        break;
+                }
+
+                var decl = this.semanticInfoChain.getDeclForAST(current);
+                if (decl) {
+                    enclosingDecl = decl;
+                    enclosingDeclAST = current;
+                }
+            }
+
+            if (ast && ast.parent && ast.kind() === 11 /* IdentifierName */) {
+                if (ast.parent.kind() === 212 /* MemberAccessExpression */) {
+                    if (ast.parent.name === ast) {
+                        ast = ast.parent;
+                    }
+                } else if (ast.parent.kind() === 121 /* QualifiedName */) {
+                    if (ast.parent.right === ast) {
+                        ast = ast.parent;
+                    }
+                }
+            }
+
+            return {
+                ast: ast,
+                enclosingDecl: enclosingDecl,
+                resolutionContext: resolutionContext,
+                inContextuallyTypedAssignment: inContextuallyTypedAssignment,
+                inWithBlock: inWithBlock
+            };
+        };
+
+        TypeScriptCompiler.prototype.extractResolutionContextForVariable = function (inContextuallyTypedAssignment, propagateContextualTypes, resolver, resolutionContext, enclosingDecl, assigningAST, init) {
+            if (inContextuallyTypedAssignment) {
+                if (propagateContextualTypes) {
+                    resolver.resolveAST(assigningAST, false, resolutionContext);
+                    var varSymbol = this.semanticInfoChain.getSymbolForAST(assigningAST);
+
+                    var contextualType = null;
+                    if (varSymbol && inContextuallyTypedAssignment) {
+                        contextualType = varSymbol.type;
+                    }
+
+                    resolutionContext.pushNewContextualType(contextualType);
+
+                    if (init) {
+                        resolver.resolveAST(init, inContextuallyTypedAssignment, resolutionContext);
+                    }
+                }
+            }
+        };
+
+        TypeScriptCompiler.prototype.getASTPath = function (ast) {
+            var result = [];
+
+            while (ast) {
+                result.unshift(ast);
+                ast = ast.parent;
+            }
+
+            return result;
+        };
+
+        TypeScriptCompiler.prototype.pullGetSymbolInformationFromAST = function (ast, document) {
+            var resolver = this.semanticInfoChain.getResolver();
+            var context = this.extractResolutionContextFromAST(resolver, ast, document, true);
+            if (!context || context.inWithBlock) {
+                return null;
+            }
+
+            ast = context.ast;
+            var symbol = resolver.resolveAST(ast, context.inContextuallyTypedAssignment, context.resolutionContext);
+
+            if (!symbol) {
+                TypeScript.Debug.assert(ast.kind() === 120 /* SourceUnit */, "No symbol was found for ast and ast was not source unit. Ast Kind: " + TypeScript.SyntaxKind[ast.kind()]);
+                return null;
+            }
+
+            if (symbol.isTypeReference()) {
+                symbol = symbol.getReferencedTypeSymbol();
+            }
+
+            var aliasSymbol = this.semanticInfoChain.getAliasSymbolForAST(ast);
+
+            return {
+                symbol: symbol,
+                aliasSymbol: aliasSymbol,
+                ast: ast,
+                enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl)
+            };
+        };
+
+        TypeScriptCompiler.prototype.pullGetCallInformationFromAST = function (ast, document) {
+            if (ast.kind() !== 213 /* InvocationExpression */ && ast.kind() !== 216 /* ObjectCreationExpression */) {
+                return null;
+            }
+
+            var isNew = ast.kind() === 216 /* ObjectCreationExpression */;
+
+            var resolver = this.semanticInfoChain.getResolver();
+            var context = this.extractResolutionContextFromAST(resolver, ast, document, true);
+            if (!context || context.inWithBlock) {
+                return null;
+            }
+
+            var callResolutionResults = new TypeScript.PullAdditionalCallResolutionData();
+
+            if (isNew) {
+                resolver.resolveObjectCreationExpression(ast, context.resolutionContext, callResolutionResults);
+            } else {
+                resolver.resolveInvocationExpression(ast, context.resolutionContext, callResolutionResults);
+            }
+
+            return {
+                targetSymbol: callResolutionResults.targetSymbol,
+                resolvedSignatures: callResolutionResults.resolvedSignatures,
+                candidateSignature: callResolutionResults.candidateSignature,
+                ast: ast,
+                enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl),
+                isConstructorCall: isNew
+            };
+        };
+
+        TypeScriptCompiler.prototype.pullGetVisibleMemberSymbolsFromAST = function (ast, document) {
+            var resolver = this.semanticInfoChain.getResolver();
+            var context = this.extractResolutionContextFromAST(resolver, ast, document, true);
+            if (!context || context.inWithBlock) {
+                return null;
+            }
+
+            var symbols = resolver.getVisibleMembersFromExpression(ast, context.enclosingDecl, context.resolutionContext);
+            if (!symbols) {
+                return null;
+            }
+
+            return {
+                symbols: symbols,
+                enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl)
+            };
+        };
+
+        TypeScriptCompiler.prototype.pullGetVisibleDeclsFromAST = function (ast, document) {
+            var resolver = this.semanticInfoChain.getResolver();
+            var context = this.extractResolutionContextFromAST(resolver, ast, document, false);
+            if (!context || context.inWithBlock) {
+                return null;
+            }
+
+            return resolver.getVisibleDecls(context.enclosingDecl);
+        };
+
+        TypeScriptCompiler.prototype.pullGetContextualMembersFromAST = function (ast, document) {
+            if (ast.kind() !== 215 /* ObjectLiteralExpression */) {
+                return null;
+            }
+
+            var resolver = this.semanticInfoChain.getResolver();
+            var context = this.extractResolutionContextFromAST(resolver, ast, document, true);
+            if (!context || context.inWithBlock) {
+                return null;
+            }
+
+            var members = resolver.getVisibleContextSymbols(context.enclosingDecl, context.resolutionContext);
+
+            return {
+                symbols: members,
+                enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl)
+            };
+        };
+
+        TypeScriptCompiler.prototype.pullGetDeclInformation = function (decl, ast, document) {
+            var resolver = this.semanticInfoChain.getResolver();
+
+            var context = this.extractResolutionContextFromAST(resolver, ast, document, true);
+            if (!context || context.inWithBlock) {
+                return null;
+            }
+
+            var astForDecl = decl.ast();
+            if (!astForDecl) {
+                return null;
+            }
+
+            var astForDeclContext = this.extractResolutionContextFromAST(resolver, astForDecl, this.getDocument(astForDecl.fileName()), true);
+            if (!astForDeclContext) {
+                return null;
+            }
+
+            var symbol = decl.getSymbol();
+            resolver.resolveDeclaredSymbol(symbol, context.resolutionContext);
+            symbol.setUnresolved();
+
+            return {
+                symbol: symbol,
+                aliasSymbol: null,
+                ast: ast,
+                enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl)
+            };
+        };
+
+        TypeScriptCompiler.prototype.topLevelDeclaration = function (fileName) {
+            return this.semanticInfoChain.topLevelDecl(fileName);
+        };
+
+        TypeScriptCompiler.prototype.getDeclForAST = function (ast) {
+            return this.semanticInfoChain.getDeclForAST(ast);
+        };
+
+        TypeScriptCompiler.prototype.fileNames = function () {
+            return this.semanticInfoChain.fileNames();
+        };
+
+        TypeScriptCompiler.prototype.topLevelDecl = function (fileName) {
+            return this.semanticInfoChain.topLevelDecl(fileName);
+        };
+
+        TypeScriptCompiler.getLocationText = function (location) {
+            return location.fileName() + "(" + (location.line() + 1) + "," + (location.character() + 1) + ")";
+        };
+
+        TypeScriptCompiler.getFullDiagnosticText = function (diagnostic) {
+            var result = "";
+            if (diagnostic.fileName()) {
+                result += this.getLocationText(diagnostic) + ": ";
+            }
+
+            result += diagnostic.message();
+
+            var additionalLocations = diagnostic.additionalLocations();
+            if (additionalLocations.length > 0) {
+                result += " " + TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Additional_locations, null) + TypeScript.Environment.newLine;
+
+                for (var i = 0, n = additionalLocations.length; i < n; i++) {
+                    result += "\t" + this.getLocationText(additionalLocations[i]) + TypeScript.Environment.newLine;
+                }
+            } else {
+                result += TypeScript.Environment.newLine;
+            }
+
+            return result;
+        };
+        return TypeScriptCompiler;
+    })();
+    TypeScript.TypeScriptCompiler = TypeScriptCompiler;
+
+    var CompilerPhase;
+    (function (CompilerPhase) {
+        CompilerPhase[CompilerPhase["Syntax"] = 0] = "Syntax";
+        CompilerPhase[CompilerPhase["Semantics"] = 1] = "Semantics";
+        CompilerPhase[CompilerPhase["EmitOptionsValidation"] = 2] = "EmitOptionsValidation";
+        CompilerPhase[CompilerPhase["Emit"] = 3] = "Emit";
+        CompilerPhase[CompilerPhase["DeclarationEmit"] = 4] = "DeclarationEmit";
+    })(CompilerPhase || (CompilerPhase = {}));
+
+    var CompilerIterator = (function () {
+        function CompilerIterator(compiler, resolvePath, continueOnDiagnostics, startingPhase) {
+            if (typeof startingPhase === "undefined") { startingPhase = 0 /* Syntax */; }
+            this.compiler = compiler;
+            this.resolvePath = resolvePath;
+            this.continueOnDiagnostics = continueOnDiagnostics;
+            this.index = -1;
+            this.fileNames = null;
+            this._current = null;
+            this._emitOptions = null;
+            this._sharedEmitter = null;
+            this._sharedDeclarationEmitter = null;
+            this.hadSyntacticDiagnostics = false;
+            this.hadSemanticDiagnostics = false;
+            this.hadEmitDiagnostics = false;
+            this.fileNames = compiler.fileNames();
+            this.compilerPhase = startingPhase;
+        }
+        CompilerIterator.prototype.current = function () {
+            return this._current;
+        };
+
+        CompilerIterator.prototype.moveNext = function () {
+            this._current = null;
+
+            while (this.moveNextInternal()) {
+                if (this._current) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        CompilerIterator.prototype.moveNextInternal = function () {
+            this.index++;
+
+            while (this.shouldMoveToNextPhase()) {
+                this.index = 0;
+                this.compilerPhase++;
+            }
+
+            if (this.compilerPhase > 4 /* DeclarationEmit */) {
+                return false;
+            }
+
+            switch (this.compilerPhase) {
+                case 0 /* Syntax */:
+                    return this.moveNextSyntaxPhase();
+                case 1 /* Semantics */:
+                    return this.moveNextSemanticsPhase();
+                case 2 /* EmitOptionsValidation */:
+                    return this.moveNextEmitOptionsValidationPhase();
+                case 3 /* Emit */:
+                    return this.moveNextEmitPhase();
+                case 4 /* DeclarationEmit */:
+                    return this.moveNextDeclarationEmitPhase();
+            }
+        };
+
+        CompilerIterator.prototype.shouldMoveToNextPhase = function () {
+            switch (this.compilerPhase) {
+                case 2 /* EmitOptionsValidation */:
+                    return this.index === 1;
+
+                case 0 /* Syntax */:
+                case 1 /* Semantics */:
+                    return this.index === this.fileNames.length;
+
+                case 3 /* Emit */:
+                case 4 /* DeclarationEmit */:
+                    return this.index === (this.fileNames.length + 1);
+            }
+
+            return false;
+        };
+
+        CompilerIterator.prototype.moveNextSyntaxPhase = function () {
+            TypeScript.Debug.assert(this.index >= 0 && this.index < this.fileNames.length);
+            var fileName = this.fileNames[this.index];
+
+            var diagnostics = this.compiler.getSyntacticDiagnostics(fileName);
+            if (diagnostics.length) {
+                if (!this.continueOnDiagnostics) {
+                    this.hadSyntacticDiagnostics = true;
+                }
+
+                this._current = CompileResult.fromDiagnostics(diagnostics);
+            }
+
+            return true;
+        };
+
+        CompilerIterator.prototype.moveNextSemanticsPhase = function () {
+            if (this.hadSyntacticDiagnostics) {
+                return false;
+            }
+
+            TypeScript.Debug.assert(this.index >= 0 && this.index < this.fileNames.length);
+            var fileName = this.fileNames[this.index];
+            var diagnostics = this.compiler.getSemanticDiagnostics(fileName);
+            if (diagnostics.length) {
+                if (!this.continueOnDiagnostics) {
+                    this.hadSemanticDiagnostics = true;
+                }
+
+                this._current = CompileResult.fromDiagnostics(diagnostics);
+            }
+
+            return true;
+        };
+
+        CompilerIterator.prototype.moveNextEmitOptionsValidationPhase = function () {
+            TypeScript.Debug.assert(!this.hadSyntacticDiagnostics);
+
+            if (!this._emitOptions) {
+                this._emitOptions = new TypeScript.EmitOptions(this.compiler, this.resolvePath);
+            }
+
+            if (this._emitOptions.diagnostic()) {
+                if (!this.continueOnDiagnostics) {
+                    this.hadEmitDiagnostics = true;
+                }
+
+                this._current = CompileResult.fromDiagnostics([this._emitOptions.diagnostic()]);
+            }
+
+            return true;
+        };
+
+        CompilerIterator.prototype.moveNextEmitPhase = function () {
+            var _this = this;
+            TypeScript.Debug.assert(!this.hadSyntacticDiagnostics);
+            TypeScript.Debug.assert(this._emitOptions);
+
+            if (this.hadEmitDiagnostics) {
+                return false;
+            }
+
+            TypeScript.Debug.assert(this.index >= 0 && this.index <= this.fileNames.length);
+            if (this.index < this.fileNames.length) {
+                var fileName = this.fileNames[this.index];
+                var document = this.compiler.getDocument(fileName);
+
+                this._sharedEmitter = this.compiler._emitDocument(document, this._emitOptions, function (outputFiles) {
+                    _this._current = CompileResult.fromOutputFiles(outputFiles);
+                }, this._sharedEmitter);
+                return true;
+            }
+
+            if (this.index === this.fileNames.length && this._sharedEmitter) {
+                this._current = CompileResult.fromOutputFiles(this._sharedEmitter.getOutputFiles());
+            }
+
+            return true;
+        };
+
+        CompilerIterator.prototype.moveNextDeclarationEmitPhase = function () {
+            var _this = this;
+            TypeScript.Debug.assert(!this.hadSyntacticDiagnostics);
+            TypeScript.Debug.assert(!this.hadEmitDiagnostics);
+            if (this.hadSemanticDiagnostics) {
+                return false;
+            }
+
+            if (!this.compiler.compilationSettings().generateDeclarationFiles()) {
+                return false;
+            }
+
+            TypeScript.Debug.assert(this.index >= 0 && this.index <= this.fileNames.length);
+            if (this.index < this.fileNames.length) {
+                var fileName = this.fileNames[this.index];
+                var document = this.compiler.getDocument(fileName);
+
+                this._sharedDeclarationEmitter = this.compiler._emitDocumentDeclarations(document, this._emitOptions, function (file) {
+                    _this._current = CompileResult.fromOutputFiles([file]);
+                }, this._sharedDeclarationEmitter);
+                return true;
+            }
+
+            if (this.index === this.fileNames.length && this._sharedDeclarationEmitter) {
+                this._current = CompileResult.fromOutputFiles([this._sharedDeclarationEmitter.getOutputFile()]);
+            }
+
+            return true;
+        };
+        return CompilerIterator;
+    })();
+
+    function compareDataObjects(dst, src) {
+        for (var e in dst) {
+            if (typeof dst[e] === "object") {
+                if (!compareDataObjects(dst[e], src[e]))
+                    return false;
+            } else if (typeof dst[e] !== "function") {
+                if (dst[e] !== src[e])
+                    return false;
+            }
+        }
+        return true;
+    }
+    TypeScript.compareDataObjects = compareDataObjects;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (GenerativeTypeClassification) {
+        GenerativeTypeClassification[GenerativeTypeClassification["Unknown"] = 0] = "Unknown";
+        GenerativeTypeClassification[GenerativeTypeClassification["Open"] = 1] = "Open";
+        GenerativeTypeClassification[GenerativeTypeClassification["Closed"] = 2] = "Closed";
+        GenerativeTypeClassification[GenerativeTypeClassification["InfinitelyExpanding"] = 3] = "InfinitelyExpanding";
+    })(TypeScript.GenerativeTypeClassification || (TypeScript.GenerativeTypeClassification = {}));
+    var GenerativeTypeClassification = TypeScript.GenerativeTypeClassification;
+
+    var PullTypeReferenceSymbol = (function (_super) {
+        __extends(PullTypeReferenceSymbol, _super);
+        function PullTypeReferenceSymbol(referencedTypeSymbol) {
+            _super.call(this, referencedTypeSymbol.name, referencedTypeSymbol.kind);
+            this.referencedTypeSymbol = referencedTypeSymbol;
+            this.isResolved = true;
+
+            TypeScript.Debug.assert(referencedTypeSymbol !== null, "Type root symbol may not be null");
+
+            this.setRootSymbol(referencedTypeSymbol);
+
+            this.typeReference = this;
+        }
+        PullTypeReferenceSymbol.createTypeReference = function (type) {
+            if (type.isTypeReference()) {
+                return type;
+            }
+
+            var typeReference = type.typeReference;
+
+            if (!typeReference) {
+                typeReference = new PullTypeReferenceSymbol(type);
+                type.typeReference = typeReference;
+            }
+
+            return typeReference;
+        };
+
+        PullTypeReferenceSymbol.prototype.isTypeReference = function () {
+            return true;
+        };
+
+        PullTypeReferenceSymbol.prototype.setResolved = function () {
+        };
+
+        PullTypeReferenceSymbol.prototype.setUnresolved = function () {
+        };
+        PullTypeReferenceSymbol.prototype.invalidate = function () {
+        };
+
+        PullTypeReferenceSymbol.prototype.ensureReferencedTypeIsResolved = function () {
+            this._getResolver().resolveDeclaredSymbol(this.referencedTypeSymbol);
+        };
+
+        PullTypeReferenceSymbol.prototype.getReferencedTypeSymbol = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol;
+        };
+
+        PullTypeReferenceSymbol.prototype._getResolver = function () {
+            return this.referencedTypeSymbol._getResolver();
+        };
+
+        PullTypeReferenceSymbol.prototype.hasMembers = function () {
+            return this.referencedTypeSymbol.hasMembers();
+        };
+
+        PullTypeReferenceSymbol.prototype.setAssociatedContainerType = function (type) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": setAssociatedContainerType");
+        };
+
+        PullTypeReferenceSymbol.prototype.getAssociatedContainerType = function () {
+            return this.referencedTypeSymbol.getAssociatedContainerType();
+        };
+
+        PullTypeReferenceSymbol.prototype.getFunctionSymbol = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.getFunctionSymbol();
+        };
+        PullTypeReferenceSymbol.prototype.setFunctionSymbol = function (symbol) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": setFunctionSymbol");
+        };
+
+        PullTypeReferenceSymbol.prototype.addContainedNonMember = function (nonMember) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addContainedNonMember");
+        };
+        PullTypeReferenceSymbol.prototype.findContainedNonMemberContainer = function (containerName, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.findContainedNonMemberContainer(containerName, kind);
+        };
+
+        PullTypeReferenceSymbol.prototype.addMember = function (memberSymbol) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addMember");
+        };
+        PullTypeReferenceSymbol.prototype.addEnclosedMemberType = function (enclosedType) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedMemberType");
+        };
+        PullTypeReferenceSymbol.prototype.addEnclosedMemberContainer = function (enclosedContainer) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedMemberContainer");
+        };
+        PullTypeReferenceSymbol.prototype.addEnclosedNonMember = function (enclosedNonMember) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedNonMember");
+        };
+        PullTypeReferenceSymbol.prototype.addEnclosedNonMemberType = function (enclosedNonMemberType) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedNonMemberType");
+        };
+        PullTypeReferenceSymbol.prototype.addEnclosedNonMemberContainer = function (enclosedNonMemberContainer) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedNonMemberContainer");
+        };
+        PullTypeReferenceSymbol.prototype.addTypeParameter = function (typeParameter) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addTypeParameter");
+        };
+        PullTypeReferenceSymbol.prototype.addConstructorTypeParameter = function (typeParameter) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addConstructorTypeParameter");
+        };
+
+        PullTypeReferenceSymbol.prototype.findContainedNonMember = function (name) {
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.findContainedNonMember(name);
+        };
+
+        PullTypeReferenceSymbol.prototype.findContainedNonMemberType = function (typeName, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.findContainedNonMemberType(typeName, kind);
+        };
+
+        PullTypeReferenceSymbol.prototype.getMembers = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.getMembers();
+        };
+
+        PullTypeReferenceSymbol.prototype.setHasDefaultConstructor = function (hasOne) {
+            if (typeof hasOne === "undefined") { hasOne = true; }
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ":setHasDefaultConstructor");
+        };
+        PullTypeReferenceSymbol.prototype.getHasDefaultConstructor = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getHasDefaultConstructor();
+        };
+        PullTypeReferenceSymbol.prototype.getConstructorMethod = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getConstructorMethod();
+        };
+        PullTypeReferenceSymbol.prototype.setConstructorMethod = function (constructorMethod) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": setConstructorMethod");
+        };
+        PullTypeReferenceSymbol.prototype.getTypeParameters = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getTypeParameters();
+        };
+
+        PullTypeReferenceSymbol.prototype.isGeneric = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.isGeneric();
+        };
+
+        PullTypeReferenceSymbol.prototype.addSpecialization = function (specializedVersionOfThisType, substitutingTypes) {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.addSpecialization(specializedVersionOfThisType, substitutingTypes);
+        };
+        PullTypeReferenceSymbol.prototype.getSpecialization = function (substitutingTypes) {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getSpecialization(substitutingTypes);
+        };
+        PullTypeReferenceSymbol.prototype.getKnownSpecializations = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getKnownSpecializations();
+        };
+        PullTypeReferenceSymbol.prototype.getTypeArguments = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getTypeArguments();
+        };
+        PullTypeReferenceSymbol.prototype.getTypeArgumentsOrTypeParameters = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getTypeArgumentsOrTypeParameters();
+        };
+
+        PullTypeReferenceSymbol.prototype.appendCallSignature = function (callSignature) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": appendCallSignature");
+        };
+        PullTypeReferenceSymbol.prototype.insertCallSignatureAtIndex = function (callSignature, index) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": insertCallSignatureAtIndex");
+        };
+        PullTypeReferenceSymbol.prototype.appendConstructSignature = function (callSignature) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": appendConstructSignature");
+        };
+        PullTypeReferenceSymbol.prototype.insertConstructSignatureAtIndex = function (callSignature, index) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": insertConstructSignatureAtIndex");
+        };
+        PullTypeReferenceSymbol.prototype.addIndexSignature = function (indexSignature) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addIndexSignature");
+        };
+
+        PullTypeReferenceSymbol.prototype.hasOwnCallSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.hasOwnCallSignatures();
+        };
+        PullTypeReferenceSymbol.prototype.getCallSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getCallSignatures();
+        };
+        PullTypeReferenceSymbol.prototype.hasOwnConstructSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.hasOwnConstructSignatures();
+        };
+        PullTypeReferenceSymbol.prototype.getConstructSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getConstructSignatures();
+        };
+        PullTypeReferenceSymbol.prototype.hasOwnIndexSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.hasOwnIndexSignatures();
+        };
+        PullTypeReferenceSymbol.prototype.getIndexSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getIndexSignatures();
+        };
+
+        PullTypeReferenceSymbol.prototype.addImplementedType = function (implementedType) {
+            this.referencedTypeSymbol.addImplementedType(implementedType);
+        };
+        PullTypeReferenceSymbol.prototype.getImplementedTypes = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getImplementedTypes();
+        };
+        PullTypeReferenceSymbol.prototype.addExtendedType = function (extendedType) {
+            this.referencedTypeSymbol.addExtendedType(extendedType);
+        };
+        PullTypeReferenceSymbol.prototype.getExtendedTypes = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getExtendedTypes();
+        };
+        PullTypeReferenceSymbol.prototype.addTypeThatExtendsThisType = function (type) {
+            this.referencedTypeSymbol.addTypeThatExtendsThisType(type);
+        };
+        PullTypeReferenceSymbol.prototype.getTypesThatExtendThisType = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getTypesThatExtendThisType();
+        };
+        PullTypeReferenceSymbol.prototype.addTypeThatExplicitlyImplementsThisType = function (type) {
+            this.referencedTypeSymbol.addTypeThatExplicitlyImplementsThisType(type);
+        };
+        PullTypeReferenceSymbol.prototype.getTypesThatExplicitlyImplementThisType = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getTypesThatExplicitlyImplementThisType();
+        };
+
+        PullTypeReferenceSymbol.prototype.isValidBaseKind = function (baseType, isExtendedType) {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.isValidBaseKind(baseType, isExtendedType);
+        };
+
+        PullTypeReferenceSymbol.prototype.findMember = function (name, lookInParent) {
+            if (typeof lookInParent === "undefined") { lookInParent = true; }
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.findMember(name, lookInParent);
+        };
+        PullTypeReferenceSymbol.prototype.findNestedType = function (name, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.findNestedType(name, kind);
+        };
+        PullTypeReferenceSymbol.prototype.findNestedContainer = function (name, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.findNestedContainer(name, kind);
+        };
+        PullTypeReferenceSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisiblity) {
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.getAllMembers(searchDeclKind, memberVisiblity);
+        };
+
+        PullTypeReferenceSymbol.prototype.findTypeParameter = function (name) {
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.findTypeParameter(name);
+        };
+
+        PullTypeReferenceSymbol.prototype.hasOnlyOverloadCallSignatures = function () {
+            return this.referencedTypeSymbol.hasOnlyOverloadCallSignatures();
+        };
+        return PullTypeReferenceSymbol;
+    })(TypeScript.PullTypeSymbol);
+    TypeScript.PullTypeReferenceSymbol = PullTypeReferenceSymbol;
+
+    TypeScript.nSpecializationsCreated = 0;
+    TypeScript.nSpecializedSignaturesCreated = 0;
+    TypeScript.nSpecializedTypeParameterCreated = 0;
+
+    var PullInstantiatedTypeReferenceSymbol = (function (_super) {
+        __extends(PullInstantiatedTypeReferenceSymbol, _super);
+        function PullInstantiatedTypeReferenceSymbol(referencedTypeSymbol, _typeParameterArgumentMap, isInstanceReferenceType) {
+            _super.call(this, referencedTypeSymbol);
+            this.referencedTypeSymbol = referencedTypeSymbol;
+            this._typeParameterArgumentMap = _typeParameterArgumentMap;
+            this.isInstanceReferenceType = isInstanceReferenceType;
+            this._instantiatedMembers = null;
+            this._allInstantiatedMemberNameCache = null;
+            this._instantiatedMemberNameCache = TypeScript.createIntrinsicsObject();
+            this._instantiatedCallSignatures = null;
+            this._instantiatedConstructSignatures = null;
+            this._instantiatedIndexSignatures = null;
+            this._typeArgumentReferences = undefined;
+            this._instantiatedConstructorMethod = null;
+            this._instantiatedAssociatedContainerType = null;
+            this._isArray = undefined;
+            this._generativeTypeClassification = [];
+
+            TypeScript.nSpecializationsCreated++;
+        }
+        PullInstantiatedTypeReferenceSymbol.prototype.getIsSpecialized = function () {
+            return !this.isInstanceReferenceType;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getGenerativeTypeClassification = function (enclosingType) {
+            if (!this.isNamedTypeSymbol()) {
+                return 0 /* Unknown */;
+            }
+
+            var generativeTypeClassification = this._generativeTypeClassification[enclosingType.pullSymbolID] || 0 /* Unknown */;
+            if (generativeTypeClassification === 0 /* Unknown */) {
+                var typeParameters = enclosingType.getTypeParameters();
+                var enclosingTypeParameterMap = [];
+                for (var i = 0; i < typeParameters.length; i++) {
+                    enclosingTypeParameterMap[typeParameters[i].pullSymbolID] = typeParameters[i];
+                }
+
+                var typeArguments = this.getTypeArguments();
+                for (var i = 0; i < typeArguments.length; i++) {
+                    if (typeArguments[i].wrapsSomeTypeParameter(enclosingTypeParameterMap, true)) {
+                        generativeTypeClassification = 1 /* Open */;
+                        break;
+                    }
+                }
+
+                if (generativeTypeClassification === 1 /* Open */) {
+                    if (this.wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReference(enclosingType)) {
+                        generativeTypeClassification = 3 /* InfinitelyExpanding */;
+                    }
+                } else {
+                    generativeTypeClassification = 2 /* Closed */;
+                }
+
+                this._generativeTypeClassification[enclosingType.pullSymbolID] = generativeTypeClassification;
+            }
+
+            return generativeTypeClassification;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.isArrayNamedTypeReference = function () {
+            if (this._isArray === undefined) {
+                this._isArray = this.getRootSymbol().isArrayNamedTypeReference() || (this.getRootSymbol() === this._getResolver().getArrayNamedType());
+            }
+            return this._isArray;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getElementType = function () {
+            if (!this.isArrayNamedTypeReference()) {
+                return null;
+            }
+
+            var typeArguments = this.getTypeArguments();
+            return typeArguments ? typeArguments[0] : null;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getReferencedTypeSymbol = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            if (this.getIsSpecialized()) {
+                return this;
+            }
+
+            return this.referencedTypeSymbol;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.create = function (resolver, type, typeParameterArgumentMap) {
+            TypeScript.Debug.assert(resolver);
+
+            var mutableTypeParameterMap = new TypeScript.PullInstantiationHelpers.MutableTypeArgumentMap(typeParameterArgumentMap);
+
+            TypeScript.PullInstantiationHelpers.instantiateTypeArgument(resolver, type, mutableTypeParameterMap);
+
+            var rootType = type.getRootSymbol();
+            var instantiation = rootType.getSpecialization(mutableTypeParameterMap.typeParameterArgumentMap);
+            if (instantiation) {
+                return instantiation;
+            }
+
+            TypeScript.PullInstantiationHelpers.cleanUpTypeArgumentMap(type, mutableTypeParameterMap);
+            typeParameterArgumentMap = mutableTypeParameterMap.typeParameterArgumentMap;
+
+            var isInstanceReferenceType = (type.kind & 8216 /* SomeInstantiatableType */) != 0;
+            var resolvedTypeParameterArgumentMap = typeParameterArgumentMap;
+            if (isInstanceReferenceType) {
+                var typeParameters = rootType.getTypeParameters();
+                for (var i = 0; i < typeParameters.length; i++) {
+                    if (!TypeScript.PullHelpers.typeSymbolsAreIdentical(typeParameters[i], typeParameterArgumentMap[typeParameters[i].pullSymbolID])) {
+                        isInstanceReferenceType = false;
+                        break;
+                    }
+                }
+
+                if (isInstanceReferenceType) {
+                    typeParameterArgumentMap = [];
+                }
+            }
+
+            instantiation = new PullInstantiatedTypeReferenceSymbol(rootType, typeParameterArgumentMap, isInstanceReferenceType);
+
+            rootType.addSpecialization(instantiation, resolvedTypeParameterArgumentMap);
+
+            return instantiation;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.isGeneric = function () {
+            return this.getRootSymbol().isGeneric();
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getTypeParameterArgumentMap = function () {
+            return this._typeParameterArgumentMap;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getTypeArguments = function () {
+            if (this.isInstanceReferenceType) {
+                return this.getTypeParameters();
+            }
+
+            if (this._typeArgumentReferences === undefined) {
+                var typeParameters = this.referencedTypeSymbol.getTypeParameters();
+
+                if (typeParameters.length) {
+                    var typeArgument = null;
+                    var typeArguments = [];
+
+                    for (var i = 0; i < typeParameters.length; i++) {
+                        typeArgument = this._typeParameterArgumentMap[typeParameters[i].pullSymbolID];
+
+                        if (!typeArgument) {
+                            TypeScript.Debug.fail("type argument count mismatch");
+                        }
+
+                        if (typeArgument) {
+                            typeArguments[typeArguments.length] = typeArgument;
+                        }
+                    }
+
+                    this._typeArgumentReferences = typeArguments;
+                } else {
+                    this._typeArgumentReferences = null;
+                }
+            }
+
+            return this._typeArgumentReferences;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getTypeArgumentsOrTypeParameters = function () {
+            return this.getTypeArguments();
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.populateInstantiatedMemberFromReferencedMember = function (referencedMember) {
+            var instantiatedMember;
+            TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(referencedMember);
+
+            if (!referencedMember.type.wrapsSomeTypeParameter(this._typeParameterArgumentMap)) {
+                instantiatedMember = referencedMember;
+            } else {
+                instantiatedMember = new TypeScript.PullSymbol(referencedMember.name, referencedMember.kind);
+                instantiatedMember.setRootSymbol(referencedMember);
+                instantiatedMember.type = this._getResolver().instantiateType(referencedMember.type, this._typeParameterArgumentMap);
+                instantiatedMember.isOptional = referencedMember.isOptional;
+            }
+            this._instantiatedMemberNameCache[instantiatedMember.name] = instantiatedMember;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getMembers = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            if (this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.getMembers();
+            }
+
+            if (!this._instantiatedMembers) {
+                var referencedMembers = this.referencedTypeSymbol.getMembers();
+                var referencedMember = null;
+                var instantiatedMember = null;
+
+                this._instantiatedMembers = [];
+
+                for (var i = 0; i < referencedMembers.length; i++) {
+                    referencedMember = referencedMembers[i];
+
+                    this._getResolver().resolveDeclaredSymbol(referencedMember);
+
+                    if (!this._instantiatedMemberNameCache[referencedMember.name]) {
+                        this.populateInstantiatedMemberFromReferencedMember(referencedMember);
+                    }
+
+                    this._instantiatedMembers[this._instantiatedMembers.length] = this._instantiatedMemberNameCache[referencedMember.name];
+                }
+            }
+
+            return this._instantiatedMembers;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.findMember = function (name, lookInParent) {
+            if (typeof lookInParent === "undefined") { lookInParent = true; }
+            this.ensureReferencedTypeIsResolved();
+
+            if (this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.findMember(name, lookInParent);
+            }
+
+            var memberSymbol = this._instantiatedMemberNameCache[name];
+
+            if (!memberSymbol) {
+                var referencedMemberSymbol = this.referencedTypeSymbol.findMember(name, lookInParent);
+
+                if (referencedMemberSymbol) {
+                    this.populateInstantiatedMemberFromReferencedMember(referencedMemberSymbol);
+                    memberSymbol = this._instantiatedMemberNameCache[name];
+                } else {
+                    memberSymbol = null;
+                }
+            }
+
+            return memberSymbol;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisiblity) {
+            this.ensureReferencedTypeIsResolved();
+
+            if (this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.getAllMembers(searchDeclKind, memberVisiblity);
+            }
+
+            var requestedMembers = [];
+            var allReferencedMembers = this.referencedTypeSymbol.getAllMembers(searchDeclKind, memberVisiblity);
+
+            if (!this._allInstantiatedMemberNameCache) {
+                this._allInstantiatedMemberNameCache = TypeScript.createIntrinsicsObject();
+
+                var members = this.getMembers();
+
+                for (var i = 0; i < members.length; i++) {
+                    this._allInstantiatedMemberNameCache[members[i].name] = members[i];
+                }
+            }
+
+            var referencedMember = null;
+            var requestedMember = null;
+
+            for (var i = 0; i < allReferencedMembers.length; i++) {
+                referencedMember = allReferencedMembers[i];
+
+                this._getResolver().resolveDeclaredSymbol(referencedMember);
+
+                if (this._allInstantiatedMemberNameCache[referencedMember.name]) {
+                    requestedMembers[requestedMembers.length] = this._allInstantiatedMemberNameCache[referencedMember.name];
+                } else {
+                    if (!referencedMember.type.wrapsSomeTypeParameter(this._typeParameterArgumentMap)) {
+                        this._allInstantiatedMemberNameCache[referencedMember.name] = referencedMember;
+                        requestedMembers[requestedMembers.length] = referencedMember;
+                    } else {
+                        requestedMember = new TypeScript.PullSymbol(referencedMember.name, referencedMember.kind);
+                        requestedMember.setRootSymbol(referencedMember);
+
+                        requestedMember.type = this._getResolver().instantiateType(referencedMember.type, this._typeParameterArgumentMap);
+                        requestedMember.isOptional = referencedMember.isOptional;
+
+                        this._allInstantiatedMemberNameCache[requestedMember.name] = requestedMember;
+                        requestedMembers[requestedMembers.length] = requestedMember;
+                    }
+                }
+            }
+
+            return requestedMembers;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getConstructorMethod = function () {
+            if (this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.getConstructorMethod();
+            }
+
+            if (!this._instantiatedConstructorMethod) {
+                var referencedConstructorMethod = this.referencedTypeSymbol.getConstructorMethod();
+                this._instantiatedConstructorMethod = new TypeScript.PullSymbol(referencedConstructorMethod.name, referencedConstructorMethod.kind);
+                this._instantiatedConstructorMethod.setRootSymbol(referencedConstructorMethod);
+                this._instantiatedConstructorMethod.setResolved();
+
+                this._instantiatedConstructorMethod.type = PullInstantiatedTypeReferenceSymbol.create(this._getResolver(), referencedConstructorMethod.type, this._typeParameterArgumentMap);
+            }
+
+            return this._instantiatedConstructorMethod;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getAssociatedContainerType = function () {
+            if (!this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.getAssociatedContainerType();
+            }
+
+            if (!this._instantiatedAssociatedContainerType) {
+                var referencedAssociatedContainerType = this.referencedTypeSymbol.getAssociatedContainerType();
+
+                if (referencedAssociatedContainerType) {
+                    this._instantiatedAssociatedContainerType = PullInstantiatedTypeReferenceSymbol.create(this._getResolver(), referencedAssociatedContainerType, this._typeParameterArgumentMap);
+                }
+            }
+
+            return this._instantiatedAssociatedContainerType;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getCallSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            if (this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.getCallSignatures();
+            }
+
+            if (this._instantiatedCallSignatures) {
+                return this._instantiatedCallSignatures;
+            }
+
+            var referencedCallSignatures = this.referencedTypeSymbol.getCallSignatures();
+            this._instantiatedCallSignatures = [];
+
+            for (var i = 0; i < referencedCallSignatures.length; i++) {
+                this._getResolver().resolveDeclaredSymbol(referencedCallSignatures[i]);
+
+                if (!referencedCallSignatures[i].wrapsSomeTypeParameter(this._typeParameterArgumentMap)) {
+                    this._instantiatedCallSignatures[this._instantiatedCallSignatures.length] = referencedCallSignatures[i];
+                } else {
+                    this._instantiatedCallSignatures[this._instantiatedCallSignatures.length] = this._getResolver().instantiateSignature(referencedCallSignatures[i], this._typeParameterArgumentMap);
+                    this._instantiatedCallSignatures[this._instantiatedCallSignatures.length - 1].functionType = this;
+                }
+            }
+
+            return this._instantiatedCallSignatures;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getConstructSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            if (this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.getConstructSignatures();
+            }
+
+            if (this._instantiatedConstructSignatures) {
+                return this._instantiatedConstructSignatures;
+            }
+
+            var referencedConstructSignatures = this.referencedTypeSymbol.getConstructSignatures();
+            this._instantiatedConstructSignatures = [];
+
+            for (var i = 0; i < referencedConstructSignatures.length; i++) {
+                this._getResolver().resolveDeclaredSymbol(referencedConstructSignatures[i]);
+
+                if (!referencedConstructSignatures[i].wrapsSomeTypeParameter(this._typeParameterArgumentMap)) {
+                    this._instantiatedConstructSignatures[this._instantiatedConstructSignatures.length] = referencedConstructSignatures[i];
+                } else {
+                    this._instantiatedConstructSignatures[this._instantiatedConstructSignatures.length] = this._getResolver().instantiateSignature(referencedConstructSignatures[i], this._typeParameterArgumentMap);
+                    this._instantiatedConstructSignatures[this._instantiatedConstructSignatures.length - 1].functionType = this;
+                }
+            }
+
+            return this._instantiatedConstructSignatures;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getIndexSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            if (this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.getIndexSignatures();
+            }
+
+            if (this._instantiatedIndexSignatures) {
+                return this._instantiatedIndexSignatures;
+            }
+
+            var referencedIndexSignatures = this.referencedTypeSymbol.getIndexSignatures();
+            this._instantiatedIndexSignatures = [];
+
+            for (var i = 0; i < referencedIndexSignatures.length; i++) {
+                this._getResolver().resolveDeclaredSymbol(referencedIndexSignatures[i]);
+
+                if (!referencedIndexSignatures[i].wrapsSomeTypeParameter(this._typeParameterArgumentMap)) {
+                    this._instantiatedIndexSignatures[this._instantiatedIndexSignatures.length] = referencedIndexSignatures[i];
+                } else {
+                    this._instantiatedIndexSignatures[this._instantiatedIndexSignatures.length] = this._getResolver().instantiateSignature(referencedIndexSignatures[i], this._typeParameterArgumentMap);
+                    this._instantiatedIndexSignatures[this._instantiatedIndexSignatures.length - 1].functionType = this;
+                }
+            }
+
+            return this._instantiatedIndexSignatures;
+        };
+        return PullInstantiatedTypeReferenceSymbol;
+    })(PullTypeReferenceSymbol);
+    TypeScript.PullInstantiatedTypeReferenceSymbol = PullInstantiatedTypeReferenceSymbol;
+
+    var PullInstantiatedSignatureSymbol = (function (_super) {
+        __extends(PullInstantiatedSignatureSymbol, _super);
+        function PullInstantiatedSignatureSymbol(rootSignature, _typeParameterArgumentMap) {
+            _super.call(this, rootSignature.kind, rootSignature.isDefinition());
+            this._typeParameterArgumentMap = _typeParameterArgumentMap;
+            this.setRootSymbol(rootSignature);
+            TypeScript.nSpecializedSignaturesCreated++;
+
+            rootSignature.addSpecialization(this, _typeParameterArgumentMap);
+        }
+        PullInstantiatedSignatureSymbol.prototype.getTypeParameterArgumentMap = function () {
+            return this._typeParameterArgumentMap;
+        };
+
+        PullInstantiatedSignatureSymbol.prototype.getIsSpecialized = function () {
+            return true;
+        };
+
+        PullInstantiatedSignatureSymbol.prototype._getResolver = function () {
+            return this.getRootSymbol()._getResolver();
+        };
+
+        PullInstantiatedSignatureSymbol.prototype.getTypeParameters = function () {
+            var _this = this;
+            if (!this._typeParameters) {
+                var rootSymbol = this.getRootSymbol();
+                var typeParameters = rootSymbol.getTypeParameters();
+                var hasInstantiatedTypeParametersOfThisSignature = TypeScript.ArrayUtilities.all(typeParameters, function (typeParameter) {
+                    return _this._typeParameterArgumentMap[typeParameter.pullSymbolID] !== undefined;
+                });
+
+                if (!hasInstantiatedTypeParametersOfThisSignature && typeParameters.length) {
+                    this._typeParameters = [];
+                    for (var i = 0; i < typeParameters.length; i++) {
+                        this._typeParameters[this._typeParameters.length] = this._getResolver().instantiateTypeParameter(typeParameters[i], this._typeParameterArgumentMap);
+                    }
+                } else {
+                    this._typeParameters = TypeScript.sentinelEmptyArray;
+                }
+            }
+
+            return this._typeParameters;
+        };
+
+        PullInstantiatedSignatureSymbol.prototype.getAllowedToReferenceTypeParameters = function () {
+            var rootSymbol = this.getRootSymbol();
+            return rootSymbol.getAllowedToReferenceTypeParameters();
+        };
+        return PullInstantiatedSignatureSymbol;
+    })(TypeScript.PullSignatureSymbol);
+    TypeScript.PullInstantiatedSignatureSymbol = PullInstantiatedSignatureSymbol;
+
+    var PullInstantiatedTypeParameterSymbol = (function (_super) {
+        __extends(PullInstantiatedTypeParameterSymbol, _super);
+        function PullInstantiatedTypeParameterSymbol(rootTypeParameter, constraintType) {
+            _super.call(this, rootTypeParameter.name);
+            TypeScript.nSpecializedTypeParameterCreated++;
+
+            this.setRootSymbol(rootTypeParameter);
+            this.setConstraint(constraintType);
+
+            rootTypeParameter.addSpecialization(this, [constraintType]);
+        }
+        PullInstantiatedTypeParameterSymbol.prototype._getResolver = function () {
+            return this.getRootSymbol()._getResolver();
+        };
+        return PullInstantiatedTypeParameterSymbol;
+    })(TypeScript.PullTypeParameterSymbol);
+    TypeScript.PullInstantiatedTypeParameterSymbol = PullInstantiatedTypeParameterSymbol;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxTreeToAstVisitor = (function () {
+        function SyntaxTreeToAstVisitor(fileName, lineMap, compilationSettings) {
+            this.fileName = fileName;
+            this.lineMap = lineMap;
+            this.compilationSettings = compilationSettings;
+            this.position = 0;
+            this.previousTokenTrailingComments = null;
+        }
+        SyntaxTreeToAstVisitor.visit = function (syntaxTree, fileName, compilationSettings, incrementalAST) {
+            var visitor = incrementalAST ? new SyntaxTreeToIncrementalAstVisitor(fileName, syntaxTree.lineMap(), compilationSettings) : new SyntaxTreeToAstVisitor(fileName, syntaxTree.lineMap(), compilationSettings);
+            return syntaxTree.sourceUnit().accept(visitor);
+        };
+
+        SyntaxTreeToAstVisitor.prototype.movePast = function (element) {
+            if (element !== null) {
+                this.position += element.fullWidth();
+            }
+        };
+
+        SyntaxTreeToAstVisitor.prototype.moveTo = function (element1, element2) {
+            if (element2 !== null) {
+                this.position += TypeScript.Syntax.childOffset(element1, element2);
+            }
+        };
+
+        SyntaxTreeToAstVisitor.prototype.setCommentsAndSpan = function (ast, fullStart, node) {
+            var firstToken = node.firstToken();
+            var lastToken = node.lastToken();
+
+            this.setSpan(ast, fullStart, node, firstToken, lastToken);
+            ast.setPreComments(this.convertTokenLeadingComments(firstToken, fullStart));
+            ast.setPostComments(this.convertNodeTrailingComments(node, lastToken, fullStart));
+        };
+
+        SyntaxTreeToAstVisitor.prototype.createTokenSpan = function (fullStart, element) {
+            if (element === null) {
+                return null;
+            }
+
+            if (element.fullWidth() === 0) {
+                return new TypeScript.ASTSpan(-1, -1);
+            }
+
+            var leadingTriviaWidth = element.leadingTriviaWidth();
+            var trailingTriviaWidth = element.trailingTriviaWidth();
+
+            var start = fullStart + leadingTriviaWidth;
+            var end = fullStart + element.fullWidth() - trailingTriviaWidth;
+
+            return new TypeScript.ASTSpan(start, end);
+        };
+
+        SyntaxTreeToAstVisitor.prototype.setSpan = function (span, fullStart, element, firstToken, lastToken) {
+            if (typeof firstToken === "undefined") { firstToken = element.firstToken(); }
+            if (typeof lastToken === "undefined") { lastToken = element.lastToken(); }
+            var leadingTriviaWidth = firstToken ? firstToken.leadingTriviaWidth() : 0;
+            var trailingTriviaWidth = lastToken ? lastToken.trailingTriviaWidth() : 0;
+
+            var desiredMinChar = fullStart + leadingTriviaWidth;
+            var desiredLimChar = fullStart + element.fullWidth() - trailingTriviaWidth;
+
+            this.setSpanExplicit(span, desiredMinChar, desiredLimChar);
+
+            span._trailingTriviaWidth = trailingTriviaWidth;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.setSpanExplicit = function (span, start, end) {
+            span._start = start;
+            span._end = end;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitSyntaxList = function (node) {
+            var start = this.position;
+            var array = new Array(node.childCount());
+
+            for (var i = 0, n = node.childCount(); i < n; i++) {
+                array[i] = node.childAt(i).accept(this);
+            }
+
+            var result = new TypeScript.ISyntaxList2(this.fileName, array);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitSeparatedSyntaxList = function (list) {
+            var start = this.position;
+            var array = new Array(list.nonSeparatorCount());
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                if (i % 2 === 0) {
+                    array[i / 2] = list.childAt(i).accept(this);
+                    this.previousTokenTrailingComments = null;
+                } else {
+                    var separatorToken = list.childAt(i);
+                    this.previousTokenTrailingComments = this.convertTokenTrailingComments(separatorToken, this.position + separatorToken.leadingTriviaWidth() + separatorToken.width());
+                    this.movePast(separatorToken);
+                }
+            }
+
+            var result = new TypeScript.ISeparatedSyntaxList2(this.fileName, array, list.separatorCount());
+            this.setSpan(result, start, list);
+
+            result.setPostComments(this.previousTokenTrailingComments);
+            this.previousTokenTrailingComments = null;
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.convertComment = function (trivia, commentStartPosition, hasTrailingNewLine) {
+            var comment = new TypeScript.Comment(trivia, hasTrailingNewLine, commentStartPosition, commentStartPosition + trivia.fullWidth());
+
+            return comment;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.convertComments = function (triviaList, commentStartPosition) {
+            var result = [];
+
+            for (var i = 0, n = triviaList.count(); i < n; i++) {
+                var trivia = triviaList.syntaxTriviaAt(i);
+
+                if (trivia.isComment()) {
+                    var hasTrailingNewLine = ((i + 1) < n) && triviaList.syntaxTriviaAt(i + 1).isNewLine();
+                    result.push(this.convertComment(trivia, commentStartPosition, hasTrailingNewLine));
+                }
+
+                commentStartPosition += trivia.fullWidth();
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.mergeComments = function (comments1, comments2) {
+            if (comments1 === null) {
+                return comments2;
+            }
+
+            if (comments2 === null) {
+                return comments1;
+            }
+
+            return comments1.concat(comments2);
+        };
+
+        SyntaxTreeToAstVisitor.prototype.convertTokenLeadingComments = function (token, commentStartPosition) {
+            if (token === null) {
+                return null;
+            }
+
+            var preComments = token.hasLeadingComment() ? this.convertComments(token.leadingTrivia(), commentStartPosition) : null;
+
+            var previousTokenTrailingComments = this.previousTokenTrailingComments;
+            this.previousTokenTrailingComments = null;
+
+            return this.mergeComments(previousTokenTrailingComments, preComments);
+        };
+
+        SyntaxTreeToAstVisitor.prototype.convertTokenTrailingComments = function (token, commentStartPosition) {
+            if (token === null || !token.hasTrailingComment() || token.hasTrailingNewLine()) {
+                return null;
+            }
+
+            return this.convertComments(token.trailingTrivia(), commentStartPosition);
+        };
+
+        SyntaxTreeToAstVisitor.prototype.convertNodeTrailingComments = function (node, lastToken, nodeStart) {
+            if (lastToken === null || !lastToken.hasTrailingComment() || lastToken.hasTrailingNewLine()) {
+                return null;
+            }
+
+            return this.convertComments(lastToken.trailingTrivia(), nodeStart + node.fullWidth() - lastToken.trailingTriviaWidth());
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitIdentifier = function (token) {
+            return this.visitToken(token);
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitToken = function (token) {
+            var fullStart = this.position;
+
+            var result = this.visitTokenWorker(token);
+
+            this.movePast(token);
+
+            var start = fullStart + token.leadingTriviaWidth();
+            this.setSpanExplicit(result, start, start + token.width());
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTokenWorker = function (token) {
+            switch (token.tokenKind) {
+                case 60 /* AnyKeyword */:
+                    return new TypeScript.BuiltInType(60 /* AnyKeyword */, token.text(), token.valueText());
+                case 61 /* BooleanKeyword */:
+                    return new TypeScript.BuiltInType(61 /* BooleanKeyword */, token.text(), token.valueText());
+                case 67 /* NumberKeyword */:
+                    return new TypeScript.BuiltInType(67 /* NumberKeyword */, token.text(), token.valueText());
+                case 69 /* StringKeyword */:
+                    return new TypeScript.BuiltInType(69 /* StringKeyword */, token.text(), token.valueText());
+                case 41 /* VoidKeyword */:
+                    return new TypeScript.BuiltInType(41 /* VoidKeyword */, token.text(), token.valueText());
+                case 35 /* ThisKeyword */:
+                    return new TypeScript.ThisExpression(token.text(), token.valueText());
+                case 50 /* SuperKeyword */:
+                    return new TypeScript.SuperExpression(token.text(), token.valueText());
+                case 37 /* TrueKeyword */:
+                    return new TypeScript.LiteralExpression(37 /* TrueKeyword */, token.text(), token.valueText());
+                case 24 /* FalseKeyword */:
+                    return new TypeScript.LiteralExpression(24 /* FalseKeyword */, token.text(), token.valueText());
+                case 32 /* NullKeyword */:
+                    return new TypeScript.LiteralExpression(32 /* NullKeyword */, token.text(), token.valueText());
+                case 14 /* StringLiteral */:
+                    return new TypeScript.StringLiteral(token.text(), token.valueText());
+                case 12 /* RegularExpressionLiteral */:
+                    return new TypeScript.RegularExpressionLiteral(token.text(), token.valueText());
+                case 13 /* NumericLiteral */:
+                    var fullStart = this.position;
+                    var preComments = this.convertTokenLeadingComments(token, fullStart);
+
+                    var result = new TypeScript.NumericLiteral(token.value(), token.text(), token.valueText());
+
+                    result.setPreComments(preComments);
+                    return result;
+                case 11 /* IdentifierName */:
+                    return new TypeScript.Identifier(token.text());
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitSourceUnit = function (node) {
+            var start = this.position;
+            TypeScript.Debug.assert(start === 0);
+
+            var bod = this.visitSyntaxList(node.moduleElements);
+            var comments = this.convertTokenLeadingComments(node.endOfFileToken, TypeScript.Syntax.childOffset(node, node.endOfFileToken));
+            var result = new TypeScript.SourceUnit(bod, comments, this.fileName);
+            this.setSpanExplicit(result, start, start + node.fullWidth());
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitExternalModuleReference = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.stringLiteral);
+            var stringLiteral = node.stringLiteral.accept(this);
+            this.movePast(node.closeParenToken);
+
+            var result = new TypeScript.ExternalModuleReference(stringLiteral);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitModuleNameModuleReference = function (node) {
+            var start = this.position;
+            var moduleName = node.moduleName.accept(this);
+
+            var result = new TypeScript.ModuleNameModuleReference(moduleName);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitClassDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.identifier);
+            var name = this.visitIdentifier(node.identifier);
+
+            var typeParameters = this.visitTypeParameterList(node.typeParameterList);
+            var heritageClauses = node.heritageClauses ? this.visitSyntaxList(node.heritageClauses) : null;
+
+            this.movePast(node.openBraceToken);
+            var members = this.visitSyntaxList(node.classElements);
+
+            var closeBraceToken = this.createTokenSpan(this.position, node.closeBraceToken);
+            this.movePast(node.closeBraceToken);
+
+            var modifiers = this.visitModifiers(node.modifiers);
+            var result = new TypeScript.ClassDeclaration(modifiers, name, typeParameters, heritageClauses, members, closeBraceToken);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitModifiers = function (modifiers) {
+            var result = null;
+            if (TypeScript.SyntaxUtilities.containsToken(modifiers, 47 /* ExportKeyword */)) {
+                result = result || [];
+                result.push(1 /* Exported */);
+            }
+
+            if (TypeScript.SyntaxUtilities.containsToken(modifiers, 63 /* DeclareKeyword */)) {
+                result = result || [];
+                result.push(8 /* Ambient */);
+            }
+
+            if (TypeScript.SyntaxUtilities.containsToken(modifiers, 58 /* StaticKeyword */)) {
+                result = result || [];
+                result.push(16 /* Static */);
+            }
+
+            if (TypeScript.SyntaxUtilities.containsToken(modifiers, 57 /* PublicKeyword */)) {
+                result = result || [];
+                result.push(4 /* Public */);
+            }
+
+            if (TypeScript.SyntaxUtilities.containsToken(modifiers, 55 /* PrivateKeyword */)) {
+                result = result || [];
+                result.push(2 /* Private */);
+            }
+
+            return result || TypeScript.sentinelEmptyArray;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitInterfaceDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.identifier);
+            var name = this.visitIdentifier(node.identifier);
+            var typeParameters = this.visitTypeParameterList(node.typeParameterList);
+            var heritageClauses = node.heritageClauses ? this.visitSyntaxList(node.heritageClauses) : null;
+
+            var body = this.visitObjectType(node.body);
+
+            var modifiers = this.visitModifiers(node.modifiers);
+            var result = new TypeScript.InterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, body);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitHeritageClause = function (node) {
+            var start = this.position;
+
+            this.movePast(node.extendsOrImplementsKeyword);
+            var typeNames = this.visitSeparatedSyntaxList(node.typeNames);
+
+            var result = new TypeScript.HeritageClause(node.extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */ ? 230 /* ExtendsHeritageClause */ : 231 /* ImplementsHeritageClause */, typeNames);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitModuleDeclaration = function (node) {
+            var start = this.position;
+
+            var modifiers = this.visitModifiers(node.modifiers);
+
+            this.moveTo(node, node.moduleKeyword);
+            this.movePast(node.moduleKeyword);
+
+            var moduleName = node.name ? node.name.accept(this) : null;
+            var stringLiteral = node.stringLiteral ? node.stringLiteral.accept(this) : null;
+
+            this.movePast(node.openBraceToken);
+
+            var moduleElements = this.visitSyntaxList(node.moduleElements);
+
+            var closeBraceToken = this.createTokenSpan(this.position, node.closeBraceToken);
+            this.movePast(node.closeBraceToken);
+
+            var result = new TypeScript.ModuleDeclaration(modifiers, moduleName, stringLiteral, moduleElements, closeBraceToken);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitFunctionDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.identifier);
+            var name = this.visitIdentifier(node.identifier);
+
+            var callSignature = this.visitCallSignature(node.callSignature);
+            var block = node.block ? this.visitBlock(node.block) : null;
+
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.FunctionDeclaration(this.visitModifiers(node.modifiers), name, callSignature, block);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitEnumDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.identifier);
+            var identifier = this.visitIdentifier(node.identifier);
+
+            this.movePast(node.openBraceToken);
+
+            var enumElements = this.visitSeparatedSyntaxList(node.enumElements);
+
+            this.movePast(node.closeBraceToken);
+
+            var result = new TypeScript.EnumDeclaration(this.visitModifiers(node.modifiers), identifier, enumElements);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitEnumElement = function (node) {
+            var start = this.position;
+
+            var memberName = this.visitToken(node.propertyName);
+
+            var value = node.equalsValueClause !== null ? this.visitEqualsValueClause(node.equalsValueClause) : null;
+
+            var result = new TypeScript.EnumElement(memberName, value);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitImportDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.identifier);
+            var name = this.visitIdentifier(node.identifier);
+            this.movePast(node.equalsToken);
+            var alias = node.moduleReference.accept(this);
+            this.movePast(node.semicolonToken);
+
+            var modifiers = this.visitModifiers(node.modifiers);
+            var result = new TypeScript.ImportDeclaration(modifiers, name, alias);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitExportAssignment = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.identifier);
+            var name = this.visitIdentifier(node.identifier);
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.ExportAssignment(name);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitVariableStatement = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.variableDeclaration);
+
+            var declaration = node.variableDeclaration.accept(this);
+            this.movePast(node.semicolonToken);
+
+            var modifiers = this.visitModifiers(node.modifiers);
+
+            var result = new TypeScript.VariableStatement(modifiers, declaration);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitVariableDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.variableDeclarators);
+            var variableDecls = this.visitSeparatedSyntaxList(node.variableDeclarators);
+
+            var result = new TypeScript.VariableDeclaration(variableDecls);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitVariableDeclarator = function (node) {
+            var start = this.position;
+            var propertyName = this.visitToken(node.propertyName);
+            var typeExpr = this.visitTypeAnnotation(node.typeAnnotation);
+            var init = node.equalsValueClause ? this.visitEqualsValueClause(node.equalsValueClause) : null;
+
+            var result = new TypeScript.VariableDeclarator(propertyName, typeExpr, init);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitEqualsValueClause = function (node) {
+            var start = this.position;
+            var afterEqualsComments = this.convertTokenTrailingComments(node.equalsToken, this.position + node.equalsToken.leadingTriviaWidth() + node.equalsToken.width());
+
+            this.movePast(node.equalsToken);
+            var value = node.value.accept(this);
+            value.setPreComments(this.mergeComments(afterEqualsComments, value.preComments()));
+
+            var result = new TypeScript.EqualsValueClause(value);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitPrefixUnaryExpression = function (node) {
+            var start = this.position;
+
+            this.movePast(node.operatorToken);
+            var operand = node.operand.accept(this);
+
+            var result = new TypeScript.PrefixUnaryExpression(node.kind(), operand);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitArrayLiteralExpression = function (node) {
+            var start = this.position;
+            var openStart = this.position + node.openBracketToken.leadingTriviaWidth();
+            this.movePast(node.openBracketToken);
+
+            var expressions = this.visitSeparatedSyntaxList(node.expressions);
+
+            var closeStart = this.position + node.closeBracketToken.leadingTriviaWidth();
+            this.movePast(node.closeBracketToken);
+
+            var result = new TypeScript.ArrayLiteralExpression(expressions);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitOmittedExpression = function (node) {
+            var start = this.position;
+
+            var result = new TypeScript.OmittedExpression();
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitParenthesizedExpression = function (node) {
+            var start = this.position;
+
+            var openParenToken = node.openParenToken;
+            var openParenTrailingComments = this.convertTokenTrailingComments(openParenToken, start + openParenToken.leadingTriviaWidth() + openParenToken.width());
+
+            this.movePast(openParenToken);
+
+            var expr = node.expression.accept(this);
+            this.movePast(node.closeParenToken);
+
+            var result = new TypeScript.ParenthesizedExpression(openParenTrailingComments, expr);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitSimpleArrowFunctionExpression = function (node) {
+            var start = this.position;
+
+            var identifier = node.identifier.accept(this);
+            this.movePast(node.equalsGreaterThanToken);
+
+            var block = node.block ? this.visitBlock(node.block) : null;
+            var expression = node.expression ? node.expression.accept(this) : null;
+
+            var result = new TypeScript.SimpleArrowFunctionExpression(identifier, block, expression);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitParenthesizedArrowFunctionExpression = function (node) {
+            var start = this.position;
+
+            var callSignature = this.visitCallSignature(node.callSignature);
+            this.movePast(node.equalsGreaterThanToken);
+
+            var block = node.block ? this.visitBlock(node.block) : null;
+            var expression = node.expression ? node.expression.accept(this) : null;
+
+            var result = new TypeScript.ParenthesizedArrowFunctionExpression(callSignature, block, expression);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitType = function (type) {
+            return type ? type.accept(this) : null;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTypeQuery = function (node) {
+            var start = this.position;
+            this.movePast(node.typeOfKeyword);
+            var name = node.name.accept(this);
+
+            var result = new TypeScript.TypeQuery(name);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitQualifiedName = function (node) {
+            var start = this.position;
+            var left = this.visitType(node.left);
+            this.movePast(node.dotToken);
+            var right = this.visitIdentifier(node.right);
+
+            var result = new TypeScript.QualifiedName(left, right);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTypeArgumentList = function (node) {
+            if (node === null) {
+                return null;
+            }
+
+            var start = this.position;
+            this.movePast(node.lessThanToken);
+            var typeArguments = this.visitSeparatedSyntaxList(node.typeArguments);
+            this.movePast(node.greaterThanToken);
+
+            var result = new TypeScript.TypeArgumentList(typeArguments);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitConstructorType = function (node) {
+            var start = this.position;
+
+            this.movePast(node.newKeyword);
+            var typeParameters = this.visitTypeParameterList(node.typeParameterList);
+            var parameters = this.visitParameterList(node.parameterList);
+            this.movePast(node.equalsGreaterThanToken);
+            var returnType = this.visitType(node.type);
+
+            var result = new TypeScript.ConstructorType(typeParameters, parameters, returnType);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitFunctionType = function (node) {
+            var start = this.position;
+            var typeParameters = this.visitTypeParameterList(node.typeParameterList);
+            var parameters = this.visitParameterList(node.parameterList);
+            this.movePast(node.equalsGreaterThanToken);
+            var returnType = this.visitType(node.type);
+
+            var result = new TypeScript.FunctionType(typeParameters, parameters, returnType);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitObjectType = function (node) {
+            var start = this.position;
+
+            this.movePast(node.openBraceToken);
+            var typeMembers = this.visitSeparatedSyntaxList(node.typeMembers);
+            this.movePast(node.closeBraceToken);
+
+            var result = new TypeScript.ObjectType(typeMembers);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitArrayType = function (node) {
+            var start = this.position;
+
+            var underlying = this.visitType(node.type);
+            this.movePast(node.openBracketToken);
+            this.movePast(node.closeBracketToken);
+
+            var result = new TypeScript.ArrayType(underlying);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitGenericType = function (node) {
+            var start = this.position;
+
+            var underlying = this.visitType(node.name);
+            var typeArguments = this.visitTypeArgumentList(node.typeArgumentList);
+
+            var result = new TypeScript.GenericType(underlying, typeArguments);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTypeAnnotation = function (node) {
+            if (!node) {
+                return null;
+            }
+
+            var start = this.position;
+            this.movePast(node.colonToken);
+            var type = this.visitType(node.type);
+
+            var result = new TypeScript.TypeAnnotation(type);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitBlock = function (node) {
+            if (!node) {
+                return null;
+            }
+
+            var start = this.position;
+
+            this.movePast(node.openBraceToken);
+            var statements = this.visitSyntaxList(node.statements);
+            var closeBracePosition = this.position;
+
+            var closeBraceLeadingComments = this.convertTokenLeadingComments(node.closeBraceToken, this.position);
+            var closeBraceToken = this.createTokenSpan(this.position, node.closeBraceToken);
+            this.movePast(node.closeBraceToken);
+
+            var result = new TypeScript.Block(statements, closeBraceLeadingComments, closeBraceToken);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitParameter = function (node) {
+            var start = this.position;
+
+            var dotDotDotToken = this.createTokenSpan(this.position, node.dotDotDotToken);
+
+            this.moveTo(node, node.identifier);
+            var identifier = this.visitIdentifier(node.identifier);
+
+            var questionToken = this.createTokenSpan(this.position, node.questionToken);
+            this.movePast(node.questionToken);
+            var typeExpr = this.visitTypeAnnotation(node.typeAnnotation);
+            var init = node.equalsValueClause ? node.equalsValueClause.accept(this) : null;
+
+            var modifiers = this.visitModifiers(node.modifiers);
+
+            var result = new TypeScript.Parameter(dotDotDotToken, modifiers, identifier, questionToken, typeExpr, init);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitMemberAccessExpression = function (node) {
+            var start = this.position;
+
+            var expression = node.expression.accept(this);
+            this.movePast(node.dotToken);
+            var name = this.visitIdentifier(node.name);
+
+            var result = new TypeScript.MemberAccessExpression(expression, name);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitPostfixUnaryExpression = function (node) {
+            var start = this.position;
+
+            var operand = node.operand.accept(this);
+            this.movePast(node.operatorToken);
+
+            var result = new TypeScript.PostfixUnaryExpression(node.kind() === 210 /* PostIncrementExpression */ ? 210 /* PostIncrementExpression */ : 211 /* PostDecrementExpression */, operand);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitElementAccessExpression = function (node) {
+            var start = this.position;
+
+            var expression = node.expression.accept(this);
+            this.movePast(node.openBracketToken);
+            var argumentExpression = node.argumentExpression.accept(this);
+            this.movePast(node.closeBracketToken);
+
+            var result = new TypeScript.ElementAccessExpression(expression, argumentExpression);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitInvocationExpression = function (node) {
+            var start = this.position;
+
+            var expression = node.expression.accept(this);
+            var argumentList = this.visitArgumentList(node.argumentList);
+
+            var result = new TypeScript.InvocationExpression(expression, argumentList);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitArgumentList = function (node) {
+            if (node === null) {
+                return null;
+            }
+
+            var start = this.position;
+
+            var typeArguments = this.visitTypeArgumentList(node.typeArgumentList);
+
+            this.movePast(node.openParenToken);
+
+            var _arguments = this.visitSeparatedSyntaxList(node.arguments);
+
+            if (node.arguments.fullWidth() === 0 && node.closeParenToken.fullWidth() === 0) {
+                var openParenTokenEnd = start + node.openParenToken.leadingTriviaWidth() + node.openParenToken.width();
+                this.setSpanExplicit(_arguments, openParenTokenEnd, openParenTokenEnd + node.openParenToken.trailingTriviaWidth());
+            }
+
+            var closeParenToken = this.createTokenSpan(this.position, node.closeParenToken);
+            this.movePast(node.closeParenToken);
+
+            var result = new TypeScript.ArgumentList(typeArguments, _arguments, closeParenToken);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitBinaryExpression = function (node) {
+            var start = this.position;
+
+            var left = node.left.accept(this);
+            this.movePast(node.operatorToken);
+            var right = node.right.accept(this);
+
+            var result = new TypeScript.BinaryExpression(node.kind(), left, right);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitConditionalExpression = function (node) {
+            var start = this.position;
+
+            var condition = node.condition.accept(this);
+            this.movePast(node.questionToken);
+            var whenTrue = node.whenTrue.accept(this);
+            this.movePast(node.colonToken);
+            var whenFalse = node.whenFalse.accept(this);
+
+            var result = new TypeScript.ConditionalExpression(condition, whenTrue, whenFalse);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitConstructSignature = function (node) {
+            var start = this.position;
+
+            this.movePast(node.newKeyword);
+            var callSignature = this.visitCallSignature(node.callSignature);
+
+            var result = new TypeScript.ConstructSignature(callSignature);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitMethodSignature = function (node) {
+            var start = this.position;
+
+            var name = this.visitToken(node.propertyName);
+
+            var questionToken = this.createTokenSpan(this.position, node.questionToken);
+            this.movePast(node.questionToken);
+
+            var callSignature = this.visitCallSignature(node.callSignature);
+
+            var result = new TypeScript.MethodSignature(name, questionToken, callSignature);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitIndexSignature = function (node) {
+            var start = this.position;
+
+            this.movePast(node.openBracketToken);
+
+            var parameter = node.parameter.accept(this);
+
+            this.movePast(node.closeBracketToken);
+            var returnType = this.visitTypeAnnotation(node.typeAnnotation);
+
+            var result = new TypeScript.IndexSignature(parameter, returnType);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitPropertySignature = function (node) {
+            var start = this.position;
+
+            var name = this.visitToken(node.propertyName);
+
+            var questionToken = this.createTokenSpan(this.position, node.questionToken);
+            this.movePast(node.questionToken);
+            var typeExpr = this.visitTypeAnnotation(node.typeAnnotation);
+
+            var result = new TypeScript.PropertySignature(name, questionToken, typeExpr);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitParameterList = function (node) {
+            if (!node) {
+                return null;
+            }
+
+            var start = this.position;
+
+            var openParenToken = node.openParenToken;
+
+            this.previousTokenTrailingComments = this.convertTokenTrailingComments(openParenToken, start + openParenToken.leadingTriviaWidth() + openParenToken.width());
+            var openParenTrailingComments = null;
+            if (node.parameters.childCount() === 0) {
+                openParenTrailingComments = this.previousTokenTrailingComments;
+                this.previousTokenTrailingComments = null;
+            }
+
+            this.movePast(node.openParenToken);
+            var parameters = this.visitSeparatedSyntaxList(node.parameters);
+            this.movePast(node.closeParenToken);
+
+            var result = new TypeScript.ParameterList(openParenTrailingComments, parameters);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitCallSignature = function (node) {
+            var start = this.position;
+
+            var typeParameters = this.visitTypeParameterList(node.typeParameterList);
+            var parameters = this.visitParameterList(node.parameterList);
+            var returnType = this.visitTypeAnnotation(node.typeAnnotation);
+
+            var result = new TypeScript.CallSignature(typeParameters, parameters, returnType);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTypeParameterList = function (node) {
+            if (!node) {
+                return null;
+            }
+
+            var start = this.position;
+            this.movePast(node.lessThanToken);
+            var typeParameters = this.visitSeparatedSyntaxList(node.typeParameters);
+            this.movePast(node.greaterThanToken);
+
+            var result = new TypeScript.TypeParameterList(typeParameters);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTypeParameter = function (node) {
+            var start = this.position;
+
+            var identifier = this.visitIdentifier(node.identifier);
+            var constraint = node.constraint ? node.constraint.accept(this) : null;
+
+            var result = new TypeScript.TypeParameter(identifier, constraint);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitConstraint = function (node) {
+            var start = this.position;
+            this.movePast(node.extendsKeyword);
+            var type = this.visitType(node.type);
+
+            var result = new TypeScript.Constraint(type);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitIfStatement = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.condition);
+            var condition = node.condition.accept(this);
+            this.movePast(node.closeParenToken);
+            var thenBod = node.statement.accept(this);
+            var elseBod = node.elseClause ? node.elseClause.accept(this) : null;
+
+            var result = new TypeScript.IfStatement(condition, thenBod, elseBod);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitElseClause = function (node) {
+            var start = this.position;
+
+            this.movePast(node.elseKeyword);
+            var statement = node.statement.accept(this);
+
+            var result = new TypeScript.ElseClause(statement);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitExpressionStatement = function (node) {
+            var start = this.position;
+
+            var preComments = this.convertTokenLeadingComments(node.firstToken(), start);
+            var expression = node.expression.accept(this);
+
+            var semicolonPosition = this.position;
+
+            var postComments = this.convertComments(node.semicolonToken.trailingTrivia(), this.position + node.semicolonToken.leadingTriviaWidth() + node.semicolonToken.width());
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.ExpressionStatement(expression);
+            this.setSpan(result, start, node);
+
+            result.setPreComments(preComments);
+            result.setPostComments(postComments);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitConstructorDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.callSignature);
+            var callSignature = this.visitCallSignature(node.callSignature);
+
+            var block = node.block ? node.block.accept(this) : null;
+
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.ConstructorDeclaration(callSignature, block);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitIndexMemberDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.indexSignature);
+            var indexSignature = node.indexSignature.accept(this);
+
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.IndexMemberDeclaration(indexSignature);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitMemberFunctionDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.propertyName);
+            var name = this.visitToken(node.propertyName);
+
+            var callSignature = this.visitCallSignature(node.callSignature);
+            var block = node.block ? this.visitBlock(node.block) : null;
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.MemberFunctionDeclaration(this.visitModifiers(node.modifiers), name, callSignature, block);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitGetAccessor = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.propertyName);
+            var name = this.visitToken(node.propertyName);
+            var parameters = this.visitParameterList(node.parameterList);
+            var returnType = this.visitTypeAnnotation(node.typeAnnotation);
+
+            var block = node.block ? node.block.accept(this) : null;
+            var result = new TypeScript.GetAccessor(this.visitModifiers(node.modifiers), name, parameters, returnType, block);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitSetAccessor = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.propertyName);
+            var name = this.visitToken(node.propertyName);
+            var parameters = this.visitParameterList(node.parameterList);
+            var block = node.block ? node.block.accept(this) : null;
+            var result = new TypeScript.SetAccessor(this.visitModifiers(node.modifiers), name, parameters, block);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitMemberVariableDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.variableDeclarator);
+            var variableDeclarator = node.variableDeclarator.accept(this);
+            this.movePast(node.semicolonToken);
+
+            var modifiers = this.visitModifiers(node.modifiers);
+            var result = new TypeScript.MemberVariableDeclaration(modifiers, variableDeclarator);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitThrowStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.throwKeyword);
+            var expression = node.expression.accept(this);
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.ThrowStatement(expression);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitReturnStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.returnKeyword);
+            var expression = node.expression ? node.expression.accept(this) : null;
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.ReturnStatement(expression);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitObjectCreationExpression = function (node) {
+            var start = this.position;
+
+            this.movePast(node.newKeyword);
+            var expression = node.expression.accept(this);
+            var argumentList = this.visitArgumentList(node.argumentList);
+
+            var result = new TypeScript.ObjectCreationExpression(expression, argumentList);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitSwitchStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.switchKeyword);
+            this.movePast(node.openParenToken);
+            var expression = node.expression.accept(this);
+
+            var closeParenToken = this.createTokenSpan(this.position, node.closeParenToken);
+            this.movePast(node.closeParenToken);
+            this.movePast(node.openBraceToken);
+            var switchClauses = this.visitSyntaxList(node.switchClauses);
+            this.movePast(node.closeBraceToken);
+
+            var result = new TypeScript.SwitchStatement(expression, closeParenToken, switchClauses);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitCaseSwitchClause = function (node) {
+            var start = this.position;
+
+            this.movePast(node.caseKeyword);
+            var expression = node.expression.accept(this);
+            this.movePast(node.colonToken);
+            var statements = this.visitSyntaxList(node.statements);
+
+            var result = new TypeScript.CaseSwitchClause(expression, statements);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitDefaultSwitchClause = function (node) {
+            var start = this.position;
+
+            this.movePast(node.defaultKeyword);
+            this.movePast(node.colonToken);
+            var statements = this.visitSyntaxList(node.statements);
+
+            var result = new TypeScript.DefaultSwitchClause(statements);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitBreakStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.breakKeyword);
+            var identifier = node.identifier ? node.identifier.accept(this) : null;
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.BreakStatement(identifier);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitContinueStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.continueKeyword);
+            var identifier = node.identifier ? node.identifier.accept(this) : null;
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.ContinueStatement(identifier);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitForStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.forKeyword);
+            this.movePast(node.openParenToken);
+            var variableDeclaration = node.variableDeclaration ? node.variableDeclaration.accept(this) : null;
+            var initializer = node.initializer ? node.initializer.accept(this) : null;
+
+            this.movePast(node.firstSemicolonToken);
+            var cond = node.condition ? node.condition.accept(this) : null;
+            this.movePast(node.secondSemicolonToken);
+            var incr = node.incrementor ? node.incrementor.accept(this) : null;
+            this.movePast(node.closeParenToken);
+            var body = node.statement.accept(this);
+
+            var result = new TypeScript.ForStatement(variableDeclaration, initializer, cond, incr, body);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitForInStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.forKeyword);
+            this.movePast(node.openParenToken);
+            var variableDeclaration = node.variableDeclaration ? node.variableDeclaration.accept(this) : null;
+            var left = node.left ? node.left.accept(this) : null;
+
+            this.movePast(node.inKeyword);
+            var expression = node.expression.accept(this);
+            this.movePast(node.closeParenToken);
+            var body = node.statement.accept(this);
+
+            var result = new TypeScript.ForInStatement(variableDeclaration, left, expression, body);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitWhileStatement = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.condition);
+            var condition = node.condition.accept(this);
+            this.movePast(node.closeParenToken);
+            var statement = node.statement.accept(this);
+
+            var result = new TypeScript.WhileStatement(condition, statement);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitWithStatement = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.condition);
+            var condition = node.condition.accept(this);
+            this.movePast(node.closeParenToken);
+            var statement = node.statement.accept(this);
+
+            var result = new TypeScript.WithStatement(condition, statement);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitCastExpression = function (node) {
+            var start = this.position;
+
+            this.movePast(node.lessThanToken);
+            var castTerm = this.visitType(node.type);
+            this.movePast(node.greaterThanToken);
+            var expression = node.expression.accept(this);
+
+            var result = new TypeScript.CastExpression(castTerm, expression);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitObjectLiteralExpression = function (node) {
+            var start = this.position;
+
+            var openStart = this.position + node.openBraceToken.leadingTriviaWidth();
+            this.movePast(node.openBraceToken);
+
+            var propertyAssignments = this.visitSeparatedSyntaxList(node.propertyAssignments);
+
+            var closeStart = this.position + node.closeBraceToken.leadingTriviaWidth();
+            this.movePast(node.closeBraceToken);
+
+            var result = new TypeScript.ObjectLiteralExpression(propertyAssignments);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitSimplePropertyAssignment = function (node) {
+            var start = this.position;
+
+            var preComments = this.convertTokenLeadingComments(node.firstToken(), start);
+            var postComments = this.convertNodeTrailingComments(node, node.lastToken(), start);
+
+            var propertyName = node.propertyName.accept(this);
+
+            var afterColonComments = this.convertTokenTrailingComments(node.colonToken, this.position + node.colonToken.leadingTriviaWidth() + node.colonToken.width());
+
+            this.movePast(node.colonToken);
+            var expression = node.expression.accept(this);
+            expression.setPreComments(this.mergeComments(afterColonComments, expression.preComments()));
+
+            var result = new TypeScript.SimplePropertyAssignment(propertyName, expression);
+            this.setSpan(result, start, node);
+
+            result.setPreComments(preComments);
+            result.setPostComments(postComments);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitFunctionPropertyAssignment = function (node) {
+            var start = this.position;
+
+            var propertyName = node.propertyName.accept(this);
+            var callSignature = this.visitCallSignature(node.callSignature);
+            var block = this.visitBlock(node.block);
+
+            var result = new TypeScript.FunctionPropertyAssignment(propertyName, callSignature, block);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitFunctionExpression = function (node) {
+            var start = this.position;
+
+            this.movePast(node.functionKeyword);
+            var name = node.identifier === null ? null : this.visitIdentifier(node.identifier);
+
+            var callSignature = this.visitCallSignature(node.callSignature);
+            var block = node.block ? node.block.accept(this) : null;
+
+            var result = new TypeScript.FunctionExpression(name, callSignature, block);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitEmptyStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.EmptyStatement();
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTryStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.tryKeyword);
+            var tryBody = node.block.accept(this);
+
+            var catchClause = null;
+            if (node.catchClause !== null) {
+                catchClause = node.catchClause.accept(this);
+            }
+
+            var finallyBody = null;
+            if (node.finallyClause !== null) {
+                finallyBody = node.finallyClause.accept(this);
+            }
+
+            var result = new TypeScript.TryStatement(tryBody, catchClause, finallyBody);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitCatchClause = function (node) {
+            var start = this.position;
+
+            this.movePast(node.catchKeyword);
+            this.movePast(node.openParenToken);
+            var identifier = this.visitIdentifier(node.identifier);
+            var typeAnnotation = this.visitTypeAnnotation(node.typeAnnotation);
+            this.movePast(node.closeParenToken);
+            var block = node.block.accept(this);
+
+            var result = new TypeScript.CatchClause(identifier, typeAnnotation, block);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitFinallyClause = function (node) {
+            var start = this.position;
+            this.movePast(node.finallyKeyword);
+            var block = node.block.accept(this);
+
+            var result = new TypeScript.FinallyClause(block);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitLabeledStatement = function (node) {
+            var start = this.position;
+
+            var identifier = this.visitIdentifier(node.identifier);
+            this.movePast(node.colonToken);
+            var statement = node.statement.accept(this);
+
+            var result = new TypeScript.LabeledStatement(identifier, statement);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitDoStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.doKeyword);
+            var statement = node.statement.accept(this);
+            var whileKeyword = this.createTokenSpan(this.position, node.whileKeyword);
+
+            this.movePast(node.whileKeyword);
+            this.movePast(node.openParenToken);
+            var condition = node.condition.accept(this);
+            this.movePast(node.closeParenToken);
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.DoStatement(statement, whileKeyword, condition);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTypeOfExpression = function (node) {
+            var start = this.position;
+
+            this.movePast(node.typeOfKeyword);
+            var expression = node.expression.accept(this);
+
+            var result = new TypeScript.TypeOfExpression(expression);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitDeleteExpression = function (node) {
+            var start = this.position;
+
+            this.movePast(node.deleteKeyword);
+            var expression = node.expression.accept(this);
+
+            var result = new TypeScript.DeleteExpression(expression);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitVoidExpression = function (node) {
+            var start = this.position;
+
+            this.movePast(node.voidKeyword);
+            var expression = node.expression.accept(this);
+
+            var result = new TypeScript.VoidExpression(expression);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitDebuggerStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.debuggerKeyword);
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.DebuggerStatement();
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+        return SyntaxTreeToAstVisitor;
+    })();
+    TypeScript.SyntaxTreeToAstVisitor = SyntaxTreeToAstVisitor;
+
+    function applyDelta(ast, delta) {
+        if (ast) {
+            if (ast._start !== -1) {
+                ast._start += delta;
+            }
+
+            if (ast._end !== -1) {
+                ast._end += delta;
+            }
+        }
+    }
+
+    function applyDeltaToComments(comments, delta) {
+        if (comments && comments.length > 0) {
+            for (var i = 0; i < comments.length; i++) {
+                var comment = comments[i];
+                applyDelta(comment, delta);
+            }
+        }
+    }
+
+    var SyntaxTreeToIncrementalAstVisitor = (function (_super) {
+        __extends(SyntaxTreeToIncrementalAstVisitor, _super);
+        function SyntaxTreeToIncrementalAstVisitor() {
+            _super.apply(this, arguments);
+        }
+        SyntaxTreeToIncrementalAstVisitor.prototype.applyDelta = function (ast, delta) {
+            if (delta === 0) {
+                return;
+            }
+
+            var pre = function (cur) {
+                applyDelta(cur, delta);
+                applyDeltaToComments(cur.preComments(), delta);
+                applyDeltaToComments(cur.postComments(), delta);
+
+                switch (cur.kind()) {
+                    case 146 /* Block */:
+                        applyDelta(cur.closeBraceToken, delta);
+                        break;
+
+                    case 226 /* ArgumentList */:
+                        applyDelta(cur.closeParenToken, delta);
+                        break;
+
+                    case 130 /* ModuleDeclaration */:
+                        applyDelta(cur.endingToken, delta);
+                        break;
+
+                    case 131 /* ClassDeclaration */:
+                        applyDelta(cur.closeBraceToken, delta);
+                        break;
+
+                    case 161 /* DoStatement */:
+                        applyDelta(cur.whileKeyword, delta);
+                        break;
+
+                    case 151 /* SwitchStatement */:
+                        applyDelta(cur.closeParenToken, delta);
+                        break;
+                }
+            };
+
+            TypeScript.getAstWalkerFactory().simpleWalk(ast, pre);
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.setSpanExplicit = function (span, start, end) {
+            if (span._start !== -1) {
+                var delta = start - span._start;
+                this.applyDelta(span, delta);
+
+                span._end = end;
+            } else {
+                _super.prototype.setSpanExplicit.call(this, span, start, end);
+            }
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.getAndMovePastAST = function (element) {
+            if (this.previousTokenTrailingComments !== null) {
+                return null;
+            }
+
+            var result = element._ast;
+            if (!result) {
+                return null;
+            }
+
+            var start = this.position;
+            this.movePast(element);
+            this.setSpan(result, start, element);
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.setAST = function (element, ast) {
+            element._ast = ast;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitSyntaxList = function (list) {
+            var result = this.getAndMovePastAST(list);
+            if (!result) {
+                result = _super.prototype.visitSyntaxList.call(this, list);
+
+                if (list.childCount() > 0) {
+                    this.setAST(list, result);
+                }
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitSeparatedSyntaxList = function (list) {
+            var result = this.getAndMovePastAST(list);
+            if (!result) {
+                result = _super.prototype.visitSeparatedSyntaxList.call(this, list);
+
+                if (list.childCount() > 0) {
+                    this.setAST(list, result);
+                }
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitToken = function (token) {
+            var result = this.getAndMovePastAST(token);
+
+            if (!result) {
+                result = _super.prototype.visitToken.call(this, token);
+                this.setAST(token, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitClassDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitClassDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitInterfaceDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitInterfaceDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitHeritageClause = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitHeritageClause.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitModuleDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitModuleDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitFunctionDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitImportDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitImportDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitExportAssignment = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitExportAssignment.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitPrefixUnaryExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitPrefixUnaryExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitArrayLiteralExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitArrayLiteralExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitOmittedExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitOmittedExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitParenthesizedExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitParenthesizedExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitSimpleArrowFunctionExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitSimpleArrowFunctionExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitParenthesizedArrowFunctionExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitParenthesizedArrowFunctionExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitQualifiedName = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                var result = _super.prototype.visitQualifiedName.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitConstructorType = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitConstructorType.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionType = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitFunctionType.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitObjectType = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitObjectType.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitArrayType = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitArrayType.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitGenericType = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitGenericType.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitBlock = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitBlock.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitParameter = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitParameter.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitMemberAccessExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitMemberAccessExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitPostfixUnaryExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitPostfixUnaryExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitElementAccessExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitElementAccessExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitInvocationExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitInvocationExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitBinaryExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitBinaryExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitConditionalExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitConditionalExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitConstructSignature = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitConstructSignature.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitMethodSignature = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitMethodSignature.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitIndexSignature = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitIndexSignature.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitPropertySignature = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitPropertySignature.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitCallSignature = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitCallSignature.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitTypeParameter = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitTypeParameter.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitIfStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitIfStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitExpressionStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitExpressionStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitConstructorDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitConstructorDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitMemberFunctionDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitMemberFunctionDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitGetAccessor = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitGetAccessor.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitSetAccessor = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitSetAccessor.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitMemberVariableDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitMemberVariableDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitThrowStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitThrowStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitReturnStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitReturnStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitObjectCreationExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitObjectCreationExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitSwitchStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitSwitchStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitCaseSwitchClause = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitCaseSwitchClause.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitDefaultSwitchClause = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitDefaultSwitchClause.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitBreakStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitBreakStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitContinueStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitContinueStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitForStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitForStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitForInStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitForInStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitWhileStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitWhileStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitWithStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitWithStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitCastExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitCastExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitObjectLiteralExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitObjectLiteralExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitSimplePropertyAssignment = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitSimplePropertyAssignment.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionPropertyAssignment = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitFunctionPropertyAssignment.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitFunctionExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitEmptyStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitEmptyStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitTryStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitTryStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitCatchClause = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitCatchClause.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitLabeledStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitLabeledStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitDoStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitDoStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitTypeOfExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitTypeOfExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitDeleteExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitDeleteExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitVoidExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitVoidExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitDebuggerStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitDebuggerStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+        return SyntaxTreeToIncrementalAstVisitor;
+    })(SyntaxTreeToAstVisitor);
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var ASTSpan = (function () {
+        function ASTSpan(_start, _end) {
+            this._start = _start;
+            this._end = _end;
+        }
+        ASTSpan.prototype.start = function () {
+            return this._start;
+        };
+
+        ASTSpan.prototype.end = function () {
+            return this._end;
+        };
+        return ASTSpan;
+    })();
+    TypeScript.ASTSpan = ASTSpan;
+
+    var astID = 0;
+
+    function structuralEqualsNotIncludingPosition(ast1, ast2) {
+        return structuralEquals(ast1, ast2, false);
+    }
+    TypeScript.structuralEqualsNotIncludingPosition = structuralEqualsNotIncludingPosition;
+
+    function structuralEqualsIncludingPosition(ast1, ast2) {
+        return structuralEquals(ast1, ast2, true);
+    }
+    TypeScript.structuralEqualsIncludingPosition = structuralEqualsIncludingPosition;
+
+    function commentStructuralEqualsNotIncludingPosition(ast1, ast2) {
+        return commentStructuralEquals(ast1, ast2, false);
+    }
+
+    function commentStructuralEqualsIncludingPosition(ast1, ast2) {
+        return commentStructuralEquals(ast1, ast2, true);
+    }
+
+    function structuralEquals(ast1, ast2, includingPosition) {
+        if (ast1 === ast2) {
+            return true;
+        }
+
+        return ast1 !== null && ast2 !== null && ast1.kind() === ast2.kind() && ast1.structuralEquals(ast2, includingPosition);
+    }
+
+    function commentStructuralEquals(ast1, ast2, includingPosition) {
+        if (ast1 === ast2) {
+            return true;
+        }
+
+        return ast1 !== null && ast2 !== null && ast1.structuralEquals(ast2, includingPosition);
+    }
+
+    function astArrayStructuralEquals(array1, array2, includingPosition) {
+        return TypeScript.ArrayUtilities.sequenceEquals(array1, array2, includingPosition ? structuralEqualsIncludingPosition : structuralEqualsNotIncludingPosition);
+    }
+
+    function commentArrayStructuralEquals(array1, array2, includingPosition) {
+        return TypeScript.ArrayUtilities.sequenceEquals(array1, array2, includingPosition ? commentStructuralEqualsIncludingPosition : commentStructuralEqualsNotIncludingPosition);
+    }
+
+    var AST = (function () {
+        function AST() {
+            this.parent = null;
+            this._start = -1;
+            this._end = -1;
+            this._trailingTriviaWidth = 0;
+            this._astID = astID++;
+            this._preComments = null;
+            this._postComments = null;
+        }
+        AST.prototype.syntaxID = function () {
+            return this._astID;
+        };
+
+        AST.prototype.start = function () {
+            return this._start;
+        };
+
+        AST.prototype.end = function () {
+            return this._end;
+        };
+
+        AST.prototype.trailingTriviaWidth = function () {
+            return this._trailingTriviaWidth;
+        };
+
+        AST.prototype.fileName = function () {
+            return this.parent.fileName();
+        };
+
+        AST.prototype.kind = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        AST.prototype.preComments = function () {
+            return this._preComments;
+        };
+
+        AST.prototype.postComments = function () {
+            return this._postComments;
+        };
+
+        AST.prototype.setPreComments = function (comments) {
+            if (comments && comments.length) {
+                this._preComments = comments;
+            } else if (this._preComments) {
+                this._preComments = null;
+            }
+        };
+
+        AST.prototype.setPostComments = function (comments) {
+            if (comments && comments.length) {
+                this._postComments = comments;
+            } else if (this._postComments) {
+                this._postComments = null;
+            }
+        };
+
+        AST.prototype.width = function () {
+            return this.end() - this.start();
+        };
+
+        AST.prototype.structuralEquals = function (ast, includingPosition) {
+            if (includingPosition) {
+                if (this.start() !== ast.start() || this.end() !== ast.end()) {
+                    return false;
+                }
+            }
+
+            return commentArrayStructuralEquals(this.preComments(), ast.preComments(), includingPosition) && commentArrayStructuralEquals(this.postComments(), ast.postComments(), includingPosition);
+        };
+
+        AST.prototype.isExpression = function () {
+            return false;
+        };
+        return AST;
+    })();
+    TypeScript.AST = AST;
+
+    var ISyntaxList2 = (function (_super) {
+        __extends(ISyntaxList2, _super);
+        function ISyntaxList2(_fileName, members) {
+            _super.call(this);
+            this._fileName = _fileName;
+            this.members = members;
+
+            for (var i = 0, n = members.length; i < n; i++) {
+                members[i].parent = this;
+            }
+        }
+        ISyntaxList2.prototype.childCount = function () {
+            return this.members.length;
+        };
+
+        ISyntaxList2.prototype.childAt = function (index) {
+            return this.members[index];
+        };
+
+        ISyntaxList2.prototype.fileName = function () {
+            return this._fileName;
+        };
+
+        ISyntaxList2.prototype.kind = function () {
+            return 1 /* List */;
+        };
+
+        ISyntaxList2.prototype.firstOrDefault = function (func) {
+            return TypeScript.ArrayUtilities.firstOrDefault(this.members, func);
+        };
+
+        ISyntaxList2.prototype.lastOrDefault = function (func) {
+            return TypeScript.ArrayUtilities.lastOrDefault(this.members, func);
+        };
+
+        ISyntaxList2.prototype.any = function (func) {
+            return TypeScript.ArrayUtilities.any(this.members, func);
+        };
+
+        ISyntaxList2.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && astArrayStructuralEquals(this.members, ast.members, includingPosition);
+        };
+        return ISyntaxList2;
+    })(AST);
+    TypeScript.ISyntaxList2 = ISyntaxList2;
+
+    var ISeparatedSyntaxList2 = (function (_super) {
+        __extends(ISeparatedSyntaxList2, _super);
+        function ISeparatedSyntaxList2(_fileName, members, _separatorCount) {
+            _super.call(this);
+            this._fileName = _fileName;
+            this.members = members;
+            this._separatorCount = _separatorCount;
+
+            for (var i = 0, n = members.length; i < n; i++) {
+                members[i].parent = this;
+            }
+        }
+        ISeparatedSyntaxList2.prototype.nonSeparatorCount = function () {
+            return this.members.length;
+        };
+
+        ISeparatedSyntaxList2.prototype.separatorCount = function () {
+            return this._separatorCount;
+        };
+
+        ISeparatedSyntaxList2.prototype.nonSeparatorAt = function (index) {
+            return this.members[index];
+        };
+
+        ISeparatedSyntaxList2.prototype.nonSeparatorIndexOf = function (ast) {
+            for (var i = 0, n = this.nonSeparatorCount(); i < n; i++) {
+                if (this.nonSeparatorAt(i) === ast) {
+                    return i;
+                }
+            }
+
+            return -1;
+        };
+
+        ISeparatedSyntaxList2.prototype.fileName = function () {
+            return this._fileName;
+        };
+
+        ISeparatedSyntaxList2.prototype.kind = function () {
+            return 2 /* SeparatedList */;
+        };
+
+        ISeparatedSyntaxList2.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && astArrayStructuralEquals(this.members, ast.members, includingPosition);
+        };
+        return ISeparatedSyntaxList2;
+    })(AST);
+    TypeScript.ISeparatedSyntaxList2 = ISeparatedSyntaxList2;
+
+    var SourceUnit = (function (_super) {
+        __extends(SourceUnit, _super);
+        function SourceUnit(moduleElements, endOfFileTokenLeadingComments, _fileName) {
+            _super.call(this);
+            this.moduleElements = moduleElements;
+            this.endOfFileTokenLeadingComments = endOfFileTokenLeadingComments;
+            this._fileName = _fileName;
+            moduleElements && (moduleElements.parent = this);
+        }
+        SourceUnit.prototype.fileName = function () {
+            return this._fileName;
+        };
+
+        SourceUnit.prototype.kind = function () {
+            return 120 /* SourceUnit */;
+        };
+
+        SourceUnit.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.moduleElements, ast.moduleElements, includingPosition);
+        };
+        return SourceUnit;
+    })(AST);
+    TypeScript.SourceUnit = SourceUnit;
+
+    var Identifier = (function (_super) {
+        __extends(Identifier, _super);
+        function Identifier(_text) {
+            _super.call(this);
+            this._text = _text;
+            this._valueText = null;
+        }
+        Identifier.prototype.text = function () {
+            return this._text;
+        };
+        Identifier.prototype.valueText = function () {
+            if (!this._valueText) {
+                var text = this._text;
+                if (text === "__proto__") {
+                    this._valueText = "#__proto__";
+                } else {
+                    this._valueText = TypeScript.Syntax.massageEscapes(text);
+                }
+            }
+
+            return this._valueText;
+        };
+
+        Identifier.prototype.kind = function () {
+            return 11 /* IdentifierName */;
+        };
+
+        Identifier.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && this._text === ast._text;
+        };
+
+        Identifier.prototype.isExpression = function () {
+            return true;
+        };
+        return Identifier;
+    })(AST);
+    TypeScript.Identifier = Identifier;
+
+    var LiteralExpression = (function (_super) {
+        __extends(LiteralExpression, _super);
+        function LiteralExpression(_nodeType, _text, _valueText) {
+            _super.call(this);
+            this._nodeType = _nodeType;
+            this._text = _text;
+            this._valueText = _valueText;
+        }
+        LiteralExpression.prototype.text = function () {
+            return this._text;
+        };
+
+        LiteralExpression.prototype.valueText = function () {
+            return this._valueText;
+        };
+
+        LiteralExpression.prototype.kind = function () {
+            return this._nodeType;
+        };
+
+        LiteralExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition);
+        };
+
+        LiteralExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return LiteralExpression;
+    })(AST);
+    TypeScript.LiteralExpression = LiteralExpression;
+
+    var ThisExpression = (function (_super) {
+        __extends(ThisExpression, _super);
+        function ThisExpression(_text, _valueText) {
+            _super.call(this);
+            this._text = _text;
+            this._valueText = _valueText;
+        }
+        ThisExpression.prototype.text = function () {
+            return this._text;
+        };
+
+        ThisExpression.prototype.valueText = function () {
+            return this._valueText;
+        };
+
+        ThisExpression.prototype.kind = function () {
+            return 35 /* ThisKeyword */;
+        };
+
+        ThisExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition);
+        };
+
+        ThisExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ThisExpression;
+    })(AST);
+    TypeScript.ThisExpression = ThisExpression;
+
+    var SuperExpression = (function (_super) {
+        __extends(SuperExpression, _super);
+        function SuperExpression(_text, _valueText) {
+            _super.call(this);
+            this._text = _text;
+            this._valueText = _valueText;
+        }
+        SuperExpression.prototype.text = function () {
+            return this._text;
+        };
+
+        SuperExpression.prototype.valueText = function () {
+            return this._valueText;
+        };
+
+        SuperExpression.prototype.kind = function () {
+            return 50 /* SuperKeyword */;
+        };
+
+        SuperExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition);
+        };
+
+        SuperExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return SuperExpression;
+    })(AST);
+    TypeScript.SuperExpression = SuperExpression;
+
+    var NumericLiteral = (function (_super) {
+        __extends(NumericLiteral, _super);
+        function NumericLiteral(_value, _text, _valueText) {
+            _super.call(this);
+            this._value = _value;
+            this._text = _text;
+            this._valueText = _valueText;
+        }
+        NumericLiteral.prototype.text = function () {
+            return this._text;
+        };
+        NumericLiteral.prototype.valueText = function () {
+            return this._valueText;
+        };
+        NumericLiteral.prototype.value = function () {
+            return this._value;
+        };
+
+        NumericLiteral.prototype.kind = function () {
+            return 13 /* NumericLiteral */;
+        };
+
+        NumericLiteral.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && (this._value === ast._value || (isNaN(this._value) && isNaN(ast._value))) && this._text === ast._text;
+        };
+
+        NumericLiteral.prototype.isExpression = function () {
+            return true;
+        };
+        return NumericLiteral;
+    })(AST);
+    TypeScript.NumericLiteral = NumericLiteral;
+
+    var RegularExpressionLiteral = (function (_super) {
+        __extends(RegularExpressionLiteral, _super);
+        function RegularExpressionLiteral(_text, _valueText) {
+            _super.call(this);
+            this._text = _text;
+            this._valueText = _valueText;
+        }
+        RegularExpressionLiteral.prototype.text = function () {
+            return this._text;
+        };
+
+        RegularExpressionLiteral.prototype.valueText = function () {
+            return this._valueText;
+        };
+
+        RegularExpressionLiteral.prototype.kind = function () {
+            return 12 /* RegularExpressionLiteral */;
+        };
+
+        RegularExpressionLiteral.prototype.isExpression = function () {
+            return true;
+        };
+        return RegularExpressionLiteral;
+    })(AST);
+    TypeScript.RegularExpressionLiteral = RegularExpressionLiteral;
+
+    var StringLiteral = (function (_super) {
+        __extends(StringLiteral, _super);
+        function StringLiteral(_text, _valueText) {
+            _super.call(this);
+            this._text = _text;
+            this._valueText = _valueText;
+            this._valueText = _valueText === "__proto__" ? "#__proto__" : _valueText;
+        }
+        StringLiteral.prototype.text = function () {
+            return this._text;
+        };
+        StringLiteral.prototype.valueText = function () {
+            return this._valueText;
+        };
+
+        StringLiteral.prototype.kind = function () {
+            return 14 /* StringLiteral */;
+        };
+
+        StringLiteral.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && this._text === ast._text;
+        };
+
+        StringLiteral.prototype.isExpression = function () {
+            return true;
+        };
+        return StringLiteral;
+    })(AST);
+    TypeScript.StringLiteral = StringLiteral;
+
+    var TypeAnnotation = (function (_super) {
+        __extends(TypeAnnotation, _super);
+        function TypeAnnotation(type) {
+            _super.call(this);
+            this.type = type;
+            type && (type.parent = this);
+        }
+        TypeAnnotation.prototype.kind = function () {
+            return 244 /* TypeAnnotation */;
+        };
+        return TypeAnnotation;
+    })(AST);
+    TypeScript.TypeAnnotation = TypeAnnotation;
+
+    var BuiltInType = (function (_super) {
+        __extends(BuiltInType, _super);
+        function BuiltInType(_nodeType, _text, _valueText) {
+            _super.call(this);
+            this._nodeType = _nodeType;
+            this._text = _text;
+            this._valueText = _valueText;
+        }
+        BuiltInType.prototype.text = function () {
+            return this._text;
+        };
+
+        BuiltInType.prototype.valueText = function () {
+            return this._valueText;
+        };
+
+        BuiltInType.prototype.kind = function () {
+            return this._nodeType;
+        };
+        return BuiltInType;
+    })(AST);
+    TypeScript.BuiltInType = BuiltInType;
+
+    var ExternalModuleReference = (function (_super) {
+        __extends(ExternalModuleReference, _super);
+        function ExternalModuleReference(stringLiteral) {
+            _super.call(this);
+            this.stringLiteral = stringLiteral;
+            stringLiteral && (stringLiteral.parent = this);
+        }
+        ExternalModuleReference.prototype.kind = function () {
+            return 245 /* ExternalModuleReference */;
+        };
+        return ExternalModuleReference;
+    })(AST);
+    TypeScript.ExternalModuleReference = ExternalModuleReference;
+
+    var ModuleNameModuleReference = (function (_super) {
+        __extends(ModuleNameModuleReference, _super);
+        function ModuleNameModuleReference(moduleName) {
+            _super.call(this);
+            this.moduleName = moduleName;
+            moduleName && (moduleName.parent = this);
+        }
+        ModuleNameModuleReference.prototype.kind = function () {
+            return 246 /* ModuleNameModuleReference */;
+        };
+        return ModuleNameModuleReference;
+    })(AST);
+    TypeScript.ModuleNameModuleReference = ModuleNameModuleReference;
+
+    var ImportDeclaration = (function (_super) {
+        __extends(ImportDeclaration, _super);
+        function ImportDeclaration(modifiers, identifier, moduleReference) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.identifier = identifier;
+            this.moduleReference = moduleReference;
+            identifier && (identifier.parent = this);
+            moduleReference && (moduleReference.parent = this);
+        }
+        ImportDeclaration.prototype.kind = function () {
+            return 133 /* ImportDeclaration */;
+        };
+
+        ImportDeclaration.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.moduleReference, ast.moduleReference, includingPosition);
+        };
+        return ImportDeclaration;
+    })(AST);
+    TypeScript.ImportDeclaration = ImportDeclaration;
+
+    var ExportAssignment = (function (_super) {
+        __extends(ExportAssignment, _super);
+        function ExportAssignment(identifier) {
+            _super.call(this);
+            this.identifier = identifier;
+            identifier && (identifier.parent = this);
+        }
+        ExportAssignment.prototype.kind = function () {
+            return 134 /* ExportAssignment */;
+        };
+
+        ExportAssignment.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition);
+        };
+        return ExportAssignment;
+    })(AST);
+    TypeScript.ExportAssignment = ExportAssignment;
+
+    var TypeParameterList = (function (_super) {
+        __extends(TypeParameterList, _super);
+        function TypeParameterList(typeParameters) {
+            _super.call(this);
+            this.typeParameters = typeParameters;
+            typeParameters && (typeParameters.parent = this);
+        }
+        TypeParameterList.prototype.kind = function () {
+            return 229 /* TypeParameterList */;
+        };
+        return TypeParameterList;
+    })(AST);
+    TypeScript.TypeParameterList = TypeParameterList;
+
+    var ClassDeclaration = (function (_super) {
+        __extends(ClassDeclaration, _super);
+        function ClassDeclaration(modifiers, identifier, typeParameterList, heritageClauses, classElements, closeBraceToken) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.identifier = identifier;
+            this.typeParameterList = typeParameterList;
+            this.heritageClauses = heritageClauses;
+            this.classElements = classElements;
+            this.closeBraceToken = closeBraceToken;
+            identifier && (identifier.parent = this);
+            typeParameterList && (typeParameterList.parent = this);
+            heritageClauses && (heritageClauses.parent = this);
+            classElements && (classElements.parent = this);
+        }
+        ClassDeclaration.prototype.kind = function () {
+            return 131 /* ClassDeclaration */;
+        };
+
+        ClassDeclaration.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.classElements, ast.classElements, includingPosition) && structuralEquals(this.typeParameterList, ast.typeParameterList, includingPosition) && structuralEquals(this.heritageClauses, ast.heritageClauses, includingPosition);
+        };
+        return ClassDeclaration;
+    })(AST);
+    TypeScript.ClassDeclaration = ClassDeclaration;
+
+    var InterfaceDeclaration = (function (_super) {
+        __extends(InterfaceDeclaration, _super);
+        function InterfaceDeclaration(modifiers, identifier, typeParameterList, heritageClauses, body) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.identifier = identifier;
+            this.typeParameterList = typeParameterList;
+            this.heritageClauses = heritageClauses;
+            this.body = body;
+            identifier && (identifier.parent = this);
+            typeParameterList && (typeParameterList.parent = this);
+            body && (body.parent = this);
+            heritageClauses && (heritageClauses.parent = this);
+        }
+        InterfaceDeclaration.prototype.kind = function () {
+            return 128 /* InterfaceDeclaration */;
+        };
+
+        InterfaceDeclaration.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.body, ast.body, includingPosition) && structuralEquals(this.typeParameterList, ast.typeParameterList, includingPosition) && structuralEquals(this.heritageClauses, ast.heritageClauses, includingPosition);
+        };
+        return InterfaceDeclaration;
+    })(AST);
+    TypeScript.InterfaceDeclaration = InterfaceDeclaration;
+
+    var HeritageClause = (function (_super) {
+        __extends(HeritageClause, _super);
+        function HeritageClause(_nodeType, typeNames) {
+            _super.call(this);
+            this._nodeType = _nodeType;
+            this.typeNames = typeNames;
+            typeNames && (typeNames.parent = this);
+        }
+        HeritageClause.prototype.kind = function () {
+            return this._nodeType;
+        };
+
+        HeritageClause.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.typeNames, ast.typeNames, includingPosition);
+        };
+        return HeritageClause;
+    })(AST);
+    TypeScript.HeritageClause = HeritageClause;
+
+    var ModuleDeclaration = (function (_super) {
+        __extends(ModuleDeclaration, _super);
+        function ModuleDeclaration(modifiers, name, stringLiteral, moduleElements, endingToken) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.name = name;
+            this.stringLiteral = stringLiteral;
+            this.moduleElements = moduleElements;
+            this.endingToken = endingToken;
+            name && (name.parent = this);
+            stringLiteral && (stringLiteral.parent = this);
+            moduleElements && (moduleElements.parent = this);
+        }
+        ModuleDeclaration.prototype.kind = function () {
+            return 130 /* ModuleDeclaration */;
+        };
+
+        ModuleDeclaration.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.name, ast.name, includingPosition) && structuralEquals(this.moduleElements, ast.moduleElements, includingPosition);
+        };
+        return ModuleDeclaration;
+    })(AST);
+    TypeScript.ModuleDeclaration = ModuleDeclaration;
+
+    var FunctionDeclaration = (function (_super) {
+        __extends(FunctionDeclaration, _super);
+        function FunctionDeclaration(modifiers, identifier, callSignature, block) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.identifier = identifier;
+            this.callSignature = callSignature;
+            this.block = block;
+            identifier && (identifier.parent = this);
+            callSignature && (callSignature.parent = this);
+            block && (block.parent = this);
+        }
+        FunctionDeclaration.prototype.kind = function () {
+            return 129 /* FunctionDeclaration */;
+        };
+
+        FunctionDeclaration.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.block, ast.block, includingPosition) && structuralEquals(this.callSignature, ast.callSignature, includingPosition);
+        };
+        return FunctionDeclaration;
+    })(AST);
+    TypeScript.FunctionDeclaration = FunctionDeclaration;
+
+    var VariableStatement = (function (_super) {
+        __extends(VariableStatement, _super);
+        function VariableStatement(modifiers, declaration) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.declaration = declaration;
+            declaration && (declaration.parent = this);
+        }
+        VariableStatement.prototype.kind = function () {
+            return 148 /* VariableStatement */;
+        };
+
+        VariableStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.declaration, ast.declaration, includingPosition);
+        };
+        return VariableStatement;
+    })(AST);
+    TypeScript.VariableStatement = VariableStatement;
+
+    var VariableDeclaration = (function (_super) {
+        __extends(VariableDeclaration, _super);
+        function VariableDeclaration(declarators) {
+            _super.call(this);
+            this.declarators = declarators;
+            declarators && (declarators.parent = this);
+        }
+        VariableDeclaration.prototype.kind = function () {
+            return 224 /* VariableDeclaration */;
+        };
+
+        VariableDeclaration.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.declarators, ast.declarators, includingPosition);
+        };
+        return VariableDeclaration;
+    })(AST);
+    TypeScript.VariableDeclaration = VariableDeclaration;
+
+    var VariableDeclarator = (function (_super) {
+        __extends(VariableDeclarator, _super);
+        function VariableDeclarator(propertyName, typeAnnotation, equalsValueClause) {
+            _super.call(this);
+            this.propertyName = propertyName;
+            this.typeAnnotation = typeAnnotation;
+            this.equalsValueClause = equalsValueClause;
+            propertyName && (propertyName.parent = this);
+            typeAnnotation && (typeAnnotation.parent = this);
+            equalsValueClause && (equalsValueClause.parent = this);
+        }
+        VariableDeclarator.prototype.kind = function () {
+            return 225 /* VariableDeclarator */;
+        };
+        return VariableDeclarator;
+    })(AST);
+    TypeScript.VariableDeclarator = VariableDeclarator;
+
+    var EqualsValueClause = (function (_super) {
+        __extends(EqualsValueClause, _super);
+        function EqualsValueClause(value) {
+            _super.call(this);
+            this.value = value;
+            value && (value.parent = this);
+        }
+        EqualsValueClause.prototype.kind = function () {
+            return 232 /* EqualsValueClause */;
+        };
+        return EqualsValueClause;
+    })(AST);
+    TypeScript.EqualsValueClause = EqualsValueClause;
+
+    var PrefixUnaryExpression = (function (_super) {
+        __extends(PrefixUnaryExpression, _super);
+        function PrefixUnaryExpression(_nodeType, operand) {
+            _super.call(this);
+            this._nodeType = _nodeType;
+            this.operand = operand;
+            operand && (operand.parent = this);
+        }
+        PrefixUnaryExpression.prototype.kind = function () {
+            return this._nodeType;
+        };
+
+        PrefixUnaryExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.operand, ast.operand, includingPosition);
+        };
+
+        PrefixUnaryExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return PrefixUnaryExpression;
+    })(AST);
+    TypeScript.PrefixUnaryExpression = PrefixUnaryExpression;
+
+    var ArrayLiteralExpression = (function (_super) {
+        __extends(ArrayLiteralExpression, _super);
+        function ArrayLiteralExpression(expressions) {
+            _super.call(this);
+            this.expressions = expressions;
+            expressions && (expressions.parent = this);
+        }
+        ArrayLiteralExpression.prototype.kind = function () {
+            return 214 /* ArrayLiteralExpression */;
+        };
+
+        ArrayLiteralExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expressions, ast.expressions, includingPosition);
+        };
+
+        ArrayLiteralExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ArrayLiteralExpression;
+    })(AST);
+    TypeScript.ArrayLiteralExpression = ArrayLiteralExpression;
+
+    var OmittedExpression = (function (_super) {
+        __extends(OmittedExpression, _super);
+        function OmittedExpression() {
+            _super.apply(this, arguments);
+        }
+        OmittedExpression.prototype.kind = function () {
+            return 223 /* OmittedExpression */;
+        };
+
+        OmittedExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition);
+        };
+
+        OmittedExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return OmittedExpression;
+    })(AST);
+    TypeScript.OmittedExpression = OmittedExpression;
+
+    var ParenthesizedExpression = (function (_super) {
+        __extends(ParenthesizedExpression, _super);
+        function ParenthesizedExpression(openParenTrailingComments, expression) {
+            _super.call(this);
+            this.openParenTrailingComments = openParenTrailingComments;
+            this.expression = expression;
+            expression && (expression.parent = this);
+        }
+        ParenthesizedExpression.prototype.kind = function () {
+            return 217 /* ParenthesizedExpression */;
+        };
+
+        ParenthesizedExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+
+        ParenthesizedExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ParenthesizedExpression;
+    })(AST);
+    TypeScript.ParenthesizedExpression = ParenthesizedExpression;
+
+    var SimpleArrowFunctionExpression = (function (_super) {
+        __extends(SimpleArrowFunctionExpression, _super);
+        function SimpleArrowFunctionExpression(identifier, block, expression) {
+            _super.call(this);
+            this.identifier = identifier;
+            this.block = block;
+            this.expression = expression;
+            identifier && (identifier.parent = this);
+            block && (block.parent = this);
+            expression && (expression.parent = this);
+        }
+        SimpleArrowFunctionExpression.prototype.kind = function () {
+            return 219 /* SimpleArrowFunctionExpression */;
+        };
+
+        SimpleArrowFunctionExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return SimpleArrowFunctionExpression;
+    })(AST);
+    TypeScript.SimpleArrowFunctionExpression = SimpleArrowFunctionExpression;
+
+    var ParenthesizedArrowFunctionExpression = (function (_super) {
+        __extends(ParenthesizedArrowFunctionExpression, _super);
+        function ParenthesizedArrowFunctionExpression(callSignature, block, expression) {
+            _super.call(this);
+            this.callSignature = callSignature;
+            this.block = block;
+            this.expression = expression;
+            callSignature && (callSignature.parent = this);
+            block && (block.parent = this);
+            expression && (expression.parent = this);
+        }
+        ParenthesizedArrowFunctionExpression.prototype.kind = function () {
+            return 218 /* ParenthesizedArrowFunctionExpression */;
+        };
+
+        ParenthesizedArrowFunctionExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ParenthesizedArrowFunctionExpression;
+    })(AST);
+    TypeScript.ParenthesizedArrowFunctionExpression = ParenthesizedArrowFunctionExpression;
+
+    var QualifiedName = (function (_super) {
+        __extends(QualifiedName, _super);
+        function QualifiedName(left, right) {
+            _super.call(this);
+            this.left = left;
+            this.right = right;
+            left && (left.parent = this);
+            right && (right.parent = this);
+        }
+        QualifiedName.prototype.kind = function () {
+            return 121 /* QualifiedName */;
+        };
+
+        QualifiedName.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.left, ast.left, includingPosition) && structuralEquals(this.right, ast.right, includingPosition);
+        };
+        return QualifiedName;
+    })(AST);
+    TypeScript.QualifiedName = QualifiedName;
+
+    var ParameterList = (function (_super) {
+        __extends(ParameterList, _super);
+        function ParameterList(openParenTrailingComments, parameters) {
+            _super.call(this);
+            this.openParenTrailingComments = openParenTrailingComments;
+            this.parameters = parameters;
+            parameters && (parameters.parent = this);
+        }
+        ParameterList.prototype.kind = function () {
+            return 227 /* ParameterList */;
+        };
+        return ParameterList;
+    })(AST);
+    TypeScript.ParameterList = ParameterList;
+
+    var ConstructorType = (function (_super) {
+        __extends(ConstructorType, _super);
+        function ConstructorType(typeParameterList, parameterList, type) {
+            _super.call(this);
+            this.typeParameterList = typeParameterList;
+            this.parameterList = parameterList;
+            this.type = type;
+            typeParameterList && (typeParameterList.parent = this);
+            parameterList && (parameterList.parent = this);
+            type && (type.parent = this);
+        }
+        ConstructorType.prototype.kind = function () {
+            return 125 /* ConstructorType */;
+        };
+        return ConstructorType;
+    })(AST);
+    TypeScript.ConstructorType = ConstructorType;
+
+    var FunctionType = (function (_super) {
+        __extends(FunctionType, _super);
+        function FunctionType(typeParameterList, parameterList, type) {
+            _super.call(this);
+            this.typeParameterList = typeParameterList;
+            this.parameterList = parameterList;
+            this.type = type;
+            typeParameterList && (typeParameterList.parent = this);
+            parameterList && (parameterList.parent = this);
+            type && (type.parent = this);
+        }
+        FunctionType.prototype.kind = function () {
+            return 123 /* FunctionType */;
+        };
+        return FunctionType;
+    })(AST);
+    TypeScript.FunctionType = FunctionType;
+
+    var ObjectType = (function (_super) {
+        __extends(ObjectType, _super);
+        function ObjectType(typeMembers) {
+            _super.call(this);
+            this.typeMembers = typeMembers;
+            typeMembers && (typeMembers.parent = this);
+        }
+        ObjectType.prototype.kind = function () {
+            return 122 /* ObjectType */;
+        };
+
+        ObjectType.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.typeMembers, ast.typeMembers, includingPosition);
+        };
+        return ObjectType;
+    })(AST);
+    TypeScript.ObjectType = ObjectType;
+
+    var ArrayType = (function (_super) {
+        __extends(ArrayType, _super);
+        function ArrayType(type) {
+            _super.call(this);
+            this.type = type;
+            type && (type.parent = this);
+        }
+        ArrayType.prototype.kind = function () {
+            return 124 /* ArrayType */;
+        };
+
+        ArrayType.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.type, ast.type, includingPosition);
+        };
+        return ArrayType;
+    })(AST);
+    TypeScript.ArrayType = ArrayType;
+
+    var TypeArgumentList = (function (_super) {
+        __extends(TypeArgumentList, _super);
+        function TypeArgumentList(typeArguments) {
+            _super.call(this);
+            this.typeArguments = typeArguments;
+            typeArguments && (typeArguments.parent = this);
+        }
+        TypeArgumentList.prototype.kind = function () {
+            return 228 /* TypeArgumentList */;
+        };
+        return TypeArgumentList;
+    })(AST);
+    TypeScript.TypeArgumentList = TypeArgumentList;
+
+    var GenericType = (function (_super) {
+        __extends(GenericType, _super);
+        function GenericType(name, typeArgumentList) {
+            _super.call(this);
+            this.name = name;
+            this.typeArgumentList = typeArgumentList;
+            name && (name.parent = this);
+            typeArgumentList && (typeArgumentList.parent = this);
+        }
+        GenericType.prototype.kind = function () {
+            return 126 /* GenericType */;
+        };
+
+        GenericType.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.name, ast.name, includingPosition) && structuralEquals(this.typeArgumentList, ast.typeArgumentList, includingPosition);
+        };
+        return GenericType;
+    })(AST);
+    TypeScript.GenericType = GenericType;
+
+    var TypeQuery = (function (_super) {
+        __extends(TypeQuery, _super);
+        function TypeQuery(name) {
+            _super.call(this);
+            this.name = name;
+            name && (name.parent = this);
+        }
+        TypeQuery.prototype.kind = function () {
+            return 127 /* TypeQuery */;
+        };
+
+        TypeQuery.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.name, ast.name, includingPosition);
+        };
+        return TypeQuery;
+    })(AST);
+    TypeScript.TypeQuery = TypeQuery;
+
+    var Block = (function (_super) {
+        __extends(Block, _super);
+        function Block(statements, closeBraceLeadingComments, closeBraceToken) {
+            _super.call(this);
+            this.statements = statements;
+            this.closeBraceLeadingComments = closeBraceLeadingComments;
+            this.closeBraceToken = closeBraceToken;
+            statements && (statements.parent = this);
+        }
+        Block.prototype.kind = function () {
+            return 146 /* Block */;
+        };
+
+        Block.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statements, ast.statements, includingPosition);
+        };
+        return Block;
+    })(AST);
+    TypeScript.Block = Block;
+
+    var Parameter = (function (_super) {
+        __extends(Parameter, _super);
+        function Parameter(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) {
+            _super.call(this);
+            this.dotDotDotToken = dotDotDotToken;
+            this.modifiers = modifiers;
+            this.identifier = identifier;
+            this.questionToken = questionToken;
+            this.typeAnnotation = typeAnnotation;
+            this.equalsValueClause = equalsValueClause;
+            identifier && (identifier.parent = this);
+            typeAnnotation && (typeAnnotation.parent = this);
+            equalsValueClause && (equalsValueClause.parent = this);
+        }
+        Parameter.prototype.kind = function () {
+            return 242 /* Parameter */;
+        };
+        return Parameter;
+    })(AST);
+    TypeScript.Parameter = Parameter;
+
+    var MemberAccessExpression = (function (_super) {
+        __extends(MemberAccessExpression, _super);
+        function MemberAccessExpression(expression, name) {
+            _super.call(this);
+            this.expression = expression;
+            this.name = name;
+            expression && (expression.parent = this);
+            name && (name.parent = this);
+        }
+        MemberAccessExpression.prototype.kind = function () {
+            return 212 /* MemberAccessExpression */;
+        };
+
+        MemberAccessExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.name, ast.name, includingPosition);
+        };
+
+        MemberAccessExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return MemberAccessExpression;
+    })(AST);
+    TypeScript.MemberAccessExpression = MemberAccessExpression;
+
+    var PostfixUnaryExpression = (function (_super) {
+        __extends(PostfixUnaryExpression, _super);
+        function PostfixUnaryExpression(_nodeType, operand) {
+            _super.call(this);
+            this._nodeType = _nodeType;
+            this.operand = operand;
+            operand && (operand.parent = this);
+        }
+        PostfixUnaryExpression.prototype.kind = function () {
+            return this._nodeType;
+        };
+
+        PostfixUnaryExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.operand, ast.operand, includingPosition);
+        };
+
+        PostfixUnaryExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return PostfixUnaryExpression;
+    })(AST);
+    TypeScript.PostfixUnaryExpression = PostfixUnaryExpression;
+
+    var ElementAccessExpression = (function (_super) {
+        __extends(ElementAccessExpression, _super);
+        function ElementAccessExpression(expression, argumentExpression) {
+            _super.call(this);
+            this.expression = expression;
+            this.argumentExpression = argumentExpression;
+            expression && (expression.parent = this);
+            argumentExpression && (argumentExpression.parent = this);
+        }
+        ElementAccessExpression.prototype.kind = function () {
+            return 221 /* ElementAccessExpression */;
+        };
+
+        ElementAccessExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.argumentExpression, ast.argumentExpression, includingPosition);
+        };
+
+        ElementAccessExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ElementAccessExpression;
+    })(AST);
+    TypeScript.ElementAccessExpression = ElementAccessExpression;
+
+    var InvocationExpression = (function (_super) {
+        __extends(InvocationExpression, _super);
+        function InvocationExpression(expression, argumentList) {
+            _super.call(this);
+            this.expression = expression;
+            this.argumentList = argumentList;
+            expression && (expression.parent = this);
+            argumentList && (argumentList.parent = this);
+        }
+        InvocationExpression.prototype.kind = function () {
+            return 213 /* InvocationExpression */;
+        };
+
+        InvocationExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.argumentList, ast.argumentList, includingPosition);
+        };
+
+        InvocationExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return InvocationExpression;
+    })(AST);
+    TypeScript.InvocationExpression = InvocationExpression;
+
+    var ArgumentList = (function (_super) {
+        __extends(ArgumentList, _super);
+        function ArgumentList(typeArgumentList, _arguments, closeParenToken) {
+            _super.call(this);
+            this.typeArgumentList = typeArgumentList;
+            this.closeParenToken = closeParenToken;
+            this.arguments = _arguments;
+
+            typeArgumentList && (typeArgumentList.parent = this);
+            _arguments && (_arguments.parent = this);
+        }
+        ArgumentList.prototype.kind = function () {
+            return 226 /* ArgumentList */;
+        };
+        return ArgumentList;
+    })(AST);
+    TypeScript.ArgumentList = ArgumentList;
+
+    var BinaryExpression = (function (_super) {
+        __extends(BinaryExpression, _super);
+        function BinaryExpression(_nodeType, left, right) {
+            _super.call(this);
+            this._nodeType = _nodeType;
+            this.left = left;
+            this.right = right;
+            left && (left.parent = this);
+            right && (right.parent = this);
+        }
+        BinaryExpression.prototype.kind = function () {
+            return this._nodeType;
+        };
+
+        BinaryExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.left, ast.left, includingPosition) && structuralEquals(this.right, ast.right, includingPosition);
+        };
+
+        BinaryExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return BinaryExpression;
+    })(AST);
+    TypeScript.BinaryExpression = BinaryExpression;
+
+    var ConditionalExpression = (function (_super) {
+        __extends(ConditionalExpression, _super);
+        function ConditionalExpression(condition, whenTrue, whenFalse) {
+            _super.call(this);
+            this.condition = condition;
+            this.whenTrue = whenTrue;
+            this.whenFalse = whenFalse;
+            condition && (condition.parent = this);
+            whenTrue && (whenTrue.parent = this);
+            whenFalse && (whenFalse.parent = this);
+        }
+        ConditionalExpression.prototype.kind = function () {
+            return 186 /* ConditionalExpression */;
+        };
+
+        ConditionalExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.whenTrue, ast.whenTrue, includingPosition) && structuralEquals(this.whenFalse, ast.whenFalse, includingPosition);
+        };
+
+        ConditionalExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ConditionalExpression;
+    })(AST);
+    TypeScript.ConditionalExpression = ConditionalExpression;
+
+    var ConstructSignature = (function (_super) {
+        __extends(ConstructSignature, _super);
+        function ConstructSignature(callSignature) {
+            _super.call(this);
+            this.callSignature = callSignature;
+            callSignature && (callSignature.parent = this);
+        }
+        ConstructSignature.prototype.kind = function () {
+            return 143 /* ConstructSignature */;
+        };
+        return ConstructSignature;
+    })(AST);
+    TypeScript.ConstructSignature = ConstructSignature;
+
+    var MethodSignature = (function (_super) {
+        __extends(MethodSignature, _super);
+        function MethodSignature(propertyName, questionToken, callSignature) {
+            _super.call(this);
+            this.propertyName = propertyName;
+            this.questionToken = questionToken;
+            this.callSignature = callSignature;
+            propertyName && (propertyName.parent = this);
+            callSignature && (callSignature.parent = this);
+        }
+        MethodSignature.prototype.kind = function () {
+            return 145 /* MethodSignature */;
+        };
+        return MethodSignature;
+    })(AST);
+    TypeScript.MethodSignature = MethodSignature;
+
+    var IndexSignature = (function (_super) {
+        __extends(IndexSignature, _super);
+        function IndexSignature(parameter, typeAnnotation) {
+            _super.call(this);
+            this.parameter = parameter;
+            this.typeAnnotation = typeAnnotation;
+            parameter && (parameter.parent = this);
+            typeAnnotation && (typeAnnotation.parent = this);
+        }
+        IndexSignature.prototype.kind = function () {
+            return 144 /* IndexSignature */;
+        };
+        return IndexSignature;
+    })(AST);
+    TypeScript.IndexSignature = IndexSignature;
+
+    var PropertySignature = (function (_super) {
+        __extends(PropertySignature, _super);
+        function PropertySignature(propertyName, questionToken, typeAnnotation) {
+            _super.call(this);
+            this.propertyName = propertyName;
+            this.questionToken = questionToken;
+            this.typeAnnotation = typeAnnotation;
+            propertyName && (propertyName.parent = this);
+            typeAnnotation && (typeAnnotation.parent = this);
+        }
+        PropertySignature.prototype.kind = function () {
+            return 141 /* PropertySignature */;
+        };
+        return PropertySignature;
+    })(AST);
+    TypeScript.PropertySignature = PropertySignature;
+
+    var CallSignature = (function (_super) {
+        __extends(CallSignature, _super);
+        function CallSignature(typeParameterList, parameterList, typeAnnotation) {
+            _super.call(this);
+            this.typeParameterList = typeParameterList;
+            this.parameterList = parameterList;
+            this.typeAnnotation = typeAnnotation;
+            typeParameterList && (typeParameterList.parent = this);
+            parameterList && (parameterList.parent = this);
+            typeAnnotation && (typeAnnotation.parent = this);
+        }
+        CallSignature.prototype.kind = function () {
+            return 142 /* CallSignature */;
+        };
+        return CallSignature;
+    })(AST);
+    TypeScript.CallSignature = CallSignature;
+
+    var TypeParameter = (function (_super) {
+        __extends(TypeParameter, _super);
+        function TypeParameter(identifier, constraint) {
+            _super.call(this);
+            this.identifier = identifier;
+            this.constraint = constraint;
+            identifier && (identifier.parent = this);
+            constraint && (constraint.parent = this);
+        }
+        TypeParameter.prototype.kind = function () {
+            return 238 /* TypeParameter */;
+        };
+
+        TypeParameter.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.constraint, ast.constraint, includingPosition);
+        };
+        return TypeParameter;
+    })(AST);
+    TypeScript.TypeParameter = TypeParameter;
+
+    var Constraint = (function (_super) {
+        __extends(Constraint, _super);
+        function Constraint(type) {
+            _super.call(this);
+            this.type = type;
+            type && (type.parent = this);
+        }
+        Constraint.prototype.kind = function () {
+            return 239 /* Constraint */;
+        };
+        return Constraint;
+    })(AST);
+    TypeScript.Constraint = Constraint;
+
+    var ElseClause = (function (_super) {
+        __extends(ElseClause, _super);
+        function ElseClause(statement) {
+            _super.call(this);
+            this.statement = statement;
+            statement && (statement.parent = this);
+        }
+        ElseClause.prototype.kind = function () {
+            return 235 /* ElseClause */;
+        };
+
+        ElseClause.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition);
+        };
+        return ElseClause;
+    })(AST);
+    TypeScript.ElseClause = ElseClause;
+
+    var IfStatement = (function (_super) {
+        __extends(IfStatement, _super);
+        function IfStatement(condition, statement, elseClause) {
+            _super.call(this);
+            this.condition = condition;
+            this.statement = statement;
+            this.elseClause = elseClause;
+            condition && (condition.parent = this);
+            statement && (statement.parent = this);
+            elseClause && (elseClause.parent = this);
+        }
+        IfStatement.prototype.kind = function () {
+            return 147 /* IfStatement */;
+        };
+
+        IfStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition) && structuralEquals(this.elseClause, ast.elseClause, includingPosition);
+        };
+        return IfStatement;
+    })(AST);
+    TypeScript.IfStatement = IfStatement;
+
+    var ExpressionStatement = (function (_super) {
+        __extends(ExpressionStatement, _super);
+        function ExpressionStatement(expression) {
+            _super.call(this);
+            this.expression = expression;
+            expression && (expression.parent = this);
+        }
+        ExpressionStatement.prototype.kind = function () {
+            return 149 /* ExpressionStatement */;
+        };
+
+        ExpressionStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+        return ExpressionStatement;
+    })(AST);
+    TypeScript.ExpressionStatement = ExpressionStatement;
+
+    var ConstructorDeclaration = (function (_super) {
+        __extends(ConstructorDeclaration, _super);
+        function ConstructorDeclaration(callSignature, block) {
+            _super.call(this);
+            this.callSignature = callSignature;
+            this.block = block;
+            callSignature && (callSignature.parent = this);
+            block && (block.parent = this);
+        }
+        ConstructorDeclaration.prototype.kind = function () {
+            return 137 /* ConstructorDeclaration */;
+        };
+        return ConstructorDeclaration;
+    })(AST);
+    TypeScript.ConstructorDeclaration = ConstructorDeclaration;
+
+    var MemberFunctionDeclaration = (function (_super) {
+        __extends(MemberFunctionDeclaration, _super);
+        function MemberFunctionDeclaration(modifiers, propertyName, callSignature, block) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.propertyName = propertyName;
+            this.callSignature = callSignature;
+            this.block = block;
+            propertyName && (propertyName.parent = this);
+            callSignature && (callSignature.parent = this);
+            block && (block.parent = this);
+        }
+        MemberFunctionDeclaration.prototype.kind = function () {
+            return 135 /* MemberFunctionDeclaration */;
+        };
+        return MemberFunctionDeclaration;
+    })(AST);
+    TypeScript.MemberFunctionDeclaration = MemberFunctionDeclaration;
+
+    var GetAccessor = (function (_super) {
+        __extends(GetAccessor, _super);
+        function GetAccessor(modifiers, propertyName, parameterList, typeAnnotation, block) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.propertyName = propertyName;
+            this.parameterList = parameterList;
+            this.typeAnnotation = typeAnnotation;
+            this.block = block;
+            propertyName && (propertyName.parent = this);
+            parameterList && (parameterList.parent = this);
+            typeAnnotation && (typeAnnotation.parent = this);
+            block && (block.parent = this);
+        }
+        GetAccessor.prototype.kind = function () {
+            return 139 /* GetAccessor */;
+        };
+        return GetAccessor;
+    })(AST);
+    TypeScript.GetAccessor = GetAccessor;
+
+    var SetAccessor = (function (_super) {
+        __extends(SetAccessor, _super);
+        function SetAccessor(modifiers, propertyName, parameterList, block) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.propertyName = propertyName;
+            this.parameterList = parameterList;
+            this.block = block;
+            propertyName && (propertyName.parent = this);
+            parameterList && (parameterList.parent = this);
+            block && (block.parent = this);
+        }
+        SetAccessor.prototype.kind = function () {
+            return 140 /* SetAccessor */;
+        };
+        return SetAccessor;
+    })(AST);
+    TypeScript.SetAccessor = SetAccessor;
+
+    var MemberVariableDeclaration = (function (_super) {
+        __extends(MemberVariableDeclaration, _super);
+        function MemberVariableDeclaration(modifiers, variableDeclarator) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.variableDeclarator = variableDeclarator;
+            variableDeclarator && (variableDeclarator.parent = this);
+        }
+        MemberVariableDeclaration.prototype.kind = function () {
+            return 136 /* MemberVariableDeclaration */;
+        };
+        return MemberVariableDeclaration;
+    })(AST);
+    TypeScript.MemberVariableDeclaration = MemberVariableDeclaration;
+
+    var IndexMemberDeclaration = (function (_super) {
+        __extends(IndexMemberDeclaration, _super);
+        function IndexMemberDeclaration(indexSignature) {
+            _super.call(this);
+            this.indexSignature = indexSignature;
+            indexSignature && (indexSignature.parent = this);
+        }
+        IndexMemberDeclaration.prototype.kind = function () {
+            return 138 /* IndexMemberDeclaration */;
+        };
+        return IndexMemberDeclaration;
+    })(AST);
+    TypeScript.IndexMemberDeclaration = IndexMemberDeclaration;
+
+    var ThrowStatement = (function (_super) {
+        __extends(ThrowStatement, _super);
+        function ThrowStatement(expression) {
+            _super.call(this);
+            this.expression = expression;
+            expression && (expression.parent = this);
+        }
+        ThrowStatement.prototype.kind = function () {
+            return 157 /* ThrowStatement */;
+        };
+
+        ThrowStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+        return ThrowStatement;
+    })(AST);
+    TypeScript.ThrowStatement = ThrowStatement;
+
+    var ReturnStatement = (function (_super) {
+        __extends(ReturnStatement, _super);
+        function ReturnStatement(expression) {
+            _super.call(this);
+            this.expression = expression;
+            expression && (expression.parent = this);
+        }
+        ReturnStatement.prototype.kind = function () {
+            return 150 /* ReturnStatement */;
+        };
+
+        ReturnStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+        return ReturnStatement;
+    })(AST);
+    TypeScript.ReturnStatement = ReturnStatement;
+
+    var ObjectCreationExpression = (function (_super) {
+        __extends(ObjectCreationExpression, _super);
+        function ObjectCreationExpression(expression, argumentList) {
+            _super.call(this);
+            this.expression = expression;
+            this.argumentList = argumentList;
+            expression && (expression.parent = this);
+            argumentList && (argumentList.parent = this);
+        }
+        ObjectCreationExpression.prototype.kind = function () {
+            return 216 /* ObjectCreationExpression */;
+        };
+
+        ObjectCreationExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.argumentList, ast.argumentList, includingPosition);
+        };
+
+        ObjectCreationExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ObjectCreationExpression;
+    })(AST);
+    TypeScript.ObjectCreationExpression = ObjectCreationExpression;
+
+    var SwitchStatement = (function (_super) {
+        __extends(SwitchStatement, _super);
+        function SwitchStatement(expression, closeParenToken, switchClauses) {
+            _super.call(this);
+            this.expression = expression;
+            this.closeParenToken = closeParenToken;
+            this.switchClauses = switchClauses;
+            expression && (expression.parent = this);
+            switchClauses && (switchClauses.parent = this);
+        }
+        SwitchStatement.prototype.kind = function () {
+            return 151 /* SwitchStatement */;
+        };
+
+        SwitchStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.switchClauses, ast.switchClauses, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+        return SwitchStatement;
+    })(AST);
+    TypeScript.SwitchStatement = SwitchStatement;
+
+    var CaseSwitchClause = (function (_super) {
+        __extends(CaseSwitchClause, _super);
+        function CaseSwitchClause(expression, statements) {
+            _super.call(this);
+            this.expression = expression;
+            this.statements = statements;
+            expression && (expression.parent = this);
+            statements && (statements.parent = this);
+        }
+        CaseSwitchClause.prototype.kind = function () {
+            return 233 /* CaseSwitchClause */;
+        };
+
+        CaseSwitchClause.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.statements, ast.statements, includingPosition);
+        };
+        return CaseSwitchClause;
+    })(AST);
+    TypeScript.CaseSwitchClause = CaseSwitchClause;
+
+    var DefaultSwitchClause = (function (_super) {
+        __extends(DefaultSwitchClause, _super);
+        function DefaultSwitchClause(statements) {
+            _super.call(this);
+            this.statements = statements;
+            statements && (statements.parent = this);
+        }
+        DefaultSwitchClause.prototype.kind = function () {
+            return 234 /* DefaultSwitchClause */;
+        };
+
+        DefaultSwitchClause.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statements, ast.statements, includingPosition);
+        };
+        return DefaultSwitchClause;
+    })(AST);
+    TypeScript.DefaultSwitchClause = DefaultSwitchClause;
+
+    var BreakStatement = (function (_super) {
+        __extends(BreakStatement, _super);
+        function BreakStatement(identifier) {
+            _super.call(this);
+            this.identifier = identifier;
+        }
+        BreakStatement.prototype.kind = function () {
+            return 152 /* BreakStatement */;
+        };
+
+        BreakStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition);
+        };
+        return BreakStatement;
+    })(AST);
+    TypeScript.BreakStatement = BreakStatement;
+
+    var ContinueStatement = (function (_super) {
+        __extends(ContinueStatement, _super);
+        function ContinueStatement(identifier) {
+            _super.call(this);
+            this.identifier = identifier;
+        }
+        ContinueStatement.prototype.kind = function () {
+            return 153 /* ContinueStatement */;
+        };
+
+        ContinueStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition);
+        };
+        return ContinueStatement;
+    })(AST);
+    TypeScript.ContinueStatement = ContinueStatement;
+
+    var ForStatement = (function (_super) {
+        __extends(ForStatement, _super);
+        function ForStatement(variableDeclaration, initializer, condition, incrementor, statement) {
+            _super.call(this);
+            this.variableDeclaration = variableDeclaration;
+            this.initializer = initializer;
+            this.condition = condition;
+            this.incrementor = incrementor;
+            this.statement = statement;
+            variableDeclaration && (variableDeclaration.parent = this);
+            initializer && (initializer.parent = this);
+            condition && (condition.parent = this);
+            incrementor && (incrementor.parent = this);
+            statement && (statement.parent = this);
+        }
+        ForStatement.prototype.kind = function () {
+            return 154 /* ForStatement */;
+        };
+
+        ForStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.initializer, ast.initializer, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.incrementor, ast.incrementor, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition);
+        };
+        return ForStatement;
+    })(AST);
+    TypeScript.ForStatement = ForStatement;
+
+    var ForInStatement = (function (_super) {
+        __extends(ForInStatement, _super);
+        function ForInStatement(variableDeclaration, left, expression, statement) {
+            _super.call(this);
+            this.variableDeclaration = variableDeclaration;
+            this.left = left;
+            this.expression = expression;
+            this.statement = statement;
+            variableDeclaration && (variableDeclaration.parent = this);
+            left && (left.parent = this);
+            expression && (expression.parent = this);
+            statement && (statement.parent = this);
+        }
+        ForInStatement.prototype.kind = function () {
+            return 155 /* ForInStatement */;
+        };
+
+        ForInStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.variableDeclaration, ast.variableDeclaration, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition);
+        };
+        return ForInStatement;
+    })(AST);
+    TypeScript.ForInStatement = ForInStatement;
+
+    var WhileStatement = (function (_super) {
+        __extends(WhileStatement, _super);
+        function WhileStatement(condition, statement) {
+            _super.call(this);
+            this.condition = condition;
+            this.statement = statement;
+            condition && (condition.parent = this);
+            statement && (statement.parent = this);
+        }
+        WhileStatement.prototype.kind = function () {
+            return 158 /* WhileStatement */;
+        };
+
+        WhileStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition);
+        };
+        return WhileStatement;
+    })(AST);
+    TypeScript.WhileStatement = WhileStatement;
+
+    var WithStatement = (function (_super) {
+        __extends(WithStatement, _super);
+        function WithStatement(condition, statement) {
+            _super.call(this);
+            this.condition = condition;
+            this.statement = statement;
+            condition && (condition.parent = this);
+            statement && (statement.parent = this);
+        }
+        WithStatement.prototype.kind = function () {
+            return 163 /* WithStatement */;
+        };
+
+        WithStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition);
+        };
+        return WithStatement;
+    })(AST);
+    TypeScript.WithStatement = WithStatement;
+
+    var EnumDeclaration = (function (_super) {
+        __extends(EnumDeclaration, _super);
+        function EnumDeclaration(modifiers, identifier, enumElements) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.identifier = identifier;
+            this.enumElements = enumElements;
+            identifier && (identifier.parent = this);
+            enumElements && (enumElements.parent = this);
+        }
+        EnumDeclaration.prototype.kind = function () {
+            return 132 /* EnumDeclaration */;
+        };
+        return EnumDeclaration;
+    })(AST);
+    TypeScript.EnumDeclaration = EnumDeclaration;
+
+    var EnumElement = (function (_super) {
+        __extends(EnumElement, _super);
+        function EnumElement(propertyName, equalsValueClause) {
+            _super.call(this);
+            this.propertyName = propertyName;
+            this.equalsValueClause = equalsValueClause;
+            propertyName && (propertyName.parent = this);
+            equalsValueClause && (equalsValueClause.parent = this);
+        }
+        EnumElement.prototype.kind = function () {
+            return 243 /* EnumElement */;
+        };
+        return EnumElement;
+    })(AST);
+    TypeScript.EnumElement = EnumElement;
+
+    var CastExpression = (function (_super) {
+        __extends(CastExpression, _super);
+        function CastExpression(type, expression) {
+            _super.call(this);
+            this.type = type;
+            this.expression = expression;
+            type && (type.parent = this);
+            expression && (expression.parent = this);
+        }
+        CastExpression.prototype.kind = function () {
+            return 220 /* CastExpression */;
+        };
+
+        CastExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.type, ast.type, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+
+        CastExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return CastExpression;
+    })(AST);
+    TypeScript.CastExpression = CastExpression;
+
+    var ObjectLiteralExpression = (function (_super) {
+        __extends(ObjectLiteralExpression, _super);
+        function ObjectLiteralExpression(propertyAssignments) {
+            _super.call(this);
+            this.propertyAssignments = propertyAssignments;
+            propertyAssignments && (propertyAssignments.parent = this);
+        }
+        ObjectLiteralExpression.prototype.kind = function () {
+            return 215 /* ObjectLiteralExpression */;
+        };
+
+        ObjectLiteralExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.propertyAssignments, ast.propertyAssignments, includingPosition);
+        };
+
+        ObjectLiteralExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ObjectLiteralExpression;
+    })(AST);
+    TypeScript.ObjectLiteralExpression = ObjectLiteralExpression;
+
+    var SimplePropertyAssignment = (function (_super) {
+        __extends(SimplePropertyAssignment, _super);
+        function SimplePropertyAssignment(propertyName, expression) {
+            _super.call(this);
+            this.propertyName = propertyName;
+            this.expression = expression;
+            propertyName && (propertyName.parent = this);
+            expression && (expression.parent = this);
+        }
+        SimplePropertyAssignment.prototype.kind = function () {
+            return 240 /* SimplePropertyAssignment */;
+        };
+        return SimplePropertyAssignment;
+    })(AST);
+    TypeScript.SimplePropertyAssignment = SimplePropertyAssignment;
+
+    var FunctionPropertyAssignment = (function (_super) {
+        __extends(FunctionPropertyAssignment, _super);
+        function FunctionPropertyAssignment(propertyName, callSignature, block) {
+            _super.call(this);
+            this.propertyName = propertyName;
+            this.callSignature = callSignature;
+            this.block = block;
+            propertyName && (propertyName.parent = this);
+            callSignature && (callSignature.parent = this);
+            block && (block.parent = this);
+        }
+        FunctionPropertyAssignment.prototype.kind = function () {
+            return 241 /* FunctionPropertyAssignment */;
+        };
+        return FunctionPropertyAssignment;
+    })(AST);
+    TypeScript.FunctionPropertyAssignment = FunctionPropertyAssignment;
+
+    var FunctionExpression = (function (_super) {
+        __extends(FunctionExpression, _super);
+        function FunctionExpression(identifier, callSignature, block) {
+            _super.call(this);
+            this.identifier = identifier;
+            this.callSignature = callSignature;
+            this.block = block;
+            identifier && (identifier.parent = this);
+            callSignature && (callSignature.parent = this);
+            block && (block.parent = this);
+        }
+        FunctionExpression.prototype.kind = function () {
+            return 222 /* FunctionExpression */;
+        };
+
+        FunctionExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return FunctionExpression;
+    })(AST);
+    TypeScript.FunctionExpression = FunctionExpression;
+
+    var EmptyStatement = (function (_super) {
+        __extends(EmptyStatement, _super);
+        function EmptyStatement() {
+            _super.apply(this, arguments);
+        }
+        EmptyStatement.prototype.kind = function () {
+            return 156 /* EmptyStatement */;
+        };
+
+        EmptyStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition);
+        };
+        return EmptyStatement;
+    })(AST);
+    TypeScript.EmptyStatement = EmptyStatement;
+
+    var TryStatement = (function (_super) {
+        __extends(TryStatement, _super);
+        function TryStatement(block, catchClause, finallyClause) {
+            _super.call(this);
+            this.block = block;
+            this.catchClause = catchClause;
+            this.finallyClause = finallyClause;
+            block && (block.parent = this);
+            catchClause && (catchClause.parent = this);
+            finallyClause && (finallyClause.parent = this);
+        }
+        TryStatement.prototype.kind = function () {
+            return 159 /* TryStatement */;
+        };
+
+        TryStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.block, ast.block, includingPosition) && structuralEquals(this.catchClause, ast.catchClause, includingPosition) && structuralEquals(this.finallyClause, ast.finallyClause, includingPosition);
+        };
+        return TryStatement;
+    })(AST);
+    TypeScript.TryStatement = TryStatement;
+
+    var CatchClause = (function (_super) {
+        __extends(CatchClause, _super);
+        function CatchClause(identifier, typeAnnotation, block) {
+            _super.call(this);
+            this.identifier = identifier;
+            this.typeAnnotation = typeAnnotation;
+            this.block = block;
+            identifier && (identifier.parent = this);
+            typeAnnotation && (typeAnnotation.parent = this);
+            block && (block.parent = this);
+        }
+        CatchClause.prototype.kind = function () {
+            return 236 /* CatchClause */;
+        };
+
+        CatchClause.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.typeAnnotation, ast.typeAnnotation, includingPosition) && structuralEquals(this.block, ast.block, includingPosition);
+        };
+        return CatchClause;
+    })(AST);
+    TypeScript.CatchClause = CatchClause;
+
+    var FinallyClause = (function (_super) {
+        __extends(FinallyClause, _super);
+        function FinallyClause(block) {
+            _super.call(this);
+            this.block = block;
+            block && (block.parent = this);
+        }
+        FinallyClause.prototype.kind = function () {
+            return 237 /* FinallyClause */;
+        };
+
+        FinallyClause.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.block, ast.block, includingPosition);
+        };
+        return FinallyClause;
+    })(AST);
+    TypeScript.FinallyClause = FinallyClause;
+
+    var LabeledStatement = (function (_super) {
+        __extends(LabeledStatement, _super);
+        function LabeledStatement(identifier, statement) {
+            _super.call(this);
+            this.identifier = identifier;
+            this.statement = statement;
+            identifier && (identifier.parent = this);
+            statement && (statement.parent = this);
+        }
+        LabeledStatement.prototype.kind = function () {
+            return 160 /* LabeledStatement */;
+        };
+
+        LabeledStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition);
+        };
+        return LabeledStatement;
+    })(AST);
+    TypeScript.LabeledStatement = LabeledStatement;
+
+    var DoStatement = (function (_super) {
+        __extends(DoStatement, _super);
+        function DoStatement(statement, whileKeyword, condition) {
+            _super.call(this);
+            this.statement = statement;
+            this.whileKeyword = whileKeyword;
+            this.condition = condition;
+            statement && (statement.parent = this);
+            condition && (condition.parent = this);
+        }
+        DoStatement.prototype.kind = function () {
+            return 161 /* DoStatement */;
+        };
+
+        DoStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition);
+        };
+        return DoStatement;
+    })(AST);
+    TypeScript.DoStatement = DoStatement;
+
+    var TypeOfExpression = (function (_super) {
+        __extends(TypeOfExpression, _super);
+        function TypeOfExpression(expression) {
+            _super.call(this);
+            this.expression = expression;
+            expression && (expression.parent = this);
+        }
+        TypeOfExpression.prototype.kind = function () {
+            return 171 /* TypeOfExpression */;
+        };
+
+        TypeOfExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+
+        TypeOfExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return TypeOfExpression;
+    })(AST);
+    TypeScript.TypeOfExpression = TypeOfExpression;
+
+    var DeleteExpression = (function (_super) {
+        __extends(DeleteExpression, _super);
+        function DeleteExpression(expression) {
+            _super.call(this);
+            this.expression = expression;
+            expression && (expression.parent = this);
+        }
+        DeleteExpression.prototype.kind = function () {
+            return 170 /* DeleteExpression */;
+        };
+
+        DeleteExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+
+        DeleteExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return DeleteExpression;
+    })(AST);
+    TypeScript.DeleteExpression = DeleteExpression;
+
+    var VoidExpression = (function (_super) {
+        __extends(VoidExpression, _super);
+        function VoidExpression(expression) {
+            _super.call(this);
+            this.expression = expression;
+            expression && (expression.parent = this);
+        }
+        VoidExpression.prototype.kind = function () {
+            return 172 /* VoidExpression */;
+        };
+
+        VoidExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+
+        VoidExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return VoidExpression;
+    })(AST);
+    TypeScript.VoidExpression = VoidExpression;
+
+    var DebuggerStatement = (function (_super) {
+        __extends(DebuggerStatement, _super);
+        function DebuggerStatement() {
+            _super.apply(this, arguments);
+        }
+        DebuggerStatement.prototype.kind = function () {
+            return 162 /* DebuggerStatement */;
+        };
+        return DebuggerStatement;
+    })(AST);
+    TypeScript.DebuggerStatement = DebuggerStatement;
+
+    var Comment = (function () {
+        function Comment(_trivia, endsLine, _start, _end) {
+            this._trivia = _trivia;
+            this.endsLine = endsLine;
+            this._start = _start;
+            this._end = _end;
+        }
+        Comment.prototype.start = function () {
+            return this._start;
+        };
+
+        Comment.prototype.end = function () {
+            return this._end;
+        };
+
+        Comment.prototype.fullText = function () {
+            return this._trivia.fullText();
+        };
+
+        Comment.prototype.kind = function () {
+            return this._trivia.kind();
+        };
+
+        Comment.prototype.structuralEquals = function (ast, includingPosition) {
+            if (includingPosition) {
+                if (this.start() !== ast.start() || this.end() !== ast.end()) {
+                    return false;
+                }
+            }
+
+            return this._trivia.fullText() === ast._trivia.fullText() && this.endsLine === ast.endsLine;
+        };
+        return Comment;
+    })();
+    TypeScript.Comment = Comment;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (IOUtils) {
+        function createDirectoryStructure(ioHost, dirName) {
+            if (ioHost.directoryExists(dirName)) {
+                return;
+            }
+
+            var parentDirectory = ioHost.dirName(dirName);
+            if (parentDirectory != "") {
+                createDirectoryStructure(ioHost, parentDirectory);
+            }
+            ioHost.createDirectory(dirName);
+        }
+
+        function writeFileAndFolderStructure(ioHost, fileName, contents, writeByteOrderMark) {
+            var start = new Date().getTime();
+            var path = ioHost.resolvePath(fileName);
+            TypeScript.ioHostResolvePathTime += new Date().getTime() - start;
+
+            var start = new Date().getTime();
+            var dirName = ioHost.dirName(path);
+            TypeScript.ioHostDirectoryNameTime += new Date().getTime() - start;
+
+            var start = new Date().getTime();
+            createDirectoryStructure(ioHost, dirName);
+            TypeScript.ioHostCreateDirectoryStructureTime += new Date().getTime() - start;
+
+            var start = new Date().getTime();
+            ioHost.writeFile(path, contents, writeByteOrderMark);
+            TypeScript.ioHostWriteFileTime += new Date().getTime() - start;
+        }
+        IOUtils.writeFileAndFolderStructure = writeFileAndFolderStructure;
+
+        function throwIOError(message, error) {
+            var errorMessage = message;
+            if (error && error.message) {
+                errorMessage += (" " + error.message);
+            }
+            throw new Error(errorMessage);
+        }
+        IOUtils.throwIOError = throwIOError;
+
+        function combine(prefix, suffix) {
+            return prefix + "/" + suffix;
+        }
+        IOUtils.combine = combine;
+
+        var BufferedTextWriter = (function () {
+            function BufferedTextWriter(writer, capacity) {
+                if (typeof capacity === "undefined") { capacity = 1024; }
+                this.writer = writer;
+                this.capacity = capacity;
+                this.buffer = "";
+            }
+            BufferedTextWriter.prototype.Write = function (str) {
+                this.buffer += str;
+                if (this.buffer.length >= this.capacity) {
+                    this.writer.Write(this.buffer);
+                    this.buffer = "";
+                }
+            };
+            BufferedTextWriter.prototype.WriteLine = function (str) {
+                this.Write(str + '\r\n');
+            };
+            BufferedTextWriter.prototype.Close = function () {
+                this.writer.Write(this.buffer);
+                this.writer.Close();
+                this.buffer = null;
+            };
+            return BufferedTextWriter;
+        })();
+        IOUtils.BufferedTextWriter = BufferedTextWriter;
+    })(TypeScript.IOUtils || (TypeScript.IOUtils = {}));
+    var IOUtils = TypeScript.IOUtils;
+
+    TypeScript.IO = (function () {
+        function getWindowsScriptHostIO() {
+            var fso = new ActiveXObject("Scripting.FileSystemObject");
+            var streamObjectPool = [];
+
+            function getStreamObject() {
+                if (streamObjectPool.length > 0) {
+                    return streamObjectPool.pop();
+                } else {
+                    return new ActiveXObject("ADODB.Stream");
+                }
+            }
+
+            function releaseStreamObject(obj) {
+                streamObjectPool.push(obj);
+            }
+
+            var args = [];
+            for (var i = 0; i < WScript.Arguments.length; i++) {
+                args[i] = WScript.Arguments.Item(i);
+            }
+
+            return {
+                appendFile: function (path, content) {
+                    var txtFile = fso.OpenTextFile(path, 8, true);
+                    txtFile.Write(content);
+                    txtFile.Close();
+                },
+                readFile: function (path, codepage) {
+                    return TypeScript.Environment.readFile(path, codepage);
+                },
+                writeFile: function (path, contents, writeByteOrderMark) {
+                    TypeScript.Environment.writeFile(path, contents, writeByteOrderMark);
+                },
+                fileExists: function (path) {
+                    return fso.FileExists(path);
+                },
+                resolvePath: function (path) {
+                    return fso.GetAbsolutePathName(path);
+                },
+                dirName: function (path) {
+                    return fso.GetParentFolderName(path);
+                },
+                findFile: function (rootPath, partialFilePath) {
+                    var path = fso.GetAbsolutePathName(rootPath) + "/" + partialFilePath;
+
+                    while (true) {
+                        if (fso.FileExists(path)) {
+                            return { fileInformation: this.readFile(path), path: path };
+                        } else {
+                            rootPath = fso.GetParentFolderName(fso.GetAbsolutePathName(rootPath));
+
+                            if (rootPath == "") {
+                                return null;
+                            } else {
+                                path = fso.BuildPath(rootPath, partialFilePath);
+                            }
+                        }
+                    }
+                },
+                deleteFile: function (path) {
+                    try  {
+                        if (fso.FileExists(path)) {
+                            fso.DeleteFile(path, true);
+                        }
+                    } catch (e) {
+                        IOUtils.throwIOError(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Could_not_delete_file_0, [path]), e);
+                    }
+                },
+                directoryExists: function (path) {
+                    return fso.FolderExists(path);
+                },
+                createDirectory: function (path) {
+                    try  {
+                        if (!this.directoryExists(path)) {
+                            fso.CreateFolder(path);
+                        }
+                    } catch (e) {
+                        IOUtils.throwIOError(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Could_not_create_directory_0, [path]), e);
+                    }
+                },
+                dir: function (path, spec, options) {
+                    options = options || {};
+                    function filesInFolder(folder, root) {
+                        var paths = [];
+                        var fc;
+
+                        if (options.recursive) {
+                            fc = new Enumerator(folder.subfolders);
+
+                            for (; !fc.atEnd(); fc.moveNext()) {
+                                paths = paths.concat(filesInFolder(fc.item(), root + "/" + fc.item().Name));
+                            }
+                        }
+
+                        fc = new Enumerator(folder.files);
+
+                        for (; !fc.atEnd(); fc.moveNext()) {
+                            if (!spec || fc.item().Name.match(spec)) {
+                                paths.push(root + "/" + fc.item().Name);
+                            }
+                        }
+
+                        return paths;
+                    }
+
+                    var folder = fso.GetFolder(path);
+                    var paths = [];
+
+                    return filesInFolder(folder, path);
+                },
+                print: function (str) {
+                    WScript.StdOut.Write(str);
+                },
+                printLine: function (str) {
+                    WScript.Echo(str);
+                },
+                arguments: args,
+                stderr: WScript.StdErr,
+                stdout: WScript.StdOut,
+                watchFile: null,
+                run: function (source, fileName) {
+                    try  {
+                        eval(source);
+                    } catch (e) {
+                        IOUtils.throwIOError(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Error_while_executing_file_0, [fileName]), e);
+                    }
+                },
+                getExecutingFilePath: function () {
+                    return WScript.ScriptFullName;
+                },
+                quit: function (exitCode) {
+                    if (typeof exitCode === "undefined") { exitCode = 0; }
+                    try  {
+                        WScript.Quit(exitCode);
+                    } catch (e) {
+                    }
+                }
+            };
+        }
+        ;
+
+        function getNodeIO() {
+            var _fs = require('fs');
+            var _path = require('path');
+            var _module = require('module');
+
+            return {
+                appendFile: function (path, content) {
+                    _fs.appendFileSync(path, content);
+                },
+                readFile: function (file, codepage) {
+                    return TypeScript.Environment.readFile(file, codepage);
+                },
+                writeFile: function (path, contents, writeByteOrderMark) {
+                    TypeScript.Environment.writeFile(path, contents, writeByteOrderMark);
+                },
+                deleteFile: function (path) {
+                    try  {
+                        _fs.unlinkSync(path);
+                    } catch (e) {
+                        IOUtils.throwIOError(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Could_not_delete_file_0, [path]), e);
+                    }
+                },
+                fileExists: function (path) {
+                    return _fs.existsSync(path);
+                },
+                dir: function dir(path, spec, options) {
+                    options = options || {};
+
+                    function filesInFolder(folder) {
+                        var paths = [];
+
+                        try  {
+                            var files = _fs.readdirSync(folder);
+                            for (var i = 0; i < files.length; i++) {
+                                var stat = _fs.statSync(folder + "/" + files[i]);
+                                if (options.recursive && stat.isDirectory()) {
+                                    paths = paths.concat(filesInFolder(folder + "/" + files[i]));
+                                } else if (stat.isFile() && (!spec || files[i].match(spec))) {
+                                    paths.push(folder + "/" + files[i]);
+                                }
+                            }
+                        } catch (err) {
+                        }
+
+                        return paths;
+                    }
+
+                    return filesInFolder(path);
+                },
+                createDirectory: function (path) {
+                    try  {
+                        if (!this.directoryExists(path)) {
+                            _fs.mkdirSync(path);
+                        }
+                    } catch (e) {
+                        IOUtils.throwIOError(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Could_not_create_directory_0, [path]), e);
+                    }
+                },
+                directoryExists: function (path) {
+                    return _fs.existsSync(path) && _fs.statSync(path).isDirectory();
+                },
+                resolvePath: function (path) {
+                    return _path.resolve(path);
+                },
+                dirName: function (path) {
+                    var dirPath = _path.dirname(path);
+
+                    if (dirPath === path) {
+                        dirPath = null;
+                    }
+
+                    return dirPath;
+                },
+                findFile: function (rootPath, partialFilePath) {
+                    var path = rootPath + "/" + partialFilePath;
+
+                    while (true) {
+                        if (_fs.existsSync(path)) {
+                            return { fileInformation: this.readFile(path), path: path };
+                        } else {
+                            var parentPath = _path.resolve(rootPath, "..");
+
+                            if (rootPath === parentPath) {
+                                return null;
+                            } else {
+                                rootPath = parentPath;
+                                path = _path.resolve(rootPath, partialFilePath);
+                            }
+                        }
+                    }
+                },
+                print: function (str) {
+                    process.stdout.write(str);
+                },
+                printLine: function (str) {
+                    process.stdout.write(str + '\n');
+                },
+                arguments: process.argv.slice(2),
+                stderr: {
+                    Write: function (str) {
+                        process.stderr.write(str);
+                    },
+                    WriteLine: function (str) {
+                        process.stderr.write(str + '\n');
+                    },
+                    Close: function () {
+                    }
+                },
+                stdout: {
+                    Write: function (str) {
+                        process.stdout.write(str);
+                    },
+                    WriteLine: function (str) {
+                        process.stdout.write(str + '\n');
+                    },
+                    Close: function () {
+                    }
+                },
+                watchFile: function (fileName, callback) {
+                    var firstRun = true;
+                    var processingChange = false;
+
+                    var fileChanged = function (curr, prev) {
+                        if (!firstRun) {
+                            if (curr.mtime < prev.mtime) {
+                                return;
+                            }
+
+                            _fs.unwatchFile(fileName, fileChanged);
+                            if (!processingChange) {
+                                processingChange = true;
+                                callback(fileName);
+                                setTimeout(function () {
+                                    processingChange = false;
+                                }, 100);
+                            }
+                        }
+                        firstRun = false;
+                        _fs.watchFile(fileName, { persistent: true, interval: 500 }, fileChanged);
+                    };
+
+                    fileChanged();
+                    return {
+                        fileName: fileName,
+                        close: function () {
+                            _fs.unwatchFile(fileName, fileChanged);
+                        }
+                    };
+                },
+                run: function (source, fileName) {
+                    require.main.fileName = fileName;
+                    require.main.paths = _module._nodeModulePaths(_path.dirname(_fs.realpathSync(fileName)));
+                    require.main._compile(source, fileName);
+                },
+                getExecutingFilePath: function () {
+                    return process.mainModule.filename;
+                },
+                quit: function (code) {
+                    var stderrFlushed = process.stderr.write('');
+                    var stdoutFlushed = process.stdout.write('');
+                    process.stderr.on('drain', function () {
+                        stderrFlushed = true;
+                        if (stdoutFlushed) {
+                            process.exit(code);
+                        }
+                    });
+                    process.stdout.on('drain', function () {
+                        stdoutFlushed = true;
+                        if (stderrFlushed) {
+                            process.exit(code);
+                        }
+                    });
+                    setTimeout(function () {
+                        process.exit(code);
+                    }, 5);
+                }
+            };
+        }
+        ;
+
+        if (typeof WScript !== "undefined" && typeof ActiveXObject === "function")
+            return getWindowsScriptHostIO();
+        else if (typeof module !== 'undefined' && module.exports)
+            return getNodeIO();
+        else
+            return null;
+    })();
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var OptionsParser = (function () {
+        function OptionsParser(host, version) {
+            this.host = host;
+            this.version = version;
+            this.DEFAULT_SHORT_FLAG = "-";
+            this.DEFAULT_LONG_FLAG = "--";
+            this.printedVersion = false;
+            this.unnamed = [];
+            this.options = [];
+        }
+        OptionsParser.prototype.findOption = function (arg) {
+            var upperCaseArg = arg && arg.toUpperCase();
+
+            for (var i = 0; i < this.options.length; i++) {
+                var current = this.options[i];
+
+                if (upperCaseArg === (current.short && current.short.toUpperCase()) || upperCaseArg === (current.name && current.name.toUpperCase())) {
+                    return current;
+                }
+            }
+
+            return null;
+        };
+
+        OptionsParser.prototype.printUsage = function () {
+            this.printVersion();
+
+            var optionsWord = TypeScript.getLocalizedText(TypeScript.DiagnosticCode.options, null);
+            var fileWord = TypeScript.getLocalizedText(TypeScript.DiagnosticCode.file1, null);
+            var tscSyntax = "tsc [" + optionsWord + "] [" + fileWord + " ..]";
+            var syntaxHelp = TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Syntax_0, [tscSyntax]);
+            this.host.printLine(syntaxHelp);
+            this.host.printLine("");
+            this.host.printLine(TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Examples, null) + " tsc hello.ts");
+            this.host.printLine("          tsc --out foo.js foo.ts");
+            this.host.printLine("          tsc @args.txt");
+            this.host.printLine("");
+            this.host.printLine(TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Options, null));
+
+            var output = [];
+            var maxLength = 0;
+            var i = 0;
+
+            this.options = this.options.sort(function (a, b) {
+                var aName = a.name.toLowerCase();
+                var bName = b.name.toLowerCase();
+
+                if (aName > bName) {
+                    return 1;
+                } else if (aName < bName) {
+                    return -1;
+                } else {
+                    return 0;
+                }
+            });
+
+            for (i = 0; i < this.options.length; i++) {
+                var option = this.options[i];
+
+                if (option.experimental) {
+                    continue;
+                }
+
+                if (!option.usage) {
+                    break;
+                }
+
+                var usageString = "  ";
+                var type = option.type ? (" " + TypeScript.getLocalizedText(option.type, null)) : "";
+
+                if (option.short) {
+                    usageString += this.DEFAULT_SHORT_FLAG + option.short + type + ", ";
+                }
+
+                usageString += this.DEFAULT_LONG_FLAG + option.name + type;
+
+                output.push([usageString, TypeScript.getLocalizedText(option.usage.locCode, option.usage.args)]);
+
+                if (usageString.length > maxLength) {
+                    maxLength = usageString.length;
+                }
+            }
+
+            var fileDescription = TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Insert_command_line_options_and_files_from_a_file, null);
+            output.push(["  @<" + fileWord + ">", fileDescription]);
+
+            for (i = 0; i < output.length; i++) {
+                this.host.printLine(output[i][0] + (new Array(maxLength - output[i][0].length + 3)).join(" ") + output[i][1]);
+            }
+        };
+
+        OptionsParser.prototype.printVersion = function () {
+            if (!this.printedVersion) {
+                this.host.printLine(TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Version_0, [this.version]));
+                this.printedVersion = true;
+            }
+        };
+
+        OptionsParser.prototype.option = function (name, config, short) {
+            if (!config) {
+                config = short;
+                short = null;
+            }
+
+            config.name = name;
+            config.short = short;
+            config.flag = false;
+
+            this.options.push(config);
+        };
+
+        OptionsParser.prototype.flag = function (name, config, short) {
+            if (!config) {
+                config = short;
+                short = null;
+            }
+
+            config.name = name;
+            config.short = short;
+            config.flag = true;
+
+            this.options.push(config);
+        };
+
+        OptionsParser.prototype.parseString = function (argString) {
+            var position = 0;
+            var tokens = argString.match(/\s+|"|[^\s"]+/g);
+
+            function peek() {
+                return tokens[position];
+            }
+
+            function consume() {
+                return tokens[position++];
+            }
+
+            function consumeQuotedString() {
+                var value = '';
+                consume();
+
+                var token = peek();
+
+                while (token && token !== '"') {
+                    consume();
+
+                    value += token;
+
+                    token = peek();
+                }
+
+                consume();
+
+                return value;
+            }
+
+            var args = [];
+            var currentArg = '';
+
+            while (position < tokens.length) {
+                var token = peek();
+
+                if (token === '"') {
+                    currentArg += consumeQuotedString();
+                } else if (token.match(/\s/)) {
+                    if (currentArg.length > 0) {
+                        args.push(currentArg);
+                        currentArg = '';
+                    }
+
+                    consume();
+                } else {
+                    consume();
+                    currentArg += token;
+                }
+            }
+
+            if (currentArg.length > 0) {
+                args.push(currentArg);
+            }
+
+            this.parse(args);
+        };
+
+        OptionsParser.prototype.parse = function (args) {
+            var position = 0;
+
+            function consume() {
+                return args[position++];
+            }
+
+            while (position < args.length) {
+                var current = consume();
+                var match = current.match(/^(--?|@)(.*)/);
+                var value = null;
+
+                if (match) {
+                    if (match[1] === '@') {
+                        this.parseString(this.host.readFile(match[2], null).contents);
+                    } else {
+                        var arg = match[2];
+                        var option = this.findOption(arg);
+
+                        if (option === null) {
+                            this.host.printLine(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Unknown_option_0, [arg]));
+                            this.host.printLine(TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Use_the_0_flag_to_see_options, ["--help"]));
+                        } else {
+                            if (!option.flag) {
+                                value = consume();
+                                if (value === undefined) {
+                                    this.host.printLine(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Option_0_specified_without_1, [arg, TypeScript.getLocalizedText(option.type, null)]));
+                                    this.host.printLine(TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Use_the_0_flag_to_see_options, ["--help"]));
+                                    continue;
+                                }
+                            }
+
+                            option.set(value);
+                        }
+                    }
+                } else {
+                    this.unnamed.push(current);
+                }
+            }
+        };
+        return OptionsParser;
+    })();
+    TypeScript.OptionsParser = OptionsParser;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SourceFile = (function () {
+        function SourceFile(scriptSnapshot, byteOrderMark) {
+            this.scriptSnapshot = scriptSnapshot;
+            this.byteOrderMark = byteOrderMark;
+        }
+        return SourceFile;
+    })();
+
+    var DiagnosticsLogger = (function () {
+        function DiagnosticsLogger(ioHost) {
+            this.ioHost = ioHost;
+        }
+        DiagnosticsLogger.prototype.information = function () {
+            return false;
+        };
+        DiagnosticsLogger.prototype.debug = function () {
+            return false;
+        };
+        DiagnosticsLogger.prototype.warning = function () {
+            return false;
+        };
+        DiagnosticsLogger.prototype.error = function () {
+            return false;
+        };
+        DiagnosticsLogger.prototype.fatal = function () {
+            return false;
+        };
+        DiagnosticsLogger.prototype.log = function (s) {
+            this.ioHost.stdout.WriteLine(s);
+        };
+        return DiagnosticsLogger;
+    })();
+
+    var FileLogger = (function () {
+        function FileLogger(ioHost) {
+            this.ioHost = ioHost;
+            var file = "tsc." + Date.now() + ".log";
+
+            this.fileName = this.ioHost.resolvePath(file);
+        }
+        FileLogger.prototype.information = function () {
+            return false;
+        };
+        FileLogger.prototype.debug = function () {
+            return false;
+        };
+        FileLogger.prototype.warning = function () {
+            return false;
+        };
+        FileLogger.prototype.error = function () {
+            return false;
+        };
+        FileLogger.prototype.fatal = function () {
+            return false;
+        };
+        FileLogger.prototype.log = function (s) {
+            this.ioHost.appendFile(this.fileName, s + '\r\n');
+        };
+        return FileLogger;
+    })();
+
+    var BatchCompiler = (function () {
+        function BatchCompiler(ioHost) {
+            this.ioHost = ioHost;
+            this.compilerVersion = "1.0.0.0";
+            this.inputFiles = [];
+            this.resolvedFiles = [];
+            this.fileNameToSourceFile = new TypeScript.StringHashTable();
+            this.hasErrors = false;
+            this.logger = null;
+            this.fileExistsCache = TypeScript.createIntrinsicsObject();
+            this.resolvePathCache = TypeScript.createIntrinsicsObject();
+        }
+        BatchCompiler.prototype.batchCompile = function () {
+            var _this = this;
+            var start = new Date().getTime();
+
+            TypeScript.CompilerDiagnostics.diagnosticWriter = { Alert: function (s) {
+                    _this.ioHost.printLine(s);
+                } };
+
+            if (this.parseOptions()) {
+                if (this.compilationSettings.createFileLog()) {
+                    this.logger = new FileLogger(this.ioHost);
+                } else if (this.compilationSettings.gatherDiagnostics()) {
+                    this.logger = new DiagnosticsLogger(this.ioHost);
+                } else {
+                    this.logger = new TypeScript.NullLogger();
+                }
+
+                if (this.compilationSettings.watch()) {
+                    this.watchFiles();
+                    return;
+                }
+
+                this.resolve();
+
+                this.compile();
+
+                if (this.compilationSettings.createFileLog()) {
+                    this.logger.log("Compilation settings:");
+                    this.logger.log(" propagateEnumConstants " + this.compilationSettings.propagateEnumConstants());
+                    this.logger.log(" removeComments " + this.compilationSettings.removeComments());
+                    this.logger.log(" watch " + this.compilationSettings.watch());
+                    this.logger.log(" noResolve " + this.compilationSettings.noResolve());
+                    this.logger.log(" noImplicitAny " + this.compilationSettings.noImplicitAny());
+                    this.logger.log(" nolib " + this.compilationSettings.noLib());
+                    this.logger.log(" target " + this.compilationSettings.codeGenTarget());
+                    this.logger.log(" module " + this.compilationSettings.moduleGenTarget());
+                    this.logger.log(" out " + this.compilationSettings.outFileOption());
+                    this.logger.log(" outDir " + this.compilationSettings.outDirOption());
+                    this.logger.log(" sourcemap " + this.compilationSettings.mapSourceFiles());
+                    this.logger.log(" mapRoot " + this.compilationSettings.mapRoot());
+                    this.logger.log(" sourceroot " + this.compilationSettings.sourceRoot());
+                    this.logger.log(" declaration " + this.compilationSettings.generateDeclarationFiles());
+                    this.logger.log(" useCaseSensitiveFileResolution " + this.compilationSettings.useCaseSensitiveFileResolution());
+                    this.logger.log(" diagnostics " + this.compilationSettings.gatherDiagnostics());
+                    this.logger.log(" codepage " + this.compilationSettings.codepage());
+
+                    this.logger.log("");
+
+                    this.logger.log("Input files:");
+                    this.inputFiles.forEach(function (file) {
+                        _this.logger.log(" " + file);
+                    });
+
+                    this.logger.log("");
+
+                    this.logger.log("Resolved Files:");
+                    this.resolvedFiles.forEach(function (file) {
+                        file.importedFiles.forEach(function (file) {
+                            _this.logger.log(" " + file);
+                        });
+                        file.referencedFiles.forEach(function (file) {
+                            _this.logger.log(" " + file);
+                        });
+                    });
+                }
+
+                if (this.compilationSettings.gatherDiagnostics()) {
+                    this.logger.log("");
+                    this.logger.log("File resolution time:                     " + TypeScript.fileResolutionTime);
+                    this.logger.log("           file read:                     " + TypeScript.fileResolutionIOTime);
+                    this.logger.log("        scan imports:                     " + TypeScript.fileResolutionScanImportsTime);
+                    this.logger.log("       import search:                     " + TypeScript.fileResolutionImportFileSearchTime);
+                    this.logger.log("        get lib.d.ts:                     " + TypeScript.fileResolutionGetDefaultLibraryTime);
+
+                    this.logger.log("SyntaxTree parse time:                    " + TypeScript.syntaxTreeParseTime);
+                    this.logger.log("Syntax Diagnostics time:                  " + TypeScript.syntaxDiagnosticsTime);
+                    this.logger.log("AST translation time:                     " + TypeScript.astTranslationTime);
+                    this.logger.log("");
+                    this.logger.log("Type check time:                          " + TypeScript.typeCheckTime);
+                    this.logger.log("");
+                    this.logger.log("Emit time:                                " + TypeScript.emitTime);
+                    this.logger.log("Declaration emit time:                    " + TypeScript.declarationEmitTime);
+
+                    this.logger.log("Total number of symbols created:          " + TypeScript.pullSymbolID);
+                    this.logger.log("Specialized types created:                " + TypeScript.nSpecializationsCreated);
+                    this.logger.log("Specialized signatures created:           " + TypeScript.nSpecializedSignaturesCreated);
+
+                    this.logger.log("  IsExternallyVisibleTime:                " + TypeScript.declarationEmitIsExternallyVisibleTime);
+                    this.logger.log("  TypeSignatureTime:                      " + TypeScript.declarationEmitTypeSignatureTime);
+                    this.logger.log("  GetBoundDeclTypeTime:                   " + TypeScript.declarationEmitGetBoundDeclTypeTime);
+                    this.logger.log("  IsOverloadedCallSignatureTime:          " + TypeScript.declarationEmitIsOverloadedCallSignatureTime);
+                    this.logger.log("  FunctionDeclarationGetSymbolTime:       " + TypeScript.declarationEmitFunctionDeclarationGetSymbolTime);
+                    this.logger.log("  GetBaseTypeTime:                        " + TypeScript.declarationEmitGetBaseTypeTime);
+                    this.logger.log("  GetAccessorFunctionTime:                " + TypeScript.declarationEmitGetAccessorFunctionTime);
+                    this.logger.log("  GetTypeParameterSymbolTime:             " + TypeScript.declarationEmitGetTypeParameterSymbolTime);
+                    this.logger.log("  GetImportDeclarationSymbolTime:         " + TypeScript.declarationEmitGetImportDeclarationSymbolTime);
+
+                    this.logger.log("Emit write file time:                     " + TypeScript.emitWriteFileTime);
+
+                    this.logger.log("Compiler resolve path time:               " + TypeScript.compilerResolvePathTime);
+                    this.logger.log("Compiler directory name time:             " + TypeScript.compilerDirectoryNameTime);
+                    this.logger.log("Compiler directory exists time:           " + TypeScript.compilerDirectoryExistsTime);
+                    this.logger.log("Compiler file exists time:                " + TypeScript.compilerFileExistsTime);
+
+                    this.logger.log("IO host resolve path time:                " + TypeScript.ioHostResolvePathTime);
+                    this.logger.log("IO host directory name time:              " + TypeScript.ioHostDirectoryNameTime);
+                    this.logger.log("IO host create directory structure time:  " + TypeScript.ioHostCreateDirectoryStructureTime);
+                    this.logger.log("IO host write file time:                  " + TypeScript.ioHostWriteFileTime);
+
+                    this.logger.log("Node make directory time:                 " + TypeScript.nodeMakeDirectoryTime);
+                    this.logger.log("Node writeFileSync time:                  " + TypeScript.nodeWriteFileSyncTime);
+                    this.logger.log("Node createBuffer time:                   " + TypeScript.nodeCreateBufferTime);
+                }
+            }
+
+            this.ioHost.quit(this.hasErrors ? 1 : 0);
+        };
+
+        BatchCompiler.prototype.resolve = function () {
+            var _this = this;
+            var includeDefaultLibrary = !this.compilationSettings.noLib();
+            var resolvedFiles = [];
+
+            var start = new Date().getTime();
+
+            if (!this.compilationSettings.noResolve()) {
+                var resolutionResults = TypeScript.ReferenceResolver.resolve(this.inputFiles, this, this.compilationSettings.useCaseSensitiveFileResolution());
+                resolvedFiles = resolutionResults.resolvedFiles;
+
+                includeDefaultLibrary = !this.compilationSettings.noLib() && !resolutionResults.seenNoDefaultLibTag;
+
+                resolutionResults.diagnostics.forEach(function (d) {
+                    return _this.addDiagnostic(d);
+                });
+            } else {
+                for (var i = 0, n = this.inputFiles.length; i < n; i++) {
+                    var inputFile = this.inputFiles[i];
+                    var referencedFiles = [];
+                    var importedFiles = [];
+
+                    if (this.compilationSettings.generateDeclarationFiles()) {
+                        var references = TypeScript.getReferencedFiles(inputFile, this.getScriptSnapshot(inputFile));
+                        for (var j = 0; j < references.length; j++) {
+                            referencedFiles.push(references[j].path);
+                        }
+
+                        inputFile = this.resolvePath(inputFile);
+                    }
+
+                    resolvedFiles.push({
+                        path: inputFile,
+                        referencedFiles: referencedFiles,
+                        importedFiles: importedFiles
+                    });
+                }
+            }
+
+            var defaultLibStart = new Date().getTime();
+            if (includeDefaultLibrary) {
+                var libraryResolvedFile = {
+                    path: this.getDefaultLibraryFilePath(),
+                    referencedFiles: [],
+                    importedFiles: []
+                };
+
+                resolvedFiles = [libraryResolvedFile].concat(resolvedFiles);
+            }
+            TypeScript.fileResolutionGetDefaultLibraryTime += new Date().getTime() - defaultLibStart;
+
+            this.resolvedFiles = resolvedFiles;
+
+            TypeScript.fileResolutionTime = new Date().getTime() - start;
+        };
+
+        BatchCompiler.prototype.compile = function () {
+            var _this = this;
+            var compiler = new TypeScript.TypeScriptCompiler(this.logger, this.compilationSettings);
+
+            this.resolvedFiles.forEach(function (resolvedFile) {
+                var sourceFile = _this.getSourceFile(resolvedFile.path);
+                compiler.addFile(resolvedFile.path, sourceFile.scriptSnapshot, sourceFile.byteOrderMark, 0, false, resolvedFile.referencedFiles);
+            });
+
+            for (var it = compiler.compile(function (path) {
+                return _this.resolvePath(path);
+            }); it.moveNext();) {
+                var result = it.current();
+
+                result.diagnostics.forEach(function (d) {
+                    return _this.addDiagnostic(d);
+                });
+                if (!this.tryWriteOutputFiles(result.outputFiles)) {
+                    return;
+                }
+            }
+        };
+
+        BatchCompiler.prototype.parseOptions = function () {
+            var _this = this;
+            var opts = new TypeScript.OptionsParser(this.ioHost, this.compilerVersion);
+
+            var mutableSettings = new TypeScript.CompilationSettings();
+            opts.option('out', {
+                usage: {
+                    locCode: TypeScript.DiagnosticCode.Concatenate_and_emit_output_to_single_file,
+                    args: null
+                },
+                type: TypeScript.DiagnosticCode.file2,
+                set: function (str) {
+                    mutableSettings.outFileOption = str;
+                }
+            });
+
+            opts.option('outDir', {
+                usage: {
+                    locCode: TypeScript.DiagnosticCode.Redirect_output_structure_to_the_directory,
+                    args: null
+                },
+                type: TypeScript.DiagnosticCode.DIRECTORY,
+                set: function (str) {
+                    mutableSettings.outDirOption = str;
+                }
+            });
+
+            opts.flag('sourcemap', {
+                usage: {
+                    locCode: TypeScript.DiagnosticCode.Generates_corresponding_0_file,
+                    args: ['.map']
+                },
+                set: function () {
+                    mutableSettings.mapSourceFiles = true;
+                }
+            });
+
+            opts.option('mapRoot', {
+                usage: {
+                    locCode: TypeScript.DiagnosticCode.Specifies_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations,
+                    args: null
+                },
+                type: TypeScript.DiagnosticCode.LOCATION,
+                set: function (str) {
+                    mutableSettings.mapRoot = str;
+                }
+            });
+
+            opts.option('sourceRoot', {
+                usage: {
+                    locCode: TypeScript.DiagnosticCode.Specifies_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations,
+                    args: null
+                },
+                type: TypeScript.DiagnosticCode.LOCATION,
+                set: function (str) {
+                    mutableSettings.sourceRoot = str;
+                }
+            });
+
+            opts.flag('declaration', {
+                usage: {
+                    locCode: TypeScript.DiagnosticCode.Generates_corresponding_0_file,
+                    args: ['.d.ts']
+                },
+                set: function () {
+                    mutableSettings.generateDeclarationFiles = true;
+                }
+            }, 'd');
+
+            if (this.ioHost.watchFile) {
+                opts.flag('watch', {
+                    usage: {
+                        locCode: TypeScript.DiagnosticCode.Watch_input_files,
+                        args: null
+                    },
+                    set: function () {
+                        mutableSettings.watch = true;
+                    }
+                }, 'w');
+            }
+
+            opts.flag('propagateEnumConstants', {
+                experimental: true,
+                set: function () {
+                    mutableSettings.propagateEnumConstants = true;
+                }
+            });
+
+            opts.flag('removeComments', {
+                usage: {
+                    locCode: TypeScript.DiagnosticCode.Do_not_emit_comments_to_output,
+                    args: null
+                },
+                set: function () {
+                    mutableSettings.removeComments = true;
+                }
+            });
+
+            opts.flag('noResolve', {
+                experimental: true,
+                usage: {
+                    locCode: TypeScript.DiagnosticCode.Skip_resolution_and_preprocessing,
+                    args: null
+                },
+                set: function () {
+                    mutableSettings.noResolve = true;
+                }
+            });
+
+            opts.flag('noLib', {
+                experimental: true,
+                set: function () {
+                    mutableSettings.noLib = true;
+                }
+            });
+
+            opts.flag('diagnostics', {
+                experimental: true,
+                set: function () {
+                    mutableSettings.gatherDiagnostics = true;
+                }
+            });
+
+            opts.flag('logFile', {
+                experimental: true,
+                set: function () {
+                    mutableSettings.createFileLog = true;
+                }
+            });
+
+            opts.option('target', {
+                usage: {
+                    locCode: TypeScript.DiagnosticCode.Specify_ECMAScript_target_version_0_default_or_1,
+                    args: ['ES3', 'ES5']
+                },
+                type: TypeScript.DiagnosticCode.VERSION,
+                set: function (type) {
+                    type = type.toLowerCase();
+
+                    if (type === 'es3') {
+                        mutableSettings.codeGenTarget = 0 /* EcmaScript3 */;
+                    } else if (type === 'es5') {
+                        mutableSettings.codeGenTarget = 1 /* EcmaScript5 */;
+                    } else {
+                        _this.addDiagnostic(new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.ECMAScript_target_version_0_not_supported_Specify_a_valid_target_version_1_default_or_2, [type, "ES3", "ES5"]));
+                    }
+                }
+            }, 't');
+
+            opts.option('module', {
+                usage: {
+                    locCode: TypeScript.DiagnosticCode.Specify_module_code_generation_0_or_1,
+                    args: ['commonjs', 'amd']
+                },
+                type: TypeScript.DiagnosticCode.KIND,
+                set: function (type) {
+                    type = type.toLowerCase();
+
+                    if (type === 'commonjs') {
+                        mutableSettings.moduleGenTarget = 1 /* Synchronous */;
+                    } else if (type === 'amd') {
+                        mutableSettings.moduleGenTarget = 2 /* Asynchronous */;
+                    } else {
+                        _this.addDiagnostic(new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Module_code_generation_0_not_supported, [type]));
+                    }
+                }
+            }, 'm');
+
+            var needsHelp = false;
+            opts.flag('help', {
+                usage: {
+                    locCode: TypeScript.DiagnosticCode.Print_this_message,
+                    args: null
+                },
+                set: function () {
+                    needsHelp = true;
+                }
+            }, 'h');
+
+            opts.flag('useCaseSensitiveFileResolution', {
+                experimental: true,
+                set: function () {
+                    mutableSettings.useCaseSensitiveFileResolution = true;
+                }
+            });
+            var shouldPrintVersionOnly = false;
+            opts.flag('version', {
+                usage: {
+                    locCode: TypeScript.DiagnosticCode.Print_the_compiler_s_version_0,
+                    args: [this.compilerVersion]
+                },
+                set: function () {
+                    shouldPrintVersionOnly = true;
+                }
+            }, 'v');
+
+            var locale = null;
+            opts.option('locale', {
+                experimental: true,
+                usage: {
+                    locCode: TypeScript.DiagnosticCode.Specify_locale_for_errors_and_messages_For_example_0_or_1,
+                    args: ['en', 'ja-jp']
+                },
+                type: TypeScript.DiagnosticCode.STRING,
+                set: function (value) {
+                    locale = value;
+                }
+            });
+
+            opts.flag('noImplicitAny', {
+                usage: {
+                    locCode: TypeScript.DiagnosticCode.Warn_on_expressions_and_declarations_with_an_implied_any_type,
+                    args: null
+                },
+                set: function () {
+                    mutableSettings.noImplicitAny = true;
+                }
+            });
+
+            if (TypeScript.Environment.supportsCodePage()) {
+                opts.option('codepage', {
+                    usage: {
+                        locCode: TypeScript.DiagnosticCode.Specify_the_codepage_to_use_when_opening_source_files,
+                        args: null
+                    },
+                    type: TypeScript.DiagnosticCode.NUMBER,
+                    set: function (arg) {
+                        mutableSettings.codepage = parseInt(arg, 10);
+                    }
+                });
+            }
+
+            opts.parse(this.ioHost.arguments);
+
+            this.compilationSettings = TypeScript.ImmutableCompilationSettings.fromCompilationSettings(mutableSettings);
+
+            if (locale) {
+                if (!this.setLocale(locale)) {
+                    return false;
+                }
+            }
+
+            this.inputFiles.push.apply(this.inputFiles, opts.unnamed);
+
+            if (shouldPrintVersionOnly) {
+                opts.printVersion();
+                return false;
+            } else if (this.inputFiles.length === 0 || needsHelp) {
+                opts.printUsage();
+                return false;
+            }
+
+            return !this.hasErrors;
+        };
+
+        BatchCompiler.prototype.setLocale = function (locale) {
+            var matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(locale.toLowerCase());
+            if (!matchResult) {
+                this.addDiagnostic(new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1, ['en', 'ja-jp']));
+                return false;
+            }
+
+            var language = matchResult[1];
+            var territory = matchResult[3];
+
+            if (!this.setLanguageAndTerritory(language, territory) && !this.setLanguageAndTerritory(language, null)) {
+                this.addDiagnostic(new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Unsupported_locale_0, [locale]));
+                return false;
+            }
+
+            return true;
+        };
+
+        BatchCompiler.prototype.setLanguageAndTerritory = function (language, territory) {
+            var compilerFilePath = this.ioHost.getExecutingFilePath();
+            var containingDirectoryPath = this.ioHost.dirName(compilerFilePath);
+
+            var filePath = TypeScript.IOUtils.combine(containingDirectoryPath, language);
+            if (territory) {
+                filePath = filePath + "-" + territory;
+            }
+
+            filePath = this.resolvePath(TypeScript.IOUtils.combine(filePath, "diagnosticMessages.generated.json"));
+
+            if (!this.fileExists(filePath)) {
+                return false;
+            }
+
+            var fileContents = this.ioHost.readFile(filePath, this.compilationSettings.codepage());
+            TypeScript.LocalizedDiagnosticMessages = JSON.parse(fileContents.contents);
+            return true;
+        };
+
+        BatchCompiler.prototype.watchFiles = function () {
+            var _this = this;
+            if (!this.ioHost.watchFile) {
+                this.addDiagnostic(new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Current_host_does_not_support_0_option, ['-w[atch]']));
+                return;
+            }
+
+            var lastResolvedFileSet = [];
+            var watchers = {};
+            var firstTime = true;
+
+            var addWatcher = function (fileName) {
+                if (!watchers[fileName]) {
+                    var watcher = _this.ioHost.watchFile(fileName, onWatchedFileChange);
+                    watchers[fileName] = watcher;
+                } else {
+                    TypeScript.CompilerDiagnostics.debugPrint("Cannot watch file, it is already watched.");
+                }
+            };
+
+            var removeWatcher = function (fileName) {
+                if (watchers[fileName]) {
+                    watchers[fileName].close();
+                    delete watchers[fileName];
+                } else {
+                    TypeScript.CompilerDiagnostics.debugPrint("Cannot stop watching file, it is not being watched.");
+                }
+            };
+
+            var onWatchedFileChange = function () {
+                _this.hasErrors = false;
+
+                _this.fileNameToSourceFile = new TypeScript.StringHashTable();
+
+                _this.resolve();
+
+                var oldFiles = lastResolvedFileSet;
+                var newFiles = _this.resolvedFiles.map(function (resolvedFile) {
+                    return resolvedFile.path;
+                }).sort();
+
+                var i = 0, j = 0;
+                while (i < oldFiles.length && j < newFiles.length) {
+                    var compareResult = oldFiles[i].localeCompare(newFiles[j]);
+                    if (compareResult === 0) {
+                        i++;
+                        j++;
+                    } else if (compareResult < 0) {
+                        removeWatcher(oldFiles[i]);
+                        i++;
+                    } else {
+                        addWatcher(newFiles[j]);
+                        j++;
+                    }
+                }
+
+                for (var k = i; k < oldFiles.length; k++) {
+                    removeWatcher(oldFiles[k]);
+                }
+
+                for (k = j; k < newFiles.length; k++) {
+                    addWatcher(newFiles[k]);
+                }
+
+                lastResolvedFileSet = newFiles;
+
+                if (!firstTime) {
+                    var fileNames = "";
+                    for (var k = 0; k < lastResolvedFileSet.length; k++) {
+                        fileNames += TypeScript.Environment.newLine + "    " + lastResolvedFileSet[k];
+                    }
+                    _this.ioHost.printLine(TypeScript.getLocalizedText(TypeScript.DiagnosticCode.NL_Recompiling_0, [fileNames]));
+                } else {
+                    firstTime = false;
+                }
+
+                _this.compile();
+            };
+
+            this.ioHost.stderr = this.ioHost.stdout;
+
+            onWatchedFileChange();
+        };
+
+        BatchCompiler.prototype.getSourceFile = function (fileName) {
+            var sourceFile = this.fileNameToSourceFile.lookup(fileName);
+            if (!sourceFile) {
+                var fileInformation;
+
+                try  {
+                    fileInformation = this.ioHost.readFile(fileName, this.compilationSettings.codepage());
+                } catch (e) {
+                    this.addDiagnostic(new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Cannot_read_file_0_1, [fileName, e.message]));
+                    fileInformation = new TypeScript.FileInformation("", 0 /* None */);
+                }
+
+                var snapshot = TypeScript.ScriptSnapshot.fromString(fileInformation.contents);
+                var sourceFile = new SourceFile(snapshot, fileInformation.byteOrderMark);
+                this.fileNameToSourceFile.add(fileName, sourceFile);
+            }
+
+            return sourceFile;
+        };
+
+        BatchCompiler.prototype.getDefaultLibraryFilePath = function () {
+            var compilerFilePath = this.ioHost.getExecutingFilePath();
+            var containingDirectoryPath = this.ioHost.dirName(compilerFilePath);
+            var libraryFilePath = this.resolvePath(TypeScript.IOUtils.combine(containingDirectoryPath, "lib.d.ts"));
+
+            return libraryFilePath;
+        };
+
+        BatchCompiler.prototype.getScriptSnapshot = function (fileName) {
+            return this.getSourceFile(fileName).scriptSnapshot;
+        };
+
+        BatchCompiler.prototype.resolveRelativePath = function (path, directory) {
+            var start = new Date().getTime();
+
+            var unQuotedPath = TypeScript.stripStartAndEndQuotes(path);
+            var normalizedPath;
+
+            if (TypeScript.isRooted(unQuotedPath) || !directory) {
+                normalizedPath = unQuotedPath;
+            } else {
+                normalizedPath = TypeScript.IOUtils.combine(directory, unQuotedPath);
+            }
+
+            normalizedPath = this.resolvePath(normalizedPath);
+
+            normalizedPath = TypeScript.switchToForwardSlashes(normalizedPath);
+
+            return normalizedPath;
+        };
+
+        BatchCompiler.prototype.fileExists = function (path) {
+            var exists = this.fileExistsCache[path];
+            if (exists === undefined) {
+                var start = new Date().getTime();
+                exists = this.ioHost.fileExists(path);
+                this.fileExistsCache[path] = exists;
+                TypeScript.compilerFileExistsTime += new Date().getTime() - start;
+            }
+
+            return exists;
+        };
+
+        BatchCompiler.prototype.getParentDirectory = function (path) {
+            var start = new Date().getTime();
+            var result = this.ioHost.dirName(path);
+            TypeScript.compilerDirectoryNameTime += new Date().getTime() - start;
+
+            return result;
+        };
+
+        BatchCompiler.prototype.addDiagnostic = function (diagnostic) {
+            var diagnosticInfo = diagnostic.info();
+            if (diagnosticInfo.category === 1 /* Error */) {
+                this.hasErrors = true;
+            }
+
+            this.ioHost.stderr.Write(TypeScript.TypeScriptCompiler.getFullDiagnosticText(diagnostic));
+        };
+
+        BatchCompiler.prototype.tryWriteOutputFiles = function (outputFiles) {
+            for (var i = 0, n = outputFiles.length; i < n; i++) {
+                var outputFile = outputFiles[i];
+
+                try  {
+                    this.writeFile(outputFile.name, outputFile.text, outputFile.writeByteOrderMark);
+                } catch (e) {
+                    this.addDiagnostic(new TypeScript.Diagnostic(outputFile.name, null, 0, 0, TypeScript.DiagnosticCode.Emit_Error_0, [e.message]));
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        BatchCompiler.prototype.writeFile = function (fileName, contents, writeByteOrderMark) {
+            var start = new Date().getTime();
+            TypeScript.IOUtils.writeFileAndFolderStructure(this.ioHost, fileName, contents, writeByteOrderMark);
+            TypeScript.emitWriteFileTime += new Date().getTime() - start;
+        };
+
+        BatchCompiler.prototype.directoryExists = function (path) {
+            var start = new Date().getTime();
+            var result = this.ioHost.directoryExists(path);
+            TypeScript.compilerDirectoryExistsTime += new Date().getTime() - start;
+            return result;
+        };
+
+        BatchCompiler.prototype.resolvePath = function (path) {
+            var cachedValue = this.resolvePathCache[path];
+            if (!cachedValue) {
+                var start = new Date().getTime();
+                cachedValue = this.ioHost.resolvePath(path);
+                this.resolvePathCache[path] = cachedValue;
+                TypeScript.compilerResolvePathTime += new Date().getTime() - start;
+            }
+
+            return cachedValue;
+        };
+        return BatchCompiler;
+    })();
+    TypeScript.BatchCompiler = BatchCompiler;
+
+    var batch = new TypeScript.BatchCompiler(TypeScript.IO);
+    batch.batchCompile();
+})(TypeScript || (TypeScript = {}));
diff --git a/_infrastructure/tests/typescript/1.0.0/typescript.js b/_infrastructure/tests/typescript/1.0.0/typescript.js
new file mode 100644
index 000000000..c2241eb4f
--- /dev/null
+++ b/_infrastructure/tests/typescript/1.0.0/typescript.js
@@ -0,0 +1,61379 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved. 
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0  
+ 
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
+MERCHANTABLITY OR NON-INFRINGEMENT. 
+ 
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+var TypeScript;
+(function (TypeScript) {
+    TypeScript.DiagnosticCode = {
+        error_TS_0_1: "error TS{0}: {1}",
+        warning_TS_0_1: "warning TS{0}: {1}",
+        Unrecognized_escape_sequence: "Unrecognized escape sequence.",
+        Unexpected_character_0: "Unexpected character {0}.",
+        Missing_close_quote_character: "Missing close quote character.",
+        Identifier_expected: "Identifier expected.",
+        _0_keyword_expected: "'{0}' keyword expected.",
+        _0_expected: "'{0}' expected.",
+        Identifier_expected_0_is_a_keyword: "Identifier expected; '{0}' is a keyword.",
+        Automatic_semicolon_insertion_not_allowed: "Automatic semicolon insertion not allowed.",
+        Unexpected_token_0_expected: "Unexpected token; '{0}' expected.",
+        Trailing_separator_not_allowed: "Trailing separator not allowed.",
+        AsteriskSlash_expected: "'*/' expected.",
+        public_or_private_modifier_must_precede_static: "'public' or 'private' modifier must precede 'static'.",
+        Unexpected_token: "Unexpected token.",
+        Catch_clause_parameter_cannot_have_a_type_annotation: "Catch clause parameter cannot have a type annotation.",
+        Rest_parameter_must_be_last_in_list: "Rest parameter must be last in list.",
+        Parameter_cannot_have_question_mark_and_initializer: "Parameter cannot have question mark and initializer.",
+        Required_parameter_cannot_follow_optional_parameter: "Required parameter cannot follow optional parameter.",
+        Index_signatures_cannot_have_rest_parameters: "Index signatures cannot have rest parameters.",
+        Index_signature_parameter_cannot_have_accessibility_modifiers: "Index signature parameter cannot have accessibility modifiers.",
+        Index_signature_parameter_cannot_have_a_question_mark: "Index signature parameter cannot have a question mark.",
+        Index_signature_parameter_cannot_have_an_initializer: "Index signature parameter cannot have an initializer.",
+        Index_signature_must_have_a_type_annotation: "Index signature must have a type annotation.",
+        Index_signature_parameter_must_have_a_type_annotation: "Index signature parameter must have a type annotation.",
+        Index_signature_parameter_type_must_be_string_or_number: "Index signature parameter type must be 'string' or 'number'.",
+        extends_clause_already_seen: "'extends' clause already seen.",
+        extends_clause_must_precede_implements_clause: "'extends' clause must precede 'implements' clause.",
+        Classes_can_only_extend_a_single_class: "Classes can only extend a single class.",
+        implements_clause_already_seen: "'implements' clause already seen.",
+        Accessibility_modifier_already_seen: "Accessibility modifier already seen.",
+        _0_modifier_must_precede_1_modifier: "'{0}' modifier must precede '{1}' modifier.",
+        _0_modifier_already_seen: "'{0}' modifier already seen.",
+        _0_modifier_cannot_appear_on_a_class_element: "'{0}' modifier cannot appear on a class element.",
+        Interface_declaration_cannot_have_implements_clause: "Interface declaration cannot have 'implements' clause.",
+        super_invocation_cannot_have_type_arguments: "'super' invocation cannot have type arguments.",
+        Only_ambient_modules_can_use_quoted_names: "Only ambient modules can use quoted names.",
+        Statements_are_not_allowed_in_ambient_contexts: "Statements are not allowed in ambient contexts.",
+        Implementations_are_not_allowed_in_ambient_contexts: "Implementations are not allowed in ambient contexts.",
+        declare_modifier_not_allowed_for_code_already_in_an_ambient_context: "'declare' modifier not allowed for code already in an ambient context.",
+        Initializers_are_not_allowed_in_ambient_contexts: "Initializers are not allowed in ambient contexts.",
+        Parameter_property_declarations_can_only_be_used_in_a_non_ambient_constructor_declaration: "Parameter property declarations can only be used in a non-ambient constructor declaration.",
+        Function_implementation_expected: "Function implementation expected.",
+        Constructor_implementation_expected: "Constructor implementation expected.",
+        Function_overload_name_must_be_0: "Function overload name must be '{0}'.",
+        _0_modifier_cannot_appear_on_a_module_element: "'{0}' modifier cannot appear on a module element.",
+        declare_modifier_cannot_appear_on_an_interface_declaration: "'declare' modifier cannot appear on an interface declaration.",
+        declare_modifier_required_for_top_level_element: "'declare' modifier required for top level element.",
+        Rest_parameter_cannot_be_optional: "Rest parameter cannot be optional.",
+        Rest_parameter_cannot_have_an_initializer: "Rest parameter cannot have an initializer.",
+        set_accessor_must_have_one_and_only_one_parameter: "'set' accessor must have one and only one parameter.",
+        set_accessor_parameter_cannot_be_optional: "'set' accessor parameter cannot be optional.",
+        set_accessor_parameter_cannot_have_an_initializer: "'set' accessor parameter cannot have an initializer.",
+        set_accessor_cannot_have_rest_parameter: "'set' accessor cannot have rest parameter.",
+        get_accessor_cannot_have_parameters: "'get' accessor cannot have parameters.",
+        Modifiers_cannot_appear_here: "Modifiers cannot appear here.",
+        Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: "Accessors are only available when targeting ECMAScript 5 and higher.",
+        Class_name_cannot_be_0: "Class name cannot be '{0}'.",
+        Interface_name_cannot_be_0: "Interface name cannot be '{0}'.",
+        Enum_name_cannot_be_0: "Enum name cannot be '{0}'.",
+        Module_name_cannot_be_0: "Module name cannot be '{0}'.",
+        Enum_member_must_have_initializer: "Enum member must have initializer.",
+        Export_assignment_cannot_be_used_in_internal_modules: "Export assignment cannot be used in internal modules.",
+        Export_assignment_not_allowed_in_module_with_exported_element: "Export assignment not allowed in module with exported element.",
+        Module_cannot_have_multiple_export_assignments: "Module cannot have multiple export assignments.",
+        Ambient_enum_elements_can_only_have_integer_literal_initializers: "Ambient enum elements can only have integer literal initializers.",
+        module_class_interface_enum_import_or_statement: "module, class, interface, enum, import or statement",
+        constructor_function_accessor_or_variable: "constructor, function, accessor or variable",
+        statement: "statement",
+        case_or_default_clause: "case or default clause",
+        identifier: "identifier",
+        call_construct_index_property_or_function_signature: "call, construct, index, property or function signature",
+        expression: "expression",
+        type_name: "type name",
+        property_or_accessor: "property or accessor",
+        parameter: "parameter",
+        type: "type",
+        type_parameter: "type parameter",
+        declare_modifier_not_allowed_on_import_declaration: "'declare' modifier not allowed on import declaration.",
+        Function_overload_must_be_static: "Function overload must be static.",
+        Function_overload_must_not_be_static: "Function overload must not be static.",
+        Parameter_property_declarations_cannot_be_used_in_a_constructor_overload: "Parameter property declarations cannot be used in a constructor overload.",
+        Invalid_reference_directive_syntax: "Invalid 'reference' directive syntax.",
+        Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher: "Octal literals are not available when targeting ECMAScript 5 and higher.",
+        Accessors_are_not_allowed_in_ambient_contexts: "Accessors are not allowed in ambient contexts.",
+        _0_modifier_cannot_appear_on_a_constructor_declaration: "'{0}' modifier cannot appear on a constructor declaration.",
+        _0_modifier_cannot_appear_on_a_parameter: "'{0}' modifier cannot appear on a parameter.",
+        Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: "Only a single variable declaration is allowed in a 'for...in' statement.",
+        Type_parameters_cannot_appear_on_a_constructor_declaration: "Type parameters cannot appear on a constructor declaration.",
+        Type_annotation_cannot_appear_on_a_constructor_declaration: "Type annotation cannot appear on a constructor declaration.",
+        Duplicate_identifier_0: "Duplicate identifier '{0}'.",
+        The_name_0_does_not_exist_in_the_current_scope: "The name '{0}' does not exist in the current scope.",
+        The_name_0_does_not_refer_to_a_value: "The name '{0}' does not refer to a value.",
+        super_can_only_be_used_inside_a_class_instance_method: "'super' can only be used inside a class instance method.",
+        The_left_hand_side_of_an_assignment_expression_must_be_a_variable_property_or_indexer: "The left-hand side of an assignment expression must be a variable, property or indexer.",
+        Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: "Value of type '{0}' is not callable. Did you mean to include 'new'?",
+        Value_of_type_0_is_not_callable: "Value of type '{0}' is not callable.",
+        Value_of_type_0_is_not_newable: "Value of type '{0}' is not newable.",
+        Value_of_type_0_is_not_indexable_by_type_1: "Value of type '{0}' is not indexable by type '{1}'.",
+        Operator_0_cannot_be_applied_to_types_1_and_2: "Operator '{0}' cannot be applied to types '{1}' and '{2}'.",
+        Operator_0_cannot_be_applied_to_types_1_and_2_3: "Operator '{0}' cannot be applied to types '{1}' and '{2}': {3}",
+        Cannot_convert_0_to_1: "Cannot convert '{0}' to '{1}'.",
+        Cannot_convert_0_to_1_NL_2: "Cannot convert '{0}' to '{1}':{NL}{2}",
+        Expected_var_class_interface_or_module: "Expected var, class, interface, or module.",
+        Operator_0_cannot_be_applied_to_type_1: "Operator '{0}' cannot be applied to type '{1}'.",
+        Getter_0_already_declared: "Getter '{0}' already declared.",
+        Setter_0_already_declared: "Setter '{0}' already declared.",
+        Exported_class_0_extends_private_class_1: "Exported class '{0}' extends private class '{1}'.",
+        Exported_class_0_implements_private_interface_1: "Exported class '{0}' implements private interface '{1}'.",
+        Exported_interface_0_extends_private_interface_1: "Exported interface '{0}' extends private interface '{1}'.",
+        Exported_class_0_extends_class_from_inaccessible_module_1: "Exported class '{0}' extends class from inaccessible module {1}.",
+        Exported_class_0_implements_interface_from_inaccessible_module_1: "Exported class '{0}' implements interface from inaccessible module {1}.",
+        Exported_interface_0_extends_interface_from_inaccessible_module_1: "Exported interface '{0}' extends interface from inaccessible module {1}.",
+        Public_static_property_0_of_exported_class_has_or_is_using_private_type_1: "Public static property '{0}' of exported class has or is using private type '{1}'.",
+        Public_property_0_of_exported_class_has_or_is_using_private_type_1: "Public property '{0}' of exported class has or is using private type '{1}'.",
+        Property_0_of_exported_interface_has_or_is_using_private_type_1: "Property '{0}' of exported interface has or is using private type '{1}'.",
+        Exported_variable_0_has_or_is_using_private_type_1: "Exported variable '{0}' has or is using private type '{1}'.",
+        Public_static_property_0_of_exported_class_is_using_inaccessible_module_1: "Public static property '{0}' of exported class is using inaccessible module {1}.",
+        Public_property_0_of_exported_class_is_using_inaccessible_module_1: "Public property '{0}' of exported class is using inaccessible module {1}.",
+        Property_0_of_exported_interface_is_using_inaccessible_module_1: "Property '{0}' of exported interface is using inaccessible module {1}.",
+        Exported_variable_0_is_using_inaccessible_module_1: "Exported variable '{0}' is using inaccessible module {1}.",
+        Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of constructor from exported class has or is using private type '{1}'.",
+        Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public static property setter from exported class has or is using private type '{1}'.",
+        Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public property setter from exported class has or is using private type '{1}'.",
+        Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1: "Parameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.",
+        Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1: "Parameter '{0}' of call signature from exported interface has or is using private type '{1}'.",
+        Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public static method from exported class has or is using private type '{1}'.",
+        Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public method from exported class has or is using private type '{1}'.",
+        Parameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1: "Parameter '{0}' of method from exported interface has or is using private type '{1}'.",
+        Parameter_0_of_exported_function_has_or_is_using_private_type_1: "Parameter '{0}' of exported function has or is using private type '{1}'.",
+        Parameter_0_of_constructor_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of constructor from exported class is using inaccessible module {1}.",
+        Parameter_0_of_public_static_property_setter_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public static property setter from exported class is using inaccessible module {1}.",
+        Parameter_0_of_public_property_setter_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public property setter from exported class is using inaccessible module {1}.",
+        Parameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1: "Parameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.",
+        Parameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1: "Parameter '{0}' of call signature from exported interface is using inaccessible module {1}",
+        Parameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public static method from exported class is using inaccessible module {1}.",
+        Parameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public method from exported class is using inaccessible module {1}.",
+        Parameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1: "Parameter '{0}' of method from exported interface is using inaccessible module {1}.",
+        Parameter_0_of_exported_function_is_using_inaccessible_module_1: "Parameter '{0}' of exported function is using inaccessible module {1}.",
+        Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_type_0: "Return type of public static property getter from exported class has or is using private type '{0}'.",
+        Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_type_0: "Return type of public property getter from exported class has or is using private type '{0}'.",
+        Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_0: "Return type of constructor signature from exported interface has or is using private type '{0}'.",
+        Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_type_0: "Return type of call signature from exported interface has or is using private type '{0}'.",
+        Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_type_0: "Return type of index signature from exported interface has or is using private type '{0}'.",
+        Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_type_0: "Return type of public static method from exported class has or is using private type '{0}'.",
+        Return_type_of_public_method_from_exported_class_has_or_is_using_private_type_0: "Return type of public method from exported class has or is using private type '{0}'.",
+        Return_type_of_method_from_exported_interface_has_or_is_using_private_type_0: "Return type of method from exported interface has or is using private type '{0}'.",
+        Return_type_of_exported_function_has_or_is_using_private_type_0: "Return type of exported function has or is using private type '{0}'.",
+        Return_type_of_public_static_property_getter_from_exported_class_is_using_inaccessible_module_0: "Return type of public static property getter from exported class is using inaccessible module {0}.",
+        Return_type_of_public_property_getter_from_exported_class_is_using_inaccessible_module_0: "Return type of public property getter from exported class is using inaccessible module {0}.",
+        Return_type_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_0: "Return type of constructor signature from exported interface is using inaccessible module {0}.",
+        Return_type_of_call_signature_from_exported_interface_is_using_inaccessible_module_0: "Return type of call signature from exported interface is using inaccessible module {0}.",
+        Return_type_of_index_signature_from_exported_interface_is_using_inaccessible_module_0: "Return type of index signature from exported interface is using inaccessible module {0}.",
+        Return_type_of_public_static_method_from_exported_class_is_using_inaccessible_module_0: "Return type of public static method from exported class is using inaccessible module {0}.",
+        Return_type_of_public_method_from_exported_class_is_using_inaccessible_module_0: "Return type of public method from exported class is using inaccessible module {0}.",
+        Return_type_of_method_from_exported_interface_is_using_inaccessible_module_0: "Return type of method from exported interface is using inaccessible module {0}.",
+        Return_type_of_exported_function_is_using_inaccessible_module_0: "Return type of exported function is using inaccessible module {0}.",
+        new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead: "'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.",
+        A_parameter_list_must_follow_a_generic_type_argument_list_expected: "A parameter list must follow a generic type argument list. '(' expected.",
+        Multiple_constructor_implementations_are_not_allowed: "Multiple constructor implementations are not allowed.",
+        Unable_to_resolve_external_module_0: "Unable to resolve external module '{0}'.",
+        Module_cannot_be_aliased_to_a_non_module_type: "Module cannot be aliased to a non-module type.",
+        A_class_may_only_extend_another_class: "A class may only extend another class.",
+        A_class_may_only_implement_another_class_or_interface: "A class may only implement another class or interface.",
+        An_interface_may_only_extend_another_class_or_interface: "An interface may only extend another class or interface.",
+        Unable_to_resolve_type: "Unable to resolve type.",
+        Unable_to_resolve_type_of_0: "Unable to resolve type of '{0}'.",
+        Unable_to_resolve_type_parameter_constraint: "Unable to resolve type parameter constraint.",
+        Type_parameter_constraint_cannot_be_a_primitive_type: "Type parameter constraint cannot be a primitive type.",
+        Supplied_parameters_do_not_match_any_signature_of_call_target: "Supplied parameters do not match any signature of call target.",
+        Supplied_parameters_do_not_match_any_signature_of_call_target_NL_0: "Supplied parameters do not match any signature of call target:{NL}{0}",
+        Invalid_new_expression: "Invalid 'new' expression.",
+        Call_signatures_used_in_a_new_expression_must_have_a_void_return_type: "Call signatures used in a 'new' expression must have a 'void' return type.",
+        Could_not_select_overload_for_new_expression: "Could not select overload for 'new' expression.",
+        Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2: "Type '{0}' does not satisfy the constraint '{1}' for type parameter '{2}'.",
+        Could_not_select_overload_for_call_expression: "Could not select overload for 'call' expression.",
+        Cannot_invoke_an_expression_whose_type_lacks_a_call_signature: "Cannot invoke an expression whose type lacks a call signature.",
+        Calls_to_super_are_only_valid_inside_a_class: "Calls to 'super' are only valid inside a class.",
+        Generic_type_0_requires_1_type_argument_s: "Generic type '{0}' requires {1} type argument(s).",
+        Type_of_array_literal_cannot_be_determined_Best_common_type_could_not_be_found_for_array_elements: "Type of array literal cannot be determined. Best common type could not be found for array elements.",
+        Could_not_find_enclosing_symbol_for_dotted_name_0: "Could not find enclosing symbol for dotted name '{0}'.",
+        The_property_0_does_not_exist_on_value_of_type_1: "The property '{0}' does not exist on value of type '{1}'.",
+        Could_not_find_symbol_0: "Could not find symbol '{0}'.",
+        get_and_set_accessor_must_have_the_same_type: "'get' and 'set' accessor must have the same type.",
+        this_cannot_be_referenced_in_current_location: "'this' cannot be referenced in current location.",
+        Static_members_cannot_reference_class_type_parameters: "Static members cannot reference class type parameters.",
+        Class_0_is_recursively_referenced_as_a_base_type_of_itself: "Class '{0}' is recursively referenced as a base type of itself.",
+        Interface_0_is_recursively_referenced_as_a_base_type_of_itself: "Interface '{0}' is recursively referenced as a base type of itself.",
+        super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.",
+        super_cannot_be_referenced_in_non_derived_classes: "'super' cannot be referenced in non-derived classes.",
+        A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties: "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties.",
+        Constructors_for_derived_classes_must_contain_a_super_call: "Constructors for derived classes must contain a 'super' call.",
+        Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors: "Super calls are not permitted outside constructors or in nested functions inside constructors.",
+        _0_1_is_inaccessible: "'{0}.{1}' is inaccessible.",
+        this_cannot_be_referenced_within_module_bodies: "'this' cannot be referenced within module bodies.",
+        Invalid_expression_types_not_known_to_support_the_addition_operator: "Invalid '+' expression - types not known to support the addition operator.",
+        The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: "The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.",
+        The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: "The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.",
+        The_type_of_a_unary_arithmetic_operation_operand_must_be_of_type_any_number_or_an_enum_type: "The type of a unary arithmetic operation operand must be of type 'any', 'number' or an enum type.",
+        Variable_declarations_of_a_for_statement_cannot_use_a_type_annotation: "Variable declarations of a 'for' statement cannot use a type annotation.",
+        Variable_declarations_of_a_for_statement_must_be_of_types_string_or_any: "Variable declarations of a 'for' statement must be of types 'string' or 'any'.",
+        The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter: "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter.",
+        The_left_hand_side_of_an_in_expression_must_be_of_types_any_string_or_number: "The left-hand side of an 'in' expression must be of types 'any', 'string' or 'number'.",
+        The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter.",
+        The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.",
+        The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type: "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type.",
+        Setters_cannot_return_a_value: "Setters cannot return a value.",
+        Tried_to_query_type_of_uninitialized_module_0: "Tried to query type of uninitialized module '{0}'.",
+        Tried_to_set_variable_type_to_uninitialized_module_type_0: "Tried to set variable type to uninitialized module type '{0}'.",
+        Type_0_does_not_have_type_parameters: "Type '{0}' does not have type parameters.",
+        Getters_must_return_a_value: "Getters must return a value.",
+        Getter_and_setter_accessors_do_not_agree_in_visibility: "Getter and setter accessors do not agree in visibility.",
+        Invalid_left_hand_side_of_assignment_expression: "Invalid left-hand side of assignment expression.",
+        Function_declared_a_non_void_return_type_but_has_no_return_expression: "Function declared a non-void return type, but has no return expression.",
+        Cannot_resolve_return_type_reference: "Cannot resolve return type reference.",
+        Constructors_cannot_have_a_return_type_of_void: "Constructors cannot have a return type of 'void'.",
+        Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: "Subsequent variable declarations must have the same type.  Variable '{0}' must be of type '{1}', but here has type '{2}'.",
+        All_symbols_within_a_with_block_will_be_resolved_to_any: "All symbols within a with block will be resolved to 'any'.",
+        Import_declarations_in_an_internal_module_cannot_reference_an_external_module: "Import declarations in an internal module cannot reference an external module.",
+        Class_0_declares_interface_1_but_does_not_implement_it_NL_2: "Class {0} declares interface {1} but does not implement it:{NL}{2}",
+        Class_0_declares_class_1_as_an_interface_but_does_not_implement_it_NL_2: "Class {0} declares class {1} as an interface but does not implement it:{NL}{2}",
+        The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer: "The operand of an increment or decrement operator must be a variable, property or indexer.",
+        this_cannot_be_referenced_in_static_initializers_in_a_class_body: "'this' cannot be referenced in static initializers in a class body.",
+        Class_0_cannot_extend_class_1_NL_2: "Class '{0}' cannot extend class '{1}':{NL}{2}",
+        Interface_0_cannot_extend_class_1_NL_2: "Interface '{0}' cannot extend class '{1}':{NL}{2}",
+        Interface_0_cannot_extend_interface_1_NL_2: "Interface '{0}' cannot extend interface '{1}':{NL}{2}",
+        Duplicate_overload_signature_for_0: "Duplicate overload signature for '{0}'.",
+        Duplicate_constructor_overload_signature: "Duplicate constructor overload signature.",
+        Duplicate_overload_call_signature: "Duplicate overload call signature.",
+        Duplicate_overload_construct_signature: "Duplicate overload construct signature.",
+        Overload_signature_is_not_compatible_with_function_definition: "Overload signature is not compatible with function definition.",
+        Overload_signature_is_not_compatible_with_function_definition_NL_0: "Overload signature is not compatible with function definition:{NL}{0}",
+        Overload_signatures_must_all_be_public_or_private: "Overload signatures must all be public or private.",
+        Overload_signatures_must_all_be_exported_or_not_exported: "Overload signatures must all be exported or not exported.",
+        Overload_signatures_must_all_be_ambient_or_non_ambient: "Overload signatures must all be ambient or non-ambient.",
+        Overload_signatures_must_all_be_optional_or_required: "Overload signatures must all be optional or required.",
+        Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature: "Specialized overload signature is not assignable to any non-specialized signature.",
+        this_cannot_be_referenced_in_constructor_arguments: "'this' cannot be referenced in constructor arguments.",
+        Instance_member_cannot_be_accessed_off_a_class: "Instance member cannot be accessed off a class.",
+        Untyped_function_calls_may_not_accept_type_arguments: "Untyped function calls may not accept type arguments.",
+        Non_generic_functions_may_not_accept_type_arguments: "Non-generic functions may not accept type arguments.",
+        A_generic_type_may_not_reference_itself_with_a_wrapped_form_of_its_own_type_parameters: "A generic type may not reference itself with a wrapped form of its own type parameters.",
+        Rest_parameters_must_be_array_types: "Rest parameters must be array types.",
+        Overload_signature_implementation_cannot_use_specialized_type: "Overload signature implementation cannot use specialized type.",
+        Export_assignments_may_only_be_used_at_the_top_level_of_external_modules: "Export assignments may only be used at the top-level of external modules.",
+        Export_assignments_may_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules: "Export assignments may only be made with variables, functions, classes, interfaces, enums and internal modules.",
+        Only_public_methods_of_the_base_class_are_accessible_via_the_super_keyword: "Only public methods of the base class are accessible via the 'super' keyword.",
+        Numeric_indexer_type_0_must_be_assignable_to_string_indexer_type_1: "Numeric indexer type '{0}' must be assignable to string indexer type '{1}'.",
+        Numeric_indexer_type_0_must_be_assignable_to_string_indexer_type_1_NL_2: "Numeric indexer type '{0}' must be assignable to string indexer type '{1}':{NL}{2}",
+        All_numerically_named_properties_must_be_assignable_to_numeric_indexer_type_0: "All numerically named properties must be assignable to numeric indexer type '{0}'.",
+        All_numerically_named_properties_must_be_assignable_to_numeric_indexer_type_0_NL_1: "All numerically named properties must be assignable to numeric indexer type '{0}':{NL}{1}",
+        All_named_properties_must_be_assignable_to_string_indexer_type_0: "All named properties must be assignable to string indexer type '{0}'.",
+        All_named_properties_must_be_assignable_to_string_indexer_type_0_NL_1: "All named properties must be assignable to string indexer type '{0}':{NL}{1}",
+        Generic_type_references_must_include_all_type_arguments: "Generic type references must include all type arguments.",
+        Default_arguments_are_only_allowed_in_implementation: "Default arguments are only allowed in implementation.",
+        Overloads_cannot_differ_only_by_return_type: "Overloads cannot differ only by return type.",
+        Function_expression_declared_a_non_void_return_type_but_has_no_return_expression: "Function expression declared a non-void return type, but has no return expression.",
+        Import_declaration_referencing_identifier_from_internal_module_can_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules: "Import declaration referencing identifier from internal module can only be made with variables, functions, classes, interfaces, enums and internal modules.",
+        Could_not_find_symbol_0_in_module_1: "Could not find symbol '{0}' in module '{1}'.",
+        Unable_to_resolve_module_reference_0: "Unable to resolve module reference '{0}'.",
+        Could_not_find_module_0_in_module_1: "Could not find module '{0}' in module '{1}'.",
+        Exported_import_declaration_0_is_assigned_value_with_type_that_has_or_is_using_private_type_1: "Exported import declaration '{0}' is assigned value with type that has or is using private type '{1}'.",
+        Exported_import_declaration_0_is_assigned_value_with_type_that_is_using_inaccessible_module_1: "Exported import declaration '{0}' is assigned value with type that is using inaccessible module '{1}'.",
+        Exported_import_declaration_0_is_assigned_type_that_has_or_is_using_private_type_1: "Exported import declaration '{0}' is assigned type that has or is using private type '{1}'.",
+        Exported_import_declaration_0_is_assigned_type_that_is_using_inaccessible_module_1: "Exported import declaration '{0}' is assigned type that is using inaccessible module '{1}'.",
+        Exported_import_declaration_0_is_assigned_container_that_is_or_is_using_inaccessible_module_1: "Exported import declaration '{0}' is assigned container that is or is using inaccessible module '{1}'.",
+        Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_1: "Type name '{0}' in extends clause does not reference constructor function for '{1}'.",
+        Internal_module_reference_0_in_import_declaration_does_not_reference_module_instance_for_1: "Internal module reference '{0}' in import declaration does not reference module instance for '{1}'.",
+        Module_0_cannot_merge_with_previous_declaration_of_1_in_a_different_file_2: "Module '{0}' cannot merge with previous declaration of '{1}' in a different file '{2}'.",
+        Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3: "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}':{NL}{3}",
+        Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it: "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it.",
+        Ambient_external_module_declaration_cannot_be_reopened: "Ambient external module declaration cannot be reopened.",
+        All_declarations_of_merged_declaration_0_must_be_exported_or_not_exported: "All declarations of merged declaration '{0}' must be exported or not exported.",
+        super_cannot_be_referenced_in_constructor_arguments: "'super' cannot be referenced in constructor arguments.",
+        Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class: "Return type of constructor signature must be assignable to the instance type of the class.",
+        Ambient_external_module_declaration_must_be_defined_in_global_context: "Ambient external module declaration must be defined in global context.",
+        Ambient_external_module_declaration_cannot_specify_relative_module_name: "Ambient external module declaration cannot specify relative module name.",
+        Import_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name: "Import declaration in an ambient external module declaration cannot reference external module through relative external module name.",
+        Could_not_find_the_best_common_type_of_types_of_all_return_statement_expressions: "Could not find the best common type of types of all return statement expressions.",
+        Import_declaration_cannot_refer_to_external_module_reference_when_noResolve_option_is_set: "Import declaration cannot refer to external module reference when --noResolve option is set.",
+        Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference.",
+        continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: "'continue' statement can only be used within an enclosing iteration statement.",
+        break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: "'break' statement can only be used within an enclosing iteration or switch statement.",
+        Jump_target_not_found: "Jump target not found.",
+        Jump_target_cannot_cross_function_boundary: "Jump target cannot cross function boundary.",
+        Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference: "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference.",
+        Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference.",
+        Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: "Expression resolves to '_super' that compiler uses to capture base class reference.",
+        TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.",
+        TypeParameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of call signature from exported interface has or is using private type '{1}'.",
+        TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1: "TypeParameter '{0}' of public static method from exported class has or is using private type '{1}'.",
+        TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1: "TypeParameter '{0}' of public method from exported class has or is using private type '{1}'.",
+        TypeParameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of method from exported interface has or is using private type '{1}'.",
+        TypeParameter_0_of_exported_function_has_or_is_using_private_type_1: "TypeParameter '{0}' of exported function has or is using private type '{1}'.",
+        TypeParameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.",
+        TypeParameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of call signature from exported interface is using inaccessible module {1}",
+        TypeParameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1: "TypeParameter '{0}' of public static method from exported class is using inaccessible module {1}.",
+        TypeParameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1: "TypeParameter '{0}' of public method from exported class is using inaccessible module {1}.",
+        TypeParameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of method from exported interface is using inaccessible module {1}.",
+        TypeParameter_0_of_exported_function_is_using_inaccessible_module_1: "TypeParameter '{0}' of exported function is using inaccessible module {1}.",
+        TypeParameter_0_of_exported_class_has_or_is_using_private_type_1: "TypeParameter '{0}' of exported class has or is using private type '{1}'.",
+        TypeParameter_0_of_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of exported interface has or is using private type '{1}'.",
+        TypeParameter_0_of_exported_class_is_using_inaccessible_module_1: "TypeParameter '{0}' of exported class is using inaccessible module {1}.",
+        TypeParameter_0_of_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of exported interface is using inaccessible module {1}.",
+        Duplicate_identifier_i_Compiler_uses_i_to_initialize_rest_parameter: "Duplicate identifier '_i'. Compiler uses '_i' to initialize rest parameter.",
+        Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters: "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.",
+        Type_of_conditional_0_must_be_identical_to_1_or_2: "Type of conditional '{0}' must be identical to '{1}' or '{2}'.",
+        Type_of_conditional_0_must_be_identical_to_1_2_or_3: "Type of conditional '{0}' must be identical to '{1}', '{2}' or '{3}'.",
+        Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module: "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of an external module.",
+        Constraint_of_a_type_parameter_cannot_reference_any_type_parameter_from_the_same_type_parameter_list: "Constraint of a type parameter cannot reference any type parameter from the same type parameter list.",
+        Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor.",
+        Parameter_0_cannot_be_referenced_in_its_initializer: "Parameter '{0}' cannot be referenced in its initializer.",
+        Duplicate_string_index_signature: "Duplicate string index signature.",
+        Duplicate_number_index_signature: "Duplicate number index signature.",
+        All_declarations_of_an_interface_must_have_identical_type_parameters: "All declarations of an interface must have identical type parameters.",
+        Expression_resolves_to_variable_declaration_i_that_compiler_uses_to_initialize_rest_parameter: "Expression resolves to variable declaration '_i' that compiler uses to initialize rest parameter.",
+        Type_0_is_missing_property_1_from_type_2: "Type '{0}' is missing property '{1}' from type '{2}'.",
+        Types_of_property_0_of_types_1_and_2_are_incompatible: "Types of property '{0}' of types '{1}' and '{2}' are incompatible.",
+        Types_of_property_0_of_types_1_and_2_are_incompatible_NL_3: "Types of property '{0}' of types '{1}' and '{2}' are incompatible:{NL}{3}",
+        Property_0_defined_as_private_in_type_1_is_defined_as_public_in_type_2: "Property '{0}' defined as private in type '{1}' is defined as public in type '{2}'.",
+        Property_0_defined_as_public_in_type_1_is_defined_as_private_in_type_2: "Property '{0}' defined as public in type '{1}' is defined as private in type '{2}'.",
+        Types_0_and_1_define_property_2_as_private: "Types '{0}' and '{1}' define property '{2}' as private.",
+        Call_signatures_of_types_0_and_1_are_incompatible: "Call signatures of types '{0}' and '{1}' are incompatible.",
+        Call_signatures_of_types_0_and_1_are_incompatible_NL_2: "Call signatures of types '{0}' and '{1}' are incompatible:{NL}{2}",
+        Type_0_requires_a_call_signature_but_type_1_lacks_one: "Type '{0}' requires a call signature, but type '{1}' lacks one.",
+        Construct_signatures_of_types_0_and_1_are_incompatible: "Construct signatures of types '{0}' and '{1}' are incompatible.",
+        Construct_signatures_of_types_0_and_1_are_incompatible_NL_2: "Construct signatures of types '{0}' and '{1}' are incompatible:{NL}{2}",
+        Type_0_requires_a_construct_signature_but_type_1_lacks_one: "Type '{0}' requires a construct signature, but type '{1}' lacks one.",
+        Index_signatures_of_types_0_and_1_are_incompatible: "Index signatures of types '{0}' and '{1}' are incompatible.",
+        Index_signatures_of_types_0_and_1_are_incompatible_NL_2: "Index signatures of types '{0}' and '{1}' are incompatible:{NL}{2}",
+        Call_signature_expects_0_or_fewer_parameters: "Call signature expects {0} or fewer parameters.",
+        Could_not_apply_type_0_to_argument_1_which_is_of_type_2: "Could not apply type '{0}' to argument {1} which is of type '{2}'.",
+        Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function.",
+        Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function.",
+        Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor.",
+        Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property.",
+        Types_of_static_property_0_of_class_1_and_class_2_are_incompatible: "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible.",
+        Types_of_static_property_0_of_class_1_and_class_2_are_incompatible_NL_3: "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible:{NL}{3}",
+        Type_reference_cannot_refer_to_container_0: "Type reference cannot refer to container '{0}'.",
+        Type_reference_must_refer_to_type: "Type reference must refer to type.",
+        In_enums_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_the_first_enum_element: "In enums with multiple declarations only one declaration can omit an initializer for the first enum element.",
+        _0_overload_s: " (+ {0} overload(s))",
+        Variable_declaration_cannot_have_the_same_name_as_an_import_declaration: "Variable declaration cannot have the same name as an import declaration.",
+        Signature_expected_0_type_arguments_got_1_instead: "Signature expected {0} type arguments, got {1} instead.",
+        Property_0_defined_as_optional_in_type_1_but_is_required_in_type_2: "Property '{0}' defined as optional in type '{1}', but is required in type '{2}'.",
+        Types_0_and_1_originating_in_infinitely_expanding_type_reference_do_not_refer_to_same_named_type: "Types '{0}' and '{1}' originating in infinitely expanding type reference do not refer to same named type.",
+        Types_0_and_1_originating_in_infinitely_expanding_type_reference_have_incompatible_type_arguments: "Types '{0}' and '{1}' originating in infinitely expanding type reference have incompatible type arguments.",
+        Types_0_and_1_originating_in_infinitely_expanding_type_reference_have_incompatible_type_arguments_NL_2: "Types '{0}' and '{1}' originating in infinitely expanding type reference have incompatible type arguments:{NL}{2}",
+        Named_properties_0_of_types_1_and_2_are_not_identical: "Named properties '{0}' of types '{1}' and '{2}' are not identical.",
+        Types_of_string_indexer_of_types_0_and_1_are_not_identical: "Types of string indexer of types '{0}' and '{1}' are not identical.",
+        Types_of_number_indexer_of_types_0_and_1_are_not_identical: "Types of number indexer of types '{0}' and '{1}' are not identical.",
+        Type_of_number_indexer_in_type_0_is_not_assignable_to_string_indexer_type_in_type_1_NL_2: "Type of number indexer in type '{0}' is not assignable to string indexer type in type '{1}'.{NL}{2}",
+        Type_of_property_0_in_type_1_is_not_assignable_to_string_indexer_type_in_type_2_NL_3: "Type of property '{0}' in type '{1}' is not assignable to string indexer type in type '{2}'.{NL}{3}",
+        Type_of_property_0_in_type_1_is_not_assignable_to_number_indexer_type_in_type_2_NL_3: "Type of property '{0}' in type '{1}' is not assignable to number indexer type in type '{2}'.{NL}{3}",
+        Static_property_0_defined_as_private_in_type_1_is_defined_as_public_in_type_2: "Static property '{0}' defined as private in type '{1}' is defined as public in type '{2}'.",
+        Static_property_0_defined_as_public_in_type_1_is_defined_as_private_in_type_2: "Static property '{0}' defined as public in type '{1}' is defined as private in type '{2}'.",
+        Types_0_and_1_define_static_property_2_as_private: "Types '{0}' and '{1}' define static property '{2}' as private.",
+        Current_host_does_not_support_0_option: "Current host does not support '{0}' option.",
+        ECMAScript_target_version_0_not_supported_Specify_a_valid_target_version_1_default_or_2: "ECMAScript target version '{0}' not supported.  Specify a valid target version: '{1}' (default), or '{2}'",
+        Module_code_generation_0_not_supported: "Module code generation '{0}' not supported.",
+        Could_not_find_file_0: "Could not find file: '{0}'.",
+        A_file_cannot_have_a_reference_to_itself: "A file cannot have a reference to itself.",
+        Cannot_resolve_referenced_file_0: "Cannot resolve referenced file: '{0}'.",
+        Cannot_find_the_common_subdirectory_path_for_the_input_files: "Cannot find the common subdirectory path for the input files.",
+        Emit_Error_0: "Emit Error: {0}.",
+        Cannot_read_file_0_1: "Cannot read file '{0}': {1}",
+        Unsupported_file_encoding: "Unsupported file encoding.",
+        Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1: "Locale must be of the form <language> or <language>-<territory>. For example '{0}' or '{1}'.",
+        Unsupported_locale_0: "Unsupported locale: '{0}'.",
+        Execution_Failed_NL: "Execution Failed.{NL}",
+        Invalid_call_to_up: "Invalid call to 'up'",
+        Invalid_call_to_down: "Invalid call to 'down'",
+        Base64_value_0_finished_with_a_continuation_bit: "Base64 value '{0}' finished with a continuation bit.",
+        Unknown_option_0: "Unknown option '{0}'",
+        Expected_0_arguments_to_message_got_1_instead: "Expected {0} arguments to message, got {1} instead.",
+        Expected_the_message_0_to_have_1_arguments_but_it_had_2: "Expected the message '{0}' to have {1} arguments, but it had {2}",
+        Could_not_delete_file_0: "Could not delete file '{0}'",
+        Could_not_create_directory_0: "Could not create directory '{0}'",
+        Error_while_executing_file_0: "Error while executing file '{0}': ",
+        Cannot_compile_external_modules_unless_the_module_flag_is_provided: "Cannot compile external modules unless the '--module' flag is provided.",
+        Option_mapRoot_cannot_be_specified_without_specifying_sourcemap_option: "Option mapRoot cannot be specified without specifying sourcemap option.",
+        Option_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option: "Option sourceRoot cannot be specified without specifying sourcemap option.",
+        Options_mapRoot_and_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option: "Options mapRoot and sourceRoot cannot be specified without specifying sourcemap option.",
+        Option_0_specified_without_1: "Option '{0}' specified without '{1}'",
+        codepage_option_not_supported_on_current_platform: "'codepage' option not supported on current platform.",
+        Concatenate_and_emit_output_to_single_file: "Concatenate and emit output to single file.",
+        Generates_corresponding_0_file: "Generates corresponding {0} file.",
+        Specifies_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: "Specifies the location where debugger should locate map files instead of generated locations.",
+        Specifies_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations: "Specifies the location where debugger should locate TypeScript files instead of source locations.",
+        Watch_input_files: "Watch input files.",
+        Redirect_output_structure_to_the_directory: "Redirect output structure to the directory.",
+        Do_not_emit_comments_to_output: "Do not emit comments to output.",
+        Skip_resolution_and_preprocessing: "Skip resolution and preprocessing.",
+        Specify_ECMAScript_target_version_0_default_or_1: "Specify ECMAScript target version: '{0}' (default), or '{1}'",
+        Specify_module_code_generation_0_or_1: "Specify module code generation: '{0}' or '{1}'",
+        Print_this_message: "Print this message.",
+        Print_the_compiler_s_version_0: "Print the compiler's version: {0}",
+        Allow_use_of_deprecated_0_keyword_when_referencing_an_external_module: "Allow use of deprecated '{0}' keyword when referencing an external module.",
+        Specify_locale_for_errors_and_messages_For_example_0_or_1: "Specify locale for errors and messages. For example '{0}' or '{1}'",
+        Syntax_0: "Syntax:   {0}",
+        options: "options",
+        file1: "file",
+        Examples: "Examples:",
+        Options: "Options:",
+        Insert_command_line_options_and_files_from_a_file: "Insert command line options and files from a file.",
+        Version_0: "Version {0}",
+        Use_the_0_flag_to_see_options: "Use the '{0}' flag to see options.",
+        NL_Recompiling_0: "{NL}Recompiling ({0}):",
+        STRING: "STRING",
+        KIND: "KIND",
+        file2: "FILE",
+        VERSION: "VERSION",
+        LOCATION: "LOCATION",
+        DIRECTORY: "DIRECTORY",
+        NUMBER: "NUMBER",
+        Specify_the_codepage_to_use_when_opening_source_files: "Specify the codepage to use when opening source files.",
+        Additional_locations: "Additional locations:",
+        This_version_of_the_Javascript_runtime_does_not_support_the_0_function: "This version of the Javascript runtime does not support the '{0}' function.",
+        Unknown_rule: "Unknown rule.",
+        Invalid_line_number_0: "Invalid line number ({0})",
+        Warn_on_expressions_and_declarations_with_an_implied_any_type: "Warn on expressions and declarations with an implied 'any' type.",
+        Variable_0_implicitly_has_an_any_type: "Variable '{0}' implicitly has an 'any' type.",
+        Parameter_0_of_1_implicitly_has_an_any_type: "Parameter '{0}' of '{1}' implicitly has an 'any' type.",
+        Parameter_0_of_function_type_implicitly_has_an_any_type: "Parameter '{0}' of function type implicitly has an 'any' type.",
+        Member_0_of_object_type_implicitly_has_an_any_type: "Member '{0}' of object type implicitly has an 'any' type.",
+        new_expression_which_lacks_a_constructor_signature_implicitly_has_an_any_type: "'new' expression, which lacks a constructor signature, implicitly has an 'any' type.",
+        _0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "'{0}', which lacks return-type annotation, implicitly has an 'any' return type.",
+        Function_expression_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "Function expression, which lacks return-type annotation, implicitly has an 'any' return type.",
+        Parameter_0_of_lambda_function_implicitly_has_an_any_type: "Parameter '{0}' of lambda function implicitly has an 'any' type.",
+        Constructor_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "Constructor signature, which lacks return-type annotation, implicitly has an 'any' return type.",
+        Lambda_Function_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "Lambda Function, which lacks return-type annotation, implicitly has an 'any' return type.",
+        Array_Literal_implicitly_has_an_any_type_from_widening: "Array Literal implicitly has an 'any' type from widening.",
+        _0_which_lacks_get_accessor_and_parameter_type_annotation_on_set_accessor_implicitly_has_an_any_type: "'{0}', which lacks 'get' accessor and parameter type annotation on 'set' accessor, implicitly has an 'any' type.",
+        Index_signature_of_object_type_implicitly_has_an_any_type: "Index signature of object type implicitly has an 'any' type.",
+        Object_literal_s_property_0_implicitly_has_an_any_type_from_widening: "Object literal's property '{0}' implicitly has an 'any' type from widening."
+    };
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var ArrayUtilities = (function () {
+        function ArrayUtilities() {
+        }
+        ArrayUtilities.isArray = function (value) {
+            return Object.prototype.toString.apply(value, []) === '[object Array]';
+        };
+
+        ArrayUtilities.sequenceEquals = function (array1, array2, equals) {
+            if (array1 === array2) {
+                return true;
+            }
+
+            if (array1 === null || array2 === null) {
+                return false;
+            }
+
+            if (array1.length !== array2.length) {
+                return false;
+            }
+
+            for (var i = 0, n = array1.length; i < n; i++) {
+                if (!equals(array1[i], array2[i])) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        ArrayUtilities.contains = function (array, value) {
+            for (var i = 0; i < array.length; i++) {
+                if (array[i] === value) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        ArrayUtilities.groupBy = function (array, func) {
+            var result = {};
+
+            for (var i = 0, n = array.length; i < n; i++) {
+                var v = array[i];
+                var k = func(v);
+
+                var list = result[k] || [];
+                list.push(v);
+                result[k] = list;
+            }
+
+            return result;
+        };
+
+        ArrayUtilities.distinct = function (array, equalsFn) {
+            var result = [];
+
+            for (var i = 0, n = array.length; i < n; i++) {
+                var current = array[i];
+                for (var j = 0; j < result.length; j++) {
+                    if (equalsFn(result[j], current)) {
+                        break;
+                    }
+                }
+
+                if (j === result.length) {
+                    result.push(current);
+                }
+            }
+
+            return result;
+        };
+
+        ArrayUtilities.min = function (array, func) {
+            var min = func(array[0]);
+
+            for (var i = 1; i < array.length; i++) {
+                var next = func(array[i]);
+                if (next < min) {
+                    min = next;
+                }
+            }
+
+            return min;
+        };
+
+        ArrayUtilities.max = function (array, func) {
+            var max = func(array[0]);
+
+            for (var i = 1; i < array.length; i++) {
+                var next = func(array[i]);
+                if (next > max) {
+                    max = next;
+                }
+            }
+
+            return max;
+        };
+
+        ArrayUtilities.last = function (array) {
+            if (array.length === 0) {
+                throw TypeScript.Errors.argumentOutOfRange('array');
+            }
+
+            return array[array.length - 1];
+        };
+
+        ArrayUtilities.lastOrDefault = function (array, predicate) {
+            for (var i = array.length - 1; i >= 0; i--) {
+                var v = array[i];
+                if (predicate(v, i)) {
+                    return v;
+                }
+            }
+
+            return null;
+        };
+
+        ArrayUtilities.firstOrDefault = function (array, func) {
+            for (var i = 0, n = array.length; i < n; i++) {
+                var value = array[i];
+                if (func(value, i)) {
+                    return value;
+                }
+            }
+
+            return null;
+        };
+
+        ArrayUtilities.first = function (array, func) {
+            for (var i = 0, n = array.length; i < n; i++) {
+                var value = array[i];
+                if (!func || func(value, i)) {
+                    return value;
+                }
+            }
+
+            throw TypeScript.Errors.invalidOperation();
+        };
+
+        ArrayUtilities.sum = function (array, func) {
+            var result = 0;
+
+            for (var i = 0, n = array.length; i < n; i++) {
+                result += func(array[i]);
+            }
+
+            return result;
+        };
+
+        ArrayUtilities.select = function (values, func) {
+            var result = new Array(values.length);
+
+            for (var i = 0; i < values.length; i++) {
+                result[i] = func(values[i]);
+            }
+
+            return result;
+        };
+
+        ArrayUtilities.where = function (values, func) {
+            var result = new Array();
+
+            for (var i = 0; i < values.length; i++) {
+                if (func(values[i])) {
+                    result.push(values[i]);
+                }
+            }
+
+            return result;
+        };
+
+        ArrayUtilities.any = function (array, func) {
+            for (var i = 0, n = array.length; i < n; i++) {
+                if (func(array[i])) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        ArrayUtilities.all = function (array, func) {
+            for (var i = 0, n = array.length; i < n; i++) {
+                if (!func(array[i])) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        ArrayUtilities.binarySearch = function (array, value) {
+            var low = 0;
+            var high = array.length - 1;
+
+            while (low <= high) {
+                var middle = low + ((high - low) >> 1);
+                var midValue = array[middle];
+
+                if (midValue === value) {
+                    return middle;
+                } else if (midValue > value) {
+                    high = middle - 1;
+                } else {
+                    low = middle + 1;
+                }
+            }
+
+            return ~low;
+        };
+
+        ArrayUtilities.createArray = function (length, defaultValue) {
+            var result = new Array(length);
+            for (var i = 0; i < length; i++) {
+                result[i] = defaultValue;
+            }
+
+            return result;
+        };
+
+        ArrayUtilities.grow = function (array, length, defaultValue) {
+            var count = length - array.length;
+            for (var i = 0; i < count; i++) {
+                array.push(defaultValue);
+            }
+        };
+
+        ArrayUtilities.copy = function (sourceArray, sourceIndex, destinationArray, destinationIndex, length) {
+            for (var i = 0; i < length; i++) {
+                destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];
+            }
+        };
+
+        ArrayUtilities.indexOf = function (array, predicate) {
+            for (var i = 0, n = array.length; i < n; i++) {
+                if (predicate(array[i])) {
+                    return i;
+                }
+            }
+
+            return -1;
+        };
+        return ArrayUtilities;
+    })();
+    TypeScript.ArrayUtilities = ArrayUtilities;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (BitVector) {
+        var pool = [];
+        var Constants;
+        (function (Constants) {
+            Constants[Constants["MaxBitsPerEncodedNumber"] = 30] = "MaxBitsPerEncodedNumber";
+            Constants[Constants["BitsPerEncodedBiStateValue"] = 1] = "BitsPerEncodedBiStateValue";
+
+            Constants[Constants["BitsPerEncodedTriStateValue"] = 2] = "BitsPerEncodedTriStateValue";
+
+            Constants[Constants["BiStateEncodedTrue"] = 1] = "BiStateEncodedTrue";
+            Constants[Constants["BiStateClearBitsMask"] = 1] = "BiStateClearBitsMask";
+
+            Constants[Constants["TriStateEncodedFalse"] = 1] = "TriStateEncodedFalse";
+            Constants[Constants["TriStateEncodedTrue"] = 2] = "TriStateEncodedTrue";
+            Constants[Constants["TriStateClearBitsMask"] = 3] = "TriStateClearBitsMask";
+        })(Constants || (Constants = {}));
+
+        var BitVectorImpl = (function () {
+            function BitVectorImpl(allowUndefinedValues) {
+                this.allowUndefinedValues = allowUndefinedValues;
+                this.isReleased = false;
+                this.bits = [];
+            }
+            BitVectorImpl.prototype.computeTriStateArrayIndex = function (index) {
+                var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 2 /* BitsPerEncodedTriStateValue */;
+
+                return (index / encodedValuesPerNumber) >>> 0;
+            };
+
+            BitVectorImpl.prototype.computeBiStateArrayIndex = function (index) {
+                var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 1 /* BitsPerEncodedBiStateValue */;
+
+                return (index / encodedValuesPerNumber) >>> 0;
+            };
+
+            BitVectorImpl.prototype.computeTriStateEncodedValueIndex = function (index) {
+                var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 2 /* BitsPerEncodedTriStateValue */;
+
+                return (index % encodedValuesPerNumber) * 2 /* BitsPerEncodedTriStateValue */;
+            };
+
+            BitVectorImpl.prototype.computeBiStateEncodedValueIndex = function (index) {
+                var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 1 /* BitsPerEncodedBiStateValue */;
+
+                return (index % encodedValuesPerNumber) * 1 /* BitsPerEncodedBiStateValue */;
+            };
+
+            BitVectorImpl.prototype.valueAt = function (index) {
+                TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector");
+                if (this.allowUndefinedValues) {
+                    var arrayIndex = this.computeTriStateArrayIndex(index);
+                    var encoded = this.bits[arrayIndex];
+                    if (encoded === undefined) {
+                        return undefined;
+                    }
+
+                    var bitIndex = this.computeTriStateEncodedValueIndex(index);
+                    if (encoded & (2 /* TriStateEncodedTrue */ << bitIndex)) {
+                        return true;
+                    } else if (encoded & (1 /* TriStateEncodedFalse */ << bitIndex)) {
+                        return false;
+                    } else {
+                        return undefined;
+                    }
+                } else {
+                    var arrayIndex = this.computeBiStateArrayIndex(index);
+                    var encoded = this.bits[arrayIndex];
+                    if (encoded === undefined) {
+                        return false;
+                    }
+
+                    var bitIndex = this.computeBiStateEncodedValueIndex(index);
+                    if (encoded & (1 /* BiStateEncodedTrue */ << bitIndex)) {
+                        return true;
+                    } else {
+                        return false;
+                    }
+                }
+            };
+
+            BitVectorImpl.prototype.setValueAt = function (index, value) {
+                TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector");
+                if (this.allowUndefinedValues) {
+                    TypeScript.Debug.assert(value === true || value === false || value === undefined, "value must only be true, false or undefined.");
+
+                    var arrayIndex = this.computeTriStateArrayIndex(index);
+                    var encoded = this.bits[arrayIndex];
+                    if (encoded === undefined) {
+                        if (value === undefined) {
+                            return;
+                        }
+
+                        encoded = 0;
+                    }
+
+                    var bitIndex = this.computeTriStateEncodedValueIndex(index);
+
+                    var clearMask = ~(3 /* TriStateClearBitsMask */ << bitIndex);
+                    encoded = encoded & clearMask;
+
+                    if (value === true) {
+                        encoded = encoded | (2 /* TriStateEncodedTrue */ << bitIndex);
+                    } else if (value === false) {
+                        encoded = encoded | (1 /* TriStateEncodedFalse */ << bitIndex);
+                    }
+
+                    this.bits[arrayIndex] = encoded;
+                } else {
+                    TypeScript.Debug.assert(value === true || value === false, "value must only be true or false.");
+
+                    var arrayIndex = this.computeBiStateArrayIndex(index);
+                    var encoded = this.bits[arrayIndex];
+                    if (encoded === undefined) {
+                        if (value === false) {
+                            return;
+                        }
+
+                        encoded = 0;
+                    }
+
+                    var bitIndex = this.computeBiStateEncodedValueIndex(index);
+
+                    encoded = encoded & ~(1 /* BiStateClearBitsMask */ << bitIndex);
+
+                    if (value) {
+                        encoded = encoded | (1 /* BiStateEncodedTrue */ << bitIndex);
+                    }
+
+                    this.bits[arrayIndex] = encoded;
+                }
+            };
+
+            BitVectorImpl.prototype.release = function () {
+                TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector");
+                this.isReleased = true;
+                this.bits.length = 0;
+                pool.push(this);
+            };
+            return BitVectorImpl;
+        })();
+
+        function getBitVector(allowUndefinedValues) {
+            if (pool.length === 0) {
+                return new BitVectorImpl(allowUndefinedValues);
+            }
+
+            var vector = pool.pop();
+            vector.isReleased = false;
+            vector.allowUndefinedValues = allowUndefinedValues;
+
+            return vector;
+        }
+        BitVector.getBitVector = getBitVector;
+    })(TypeScript.BitVector || (TypeScript.BitVector = {}));
+    var BitVector = TypeScript.BitVector;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (BitMatrix) {
+        var pool = [];
+
+        var BitMatrixImpl = (function () {
+            function BitMatrixImpl(allowUndefinedValues) {
+                this.allowUndefinedValues = allowUndefinedValues;
+                this.isReleased = false;
+                this.vectors = [];
+            }
+            BitMatrixImpl.prototype.valueAt = function (x, y) {
+                TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector");
+                var vector = this.vectors[x];
+                if (!vector) {
+                    return this.allowUndefinedValues ? undefined : false;
+                }
+
+                return vector.valueAt(y);
+            };
+
+            BitMatrixImpl.prototype.setValueAt = function (x, y, value) {
+                TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector");
+                var vector = this.vectors[x];
+                if (!vector) {
+                    if (value === undefined) {
+                        return;
+                    }
+
+                    vector = TypeScript.BitVector.getBitVector(this.allowUndefinedValues);
+                    this.vectors[x] = vector;
+                }
+
+                vector.setValueAt(y, value);
+            };
+
+            BitMatrixImpl.prototype.release = function () {
+                TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector");
+                this.isReleased = true;
+
+                for (var name in this.vectors) {
+                    if (this.vectors.hasOwnProperty(name)) {
+                        var vector = this.vectors[name];
+                        vector.release();
+                    }
+                }
+
+                this.vectors.length = 0;
+                pool.push(this);
+            };
+            return BitMatrixImpl;
+        })();
+
+        function getBitMatrix(allowUndefinedValues) {
+            if (pool.length === 0) {
+                return new BitMatrixImpl(allowUndefinedValues);
+            }
+
+            var matrix = pool.pop();
+            matrix.isReleased = false;
+            matrix.allowUndefinedValues = allowUndefinedValues;
+
+            return matrix;
+        }
+        BitMatrix.getBitMatrix = getBitMatrix;
+    })(TypeScript.BitMatrix || (TypeScript.BitMatrix = {}));
+    var BitMatrix = TypeScript.BitMatrix;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (Constants) {
+        Constants[Constants["Max31BitInteger"] = 1073741823] = "Max31BitInteger";
+        Constants[Constants["Min31BitInteger"] = -1073741824] = "Min31BitInteger";
+    })(TypeScript.Constants || (TypeScript.Constants = {}));
+    var Constants = TypeScript.Constants;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (AssertionLevel) {
+        AssertionLevel[AssertionLevel["None"] = 0] = "None";
+        AssertionLevel[AssertionLevel["Normal"] = 1] = "Normal";
+        AssertionLevel[AssertionLevel["Aggressive"] = 2] = "Aggressive";
+        AssertionLevel[AssertionLevel["VeryAggressive"] = 3] = "VeryAggressive";
+    })(TypeScript.AssertionLevel || (TypeScript.AssertionLevel = {}));
+    var AssertionLevel = TypeScript.AssertionLevel;
+
+    var Debug = (function () {
+        function Debug() {
+        }
+        Debug.shouldAssert = function (level) {
+            return this.currentAssertionLevel >= level;
+        };
+
+        Debug.assert = function (expression, message, verboseDebugInfo) {
+            if (typeof message === "undefined") { message = ""; }
+            if (typeof verboseDebugInfo === "undefined") { verboseDebugInfo = null; }
+            if (!expression) {
+                var verboseDebugString = "";
+                if (verboseDebugInfo) {
+                    verboseDebugString = "\r\nVerbose Debug Information:" + verboseDebugInfo();
+                }
+
+                throw new Error("Debug Failure. False expression: " + message + verboseDebugString);
+            }
+        };
+
+        Debug.fail = function (message) {
+            Debug.assert(false, message);
+        };
+        Debug.currentAssertionLevel = 0 /* None */;
+        return Debug;
+    })();
+    TypeScript.Debug = Debug;
+})(TypeScript || (TypeScript = {}));
+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 TypeScript;
+(function (TypeScript) {
+    TypeScript.LocalizedDiagnosticMessages = null;
+
+    var Location = (function () {
+        function Location(fileName, lineMap, start, length) {
+            this._fileName = fileName;
+            this._lineMap = lineMap;
+            this._start = start;
+            this._length = length;
+        }
+        Location.prototype.fileName = function () {
+            return this._fileName;
+        };
+
+        Location.prototype.lineMap = function () {
+            return this._lineMap;
+        };
+
+        Location.prototype.line = function () {
+            return this._lineMap ? this._lineMap.getLineNumberFromPosition(this.start()) : 0;
+        };
+
+        Location.prototype.character = function () {
+            return this._lineMap ? this._lineMap.getLineAndCharacterFromPosition(this.start()).character() : 0;
+        };
+
+        Location.prototype.start = function () {
+            return this._start;
+        };
+
+        Location.prototype.length = function () {
+            return this._length;
+        };
+
+        Location.equals = function (location1, location2) {
+            return location1._fileName === location2._fileName && location1._start === location2._start && location1._length === location2._length;
+        };
+        return Location;
+    })();
+    TypeScript.Location = Location;
+
+    var Diagnostic = (function (_super) {
+        __extends(Diagnostic, _super);
+        function Diagnostic(fileName, lineMap, start, length, diagnosticKey, _arguments, additionalLocations) {
+            if (typeof _arguments === "undefined") { _arguments = null; }
+            if (typeof additionalLocations === "undefined") { additionalLocations = null; }
+            _super.call(this, fileName, lineMap, start, length);
+            this._diagnosticKey = diagnosticKey;
+            this._arguments = (_arguments && _arguments.length > 0) ? _arguments : null;
+            this._additionalLocations = (additionalLocations && additionalLocations.length > 0) ? additionalLocations : null;
+        }
+        Diagnostic.prototype.toJSON = function (key) {
+            var result = {};
+            result.start = this.start();
+            result.length = this.length();
+
+            result.diagnosticCode = this._diagnosticKey;
+
+            var _arguments = this.arguments();
+            if (_arguments && _arguments.length > 0) {
+                result.arguments = _arguments;
+            }
+
+            return result;
+        };
+
+        Diagnostic.prototype.diagnosticKey = function () {
+            return this._diagnosticKey;
+        };
+
+        Diagnostic.prototype.arguments = function () {
+            return this._arguments;
+        };
+
+        Diagnostic.prototype.text = function () {
+            return TypeScript.getLocalizedText(this._diagnosticKey, this._arguments);
+        };
+
+        Diagnostic.prototype.message = function () {
+            return TypeScript.getDiagnosticMessage(this._diagnosticKey, this._arguments);
+        };
+
+        Diagnostic.prototype.additionalLocations = function () {
+            return this._additionalLocations || [];
+        };
+
+        Diagnostic.equals = function (diagnostic1, diagnostic2) {
+            return Location.equals(diagnostic1, diagnostic2) && diagnostic1._diagnosticKey === diagnostic2._diagnosticKey && TypeScript.ArrayUtilities.sequenceEquals(diagnostic1._arguments, diagnostic2._arguments, function (v1, v2) {
+                return v1 === v2;
+            });
+        };
+
+        Diagnostic.prototype.info = function () {
+            return getDiagnosticInfoFromKey(this.diagnosticKey());
+        };
+        return Diagnostic;
+    })(Location);
+    TypeScript.Diagnostic = Diagnostic;
+
+    function newLine() {
+        return TypeScript.Environment ? TypeScript.Environment.newLine : "\r\n";
+    }
+    TypeScript.newLine = newLine;
+
+    function getLargestIndex(diagnostic) {
+        var largest = -1;
+        var regex = /\{(\d+)\}/g;
+
+        var match;
+        while (match = regex.exec(diagnostic)) {
+            var val = parseInt(match[1]);
+            if (!isNaN(val) && val > largest) {
+                largest = val;
+            }
+        }
+
+        return largest;
+    }
+
+    function getDiagnosticInfoFromKey(diagnosticKey) {
+        var result = TypeScript.diagnosticInformationMap[diagnosticKey];
+        TypeScript.Debug.assert(result);
+        return result;
+    }
+
+    function getLocalizedText(diagnosticKey, args) {
+        if (TypeScript.LocalizedDiagnosticMessages) {
+        }
+
+        var diagnosticMessageText = TypeScript.LocalizedDiagnosticMessages ? TypeScript.LocalizedDiagnosticMessages[diagnosticKey] : diagnosticKey;
+        TypeScript.Debug.assert(diagnosticMessageText !== undefined && diagnosticMessageText !== null);
+
+        var actualCount = args ? args.length : 0;
+
+        var expectedCount = 1 + getLargestIndex(diagnosticKey);
+
+        if (expectedCount !== actualCount) {
+            throw new Error(getLocalizedText(TypeScript.DiagnosticCode.Expected_0_arguments_to_message_got_1_instead, [expectedCount, actualCount]));
+        }
+
+        var valueCount = 1 + getLargestIndex(diagnosticMessageText);
+        if (valueCount !== expectedCount) {
+            throw new Error(getLocalizedText(TypeScript.DiagnosticCode.Expected_the_message_0_to_have_1_arguments_but_it_had_2, [diagnosticMessageText, expectedCount, valueCount]));
+        }
+
+        diagnosticMessageText = diagnosticMessageText.replace(/{(\d+)}/g, function (match, num) {
+            return typeof args[num] !== 'undefined' ? args[num] : match;
+        });
+
+        diagnosticMessageText = diagnosticMessageText.replace(/{(NL)}/g, function (match) {
+            return TypeScript.newLine();
+        });
+
+        return diagnosticMessageText;
+    }
+    TypeScript.getLocalizedText = getLocalizedText;
+
+    function getDiagnosticMessage(diagnosticKey, args) {
+        var diagnostic = getDiagnosticInfoFromKey(diagnosticKey);
+        var diagnosticMessageText = getLocalizedText(diagnosticKey, args);
+
+        var message;
+        if (diagnostic.category === 1 /* Error */) {
+            message = getLocalizedText(TypeScript.DiagnosticCode.error_TS_0_1, [diagnostic.code, diagnosticMessageText]);
+        } else if (diagnostic.category === 0 /* Warning */) {
+            message = getLocalizedText(TypeScript.DiagnosticCode.warning_TS_0_1, [diagnostic.code, diagnosticMessageText]);
+        } else {
+            message = diagnosticMessageText;
+        }
+
+        return message;
+    }
+    TypeScript.getDiagnosticMessage = getDiagnosticMessage;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var Errors = (function () {
+        function Errors() {
+        }
+        Errors.argument = function (argument, message) {
+            return new Error("Invalid argument: " + argument + ". " + message);
+        };
+
+        Errors.argumentOutOfRange = function (argument) {
+            return new Error("Argument out of range: " + argument);
+        };
+
+        Errors.argumentNull = function (argument) {
+            return new Error("Argument null: " + argument);
+        };
+
+        Errors.abstract = function () {
+            return new Error("Operation not implemented properly by subclass.");
+        };
+
+        Errors.notYetImplemented = function () {
+            return new Error("Not yet implemented.");
+        };
+
+        Errors.invalidOperation = function (message) {
+            return new Error("Invalid operation: " + message);
+        };
+        return Errors;
+    })();
+    TypeScript.Errors = Errors;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var Hash = (function () {
+        function Hash() {
+        }
+        Hash.computeFnv1aCharArrayHashCode = function (text, start, len) {
+            var hashCode = Hash.FNV_BASE;
+            var end = start + len;
+
+            for (var i = start; i < end; i++) {
+                hashCode = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(hashCode ^ text[i], Hash.FNV_PRIME);
+            }
+
+            return hashCode;
+        };
+
+        Hash.computeSimple31BitCharArrayHashCode = function (key, start, len) {
+            var hash = 0;
+
+            for (var i = 0; i < len; i++) {
+                var ch = key[start + i];
+
+                hash = ((((hash << 5) - hash) | 0) + ch) | 0;
+            }
+
+            return hash & 0x7FFFFFFF;
+        };
+
+        Hash.computeSimple31BitStringHashCode = function (key) {
+            var hash = 0;
+
+            var start = 0;
+            var len = key.length;
+
+            for (var i = 0; i < len; i++) {
+                var ch = key.charCodeAt(start + i);
+
+                hash = ((((hash << 5) - hash) | 0) + ch) | 0;
+            }
+
+            return hash & 0x7FFFFFFF;
+        };
+
+        Hash.computeMurmur2StringHashCode = function (key, seed) {
+            var m = 0x5bd1e995;
+            var r = 24;
+
+            var numberOfCharsLeft = key.length;
+            var h = Math.abs(seed ^ numberOfCharsLeft);
+
+            var index = 0;
+            while (numberOfCharsLeft >= 2) {
+                var c1 = key.charCodeAt(index);
+                var c2 = key.charCodeAt(index + 1);
+
+                var k = Math.abs(c1 | (c2 << 16));
+
+                k = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(k, m);
+                k ^= k >> r;
+                k = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(k, m);
+
+                h = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(h, m);
+                h ^= k;
+
+                index += 2;
+                numberOfCharsLeft -= 2;
+            }
+
+            if (numberOfCharsLeft === 1) {
+                h ^= key.charCodeAt(index);
+                h = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(h, m);
+            }
+
+            h ^= h >> 13;
+            h = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(h, m);
+            h ^= h >> 15;
+
+            return h;
+        };
+
+        Hash.getPrime = function (min) {
+            for (var i = 0; i < Hash.primes.length; i++) {
+                var num = Hash.primes[i];
+                if (num >= min) {
+                    return num;
+                }
+            }
+
+            throw TypeScript.Errors.notYetImplemented();
+        };
+
+        Hash.expandPrime = function (oldSize) {
+            var num = oldSize << 1;
+            if (num > 2146435069 && 2146435069 > oldSize) {
+                return 2146435069;
+            }
+            return Hash.getPrime(num);
+        };
+
+        Hash.combine = function (value, currentHash) {
+            return (((currentHash << 5) + currentHash) + value) & 0x7FFFFFFF;
+        };
+        Hash.FNV_BASE = 2166136261;
+        Hash.FNV_PRIME = 16777619;
+
+        Hash.primes = [
+            3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521,
+            631, 761, 919, 1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419,
+            10103, 12143, 14591, 17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431,
+            90523, 108631, 130363, 156437, 187751, 225307, 270371, 324449, 389357, 467237, 560689,
+            672827, 807403, 968897, 1162687, 1395263, 1674319, 2009191, 2411033, 2893249, 3471899,
+            4166287, 4999559, 5999471, 7199369];
+        return Hash;
+    })();
+    TypeScript.Hash = Hash;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (Collections) {
+        Collections.DefaultHashTableCapacity = 1024;
+
+        var HashTableEntry = (function () {
+            function HashTableEntry(Key, Value, HashCode, Next) {
+                this.Key = Key;
+                this.Value = Value;
+                this.HashCode = HashCode;
+                this.Next = Next;
+            }
+            return HashTableEntry;
+        })();
+
+        var HashTable = (function () {
+            function HashTable(capacity, hash) {
+                this.hash = hash;
+                this.count = 0;
+                var size = TypeScript.Hash.getPrime(capacity);
+                this.entries = TypeScript.ArrayUtilities.createArray(size, null);
+            }
+            HashTable.prototype.set = function (key, value) {
+                this.addOrSet(key, value, false);
+            };
+
+            HashTable.prototype.add = function (key, value) {
+                this.addOrSet(key, value, true);
+            };
+
+            HashTable.prototype.containsKey = function (key) {
+                var hashCode = this.computeHashCode(key);
+                var entry = this.findEntry(key, hashCode);
+                return entry !== null;
+            };
+
+            HashTable.prototype.get = function (key) {
+                var hashCode = this.computeHashCode(key);
+                var entry = this.findEntry(key, hashCode);
+
+                return entry === null ? null : entry.Value;
+            };
+
+            HashTable.prototype.computeHashCode = function (key) {
+                var hashCode = this.hash === null ? key.hashCode : this.hash(key);
+
+                hashCode = hashCode & 0x7FFFFFFF;
+                TypeScript.Debug.assert(hashCode >= 0);
+
+                return hashCode;
+            };
+
+            HashTable.prototype.addOrSet = function (key, value, throwOnExistingEntry) {
+                var hashCode = this.computeHashCode(key);
+
+                var entry = this.findEntry(key, hashCode);
+                if (entry !== null) {
+                    if (throwOnExistingEntry) {
+                        throw TypeScript.Errors.argument('key', "Key was already in table.");
+                    }
+
+                    entry.Key = key;
+                    entry.Value = value;
+                    return;
+                }
+
+                return this.addEntry(key, value, hashCode);
+            };
+
+            HashTable.prototype.findEntry = function (key, hashCode) {
+                for (var e = this.entries[hashCode % this.entries.length]; e !== null; e = e.Next) {
+                    if (e.HashCode === hashCode && key === e.Key) {
+                        return e;
+                    }
+                }
+
+                return null;
+            };
+
+            HashTable.prototype.addEntry = function (key, value, hashCode) {
+                var index = hashCode % this.entries.length;
+
+                var e = new HashTableEntry(key, value, hashCode, this.entries[index]);
+
+                this.entries[index] = e;
+
+                if (this.count >= (this.entries.length / 2)) {
+                    this.grow();
+                }
+
+                this.count++;
+                return e.Key;
+            };
+
+            HashTable.prototype.grow = function () {
+                var newSize = TypeScript.Hash.expandPrime(this.entries.length);
+
+                var oldEntries = this.entries;
+                var newEntries = TypeScript.ArrayUtilities.createArray(newSize, null);
+
+                this.entries = newEntries;
+
+                for (var i = 0; i < oldEntries.length; i++) {
+                    var e = oldEntries[i];
+
+                    while (e !== null) {
+                        var newIndex = e.HashCode % newSize;
+                        var tmp = e.Next;
+                        e.Next = newEntries[newIndex];
+                        newEntries[newIndex] = e;
+                        e = tmp;
+                    }
+                }
+            };
+            return HashTable;
+        })();
+        Collections.HashTable = HashTable;
+
+        function createHashTable(capacity, hash) {
+            if (typeof capacity === "undefined") { capacity = Collections.DefaultHashTableCapacity; }
+            if (typeof hash === "undefined") { hash = null; }
+            return new HashTable(capacity, hash);
+        }
+        Collections.createHashTable = createHashTable;
+
+        var currentHashCode = 1;
+        function identityHashCode(value) {
+            if (value.__hash === undefined) {
+                value.__hash = currentHashCode;
+                currentHashCode++;
+            }
+
+            return value.__hash;
+        }
+        Collections.identityHashCode = identityHashCode;
+    })(TypeScript.Collections || (TypeScript.Collections = {}));
+    var Collections = TypeScript.Collections;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    TypeScript.nodeMakeDirectoryTime = 0;
+    TypeScript.nodeCreateBufferTime = 0;
+    TypeScript.nodeWriteFileSyncTime = 0;
+
+    (function (ByteOrderMark) {
+        ByteOrderMark[ByteOrderMark["None"] = 0] = "None";
+        ByteOrderMark[ByteOrderMark["Utf8"] = 1] = "Utf8";
+        ByteOrderMark[ByteOrderMark["Utf16BigEndian"] = 2] = "Utf16BigEndian";
+        ByteOrderMark[ByteOrderMark["Utf16LittleEndian"] = 3] = "Utf16LittleEndian";
+    })(TypeScript.ByteOrderMark || (TypeScript.ByteOrderMark = {}));
+    var ByteOrderMark = TypeScript.ByteOrderMark;
+
+    var FileInformation = (function () {
+        function FileInformation(contents, byteOrderMark) {
+            this.contents = contents;
+            this.byteOrderMark = byteOrderMark;
+        }
+        return FileInformation;
+    })();
+    TypeScript.FileInformation = FileInformation;
+
+    TypeScript.Environment = (function () {
+        function getWindowsScriptHostEnvironment() {
+            try  {
+                var fso = new ActiveXObject("Scripting.FileSystemObject");
+            } catch (e) {
+                return null;
+            }
+
+            var streamObjectPool = [];
+
+            function getStreamObject() {
+                if (streamObjectPool.length > 0) {
+                    return streamObjectPool.pop();
+                } else {
+                    return new ActiveXObject("ADODB.Stream");
+                }
+            }
+
+            function releaseStreamObject(obj) {
+                streamObjectPool.push(obj);
+            }
+
+            var args = [];
+            for (var i = 0; i < WScript.Arguments.length; i++) {
+                args[i] = WScript.Arguments.Item(i);
+            }
+
+            return {
+                newLine: "\r\n",
+                currentDirectory: function () {
+                    return WScript.CreateObject("WScript.Shell").CurrentDirectory;
+                },
+                supportsCodePage: function () {
+                    return WScript.ReadFile;
+                },
+                readFile: function (path, codepage) {
+                    try  {
+                        if (codepage !== null && this.supportsCodePage()) {
+                            try  {
+                                var contents = WScript.ReadFile(path, codepage);
+                                return new FileInformation(contents, 0 /* None */);
+                            } catch (e) {
+                            }
+                        }
+
+                        var streamObj = getStreamObject();
+                        streamObj.Open();
+                        streamObj.Type = 2;
+
+                        streamObj.Charset = 'x-ansi';
+
+                        streamObj.LoadFromFile(path);
+                        var bomChar = streamObj.ReadText(2);
+
+                        streamObj.Position = 0;
+
+                        var byteOrderMark = 0 /* None */;
+
+                        if (bomChar.charCodeAt(0) === 0xFE && bomChar.charCodeAt(1) === 0xFF) {
+                            streamObj.Charset = 'unicode';
+                            byteOrderMark = 2 /* Utf16BigEndian */;
+                        } else if (bomChar.charCodeAt(0) === 0xFF && bomChar.charCodeAt(1) === 0xFE) {
+                            streamObj.Charset = 'unicode';
+                            byteOrderMark = 3 /* Utf16LittleEndian */;
+                        } else if (bomChar.charCodeAt(0) === 0xEF && bomChar.charCodeAt(1) === 0xBB) {
+                            streamObj.Charset = 'utf-8';
+                            byteOrderMark = 1 /* Utf8 */;
+                        } else {
+                            streamObj.Charset = 'utf-8';
+                        }
+
+                        var contents = streamObj.ReadText(-1);
+                        streamObj.Close();
+                        releaseStreamObject(streamObj);
+                        return new FileInformation(contents, byteOrderMark);
+                    } catch (err) {
+                        var message;
+                        if (err.number === -2147024809) {
+                            message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Unsupported_file_encoding, null);
+                        } else {
+                            message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Cannot_read_file_0_1, [path, err.message]);
+                        }
+
+                        throw new Error(message);
+                    }
+                },
+                writeFile: function (path, contents, writeByteOrderMark) {
+                    var textStream = getStreamObject();
+                    textStream.Charset = 'utf-8';
+                    textStream.Open();
+                    textStream.WriteText(contents, 0);
+
+                    if (!writeByteOrderMark) {
+                        textStream.Position = 3;
+                    } else {
+                        textStream.Position = 0;
+                    }
+
+                    var fileStream = getStreamObject();
+                    fileStream.Type = 1;
+                    fileStream.Open();
+
+                    textStream.CopyTo(fileStream);
+
+                    fileStream.Flush();
+                    fileStream.SaveToFile(path, 2);
+                    fileStream.Close();
+
+                    textStream.Flush();
+                    textStream.Close();
+                },
+                fileExists: function (path) {
+                    return fso.FileExists(path);
+                },
+                deleteFile: function (path) {
+                    if (fso.FileExists(path)) {
+                        fso.DeleteFile(path, true);
+                    }
+                },
+                directoryExists: function (path) {
+                    return fso.FolderExists(path);
+                },
+                listFiles: function (path, spec, options) {
+                    options = options || {};
+                    function filesInFolder(folder, root) {
+                        var paths = [];
+                        var fc;
+
+                        if (options.recursive) {
+                            fc = new Enumerator(folder.subfolders);
+
+                            for (; !fc.atEnd(); fc.moveNext()) {
+                                paths = paths.concat(filesInFolder(fc.item(), root + "\\" + fc.item().Name));
+                            }
+                        }
+
+                        fc = new Enumerator(folder.files);
+
+                        for (; !fc.atEnd(); fc.moveNext()) {
+                            if (!spec || fc.item().Name.match(spec)) {
+                                paths.push(root + "\\" + fc.item().Name);
+                            }
+                        }
+
+                        return paths;
+                    }
+
+                    var folder = fso.GetFolder(path);
+                    var paths = [];
+
+                    return filesInFolder(folder, path);
+                },
+                arguments: args,
+                standardOut: WScript.StdOut
+            };
+        }
+        ;
+
+        function getNodeEnvironment() {
+            var _fs = require('fs');
+            var _path = require('path');
+            var _module = require('module');
+            var _os = require('os');
+
+            return {
+                newLine: _os.EOL,
+                currentDirectory: function () {
+                    return process.cwd();
+                },
+                supportsCodePage: function () {
+                    return false;
+                },
+                readFile: function (file, codepage) {
+                    if (codepage !== null) {
+                        throw new Error(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.codepage_option_not_supported_on_current_platform, null));
+                    }
+
+                    var buffer = _fs.readFileSync(file);
+                    switch (buffer[0]) {
+                        case 0xFE:
+                            if (buffer[1] === 0xFF) {
+                                var i = 0;
+                                while ((i + 1) < buffer.length) {
+                                    var temp = buffer[i];
+                                    buffer[i] = buffer[i + 1];
+                                    buffer[i + 1] = temp;
+                                    i += 2;
+                                }
+                                return new FileInformation(buffer.toString("ucs2", 2), 2 /* Utf16BigEndian */);
+                            }
+                            break;
+                        case 0xFF:
+                            if (buffer[1] === 0xFE) {
+                                return new FileInformation(buffer.toString("ucs2", 2), 3 /* Utf16LittleEndian */);
+                            }
+                            break;
+                        case 0xEF:
+                            if (buffer[1] === 0xBB) {
+                                return new FileInformation(buffer.toString("utf8", 3), 1 /* Utf8 */);
+                            }
+                    }
+
+                    return new FileInformation(buffer.toString("utf8", 0), 0 /* None */);
+                },
+                writeFile: function (path, contents, writeByteOrderMark) {
+                    function mkdirRecursiveSync(path) {
+                        var stats = _fs.statSync(path);
+                        if (stats.isFile()) {
+                            throw "\"" + path + "\" exists but isn't a directory.";
+                        } else if (stats.isDirectory()) {
+                            return;
+                        } else {
+                            mkdirRecursiveSync(_path.dirname(path));
+                            _fs.mkdirSync(path, 509);
+                        }
+                    }
+                    var start = new Date().getTime();
+                    mkdirRecursiveSync(_path.dirname(path));
+                    TypeScript.nodeMakeDirectoryTime += new Date().getTime() - start;
+
+                    if (writeByteOrderMark) {
+                        contents = '\uFEFF' + contents;
+                    }
+
+                    var start = new Date().getTime();
+
+                    var chunkLength = 4 * 1024;
+                    var fileDescriptor = _fs.openSync(path, "w");
+                    try  {
+                        for (var index = 0; index < contents.length; index += chunkLength) {
+                            var bufferStart = new Date().getTime();
+                            var buffer = new Buffer(contents.substr(index, chunkLength), "utf8");
+                            TypeScript.nodeCreateBufferTime += new Date().getTime() - bufferStart;
+
+                            _fs.writeSync(fileDescriptor, buffer, 0, buffer.length, null);
+                        }
+                    } finally {
+                        _fs.closeSync(fileDescriptor);
+                    }
+
+                    TypeScript.nodeWriteFileSyncTime += new Date().getTime() - start;
+                },
+                fileExists: function (path) {
+                    return _fs.existsSync(path);
+                },
+                deleteFile: function (path) {
+                    try  {
+                        _fs.unlinkSync(path);
+                    } catch (e) {
+                    }
+                },
+                directoryExists: function (path) {
+                    return _fs.existsSync(path) && _fs.statSync(path).isDirectory();
+                },
+                listFiles: function dir(path, spec, options) {
+                    options = options || {};
+
+                    function filesInFolder(folder) {
+                        var paths = [];
+
+                        var files = _fs.readdirSync(folder);
+                        for (var i = 0; i < files.length; i++) {
+                            var stat = _fs.statSync(folder + "\\" + files[i]);
+                            if (options.recursive && stat.isDirectory()) {
+                                paths = paths.concat(filesInFolder(folder + "\\" + files[i]));
+                            } else if (stat.isFile() && (!spec || files[i].match(spec))) {
+                                paths.push(folder + "\\" + files[i]);
+                            }
+                        }
+
+                        return paths;
+                    }
+
+                    return filesInFolder(path);
+                },
+                arguments: process.argv.slice(2),
+                standardOut: {
+                    Write: function (str) {
+                        process.stdout.write(str);
+                    },
+                    WriteLine: function (str) {
+                        process.stdout.write(str + '\n');
+                    },
+                    Close: function () {
+                    }
+                }
+            };
+        }
+        ;
+
+        if (typeof WScript !== "undefined" && typeof ActiveXObject === "function") {
+            return getWindowsScriptHostEnvironment();
+        } else if (typeof module !== 'undefined' && module.exports) {
+            return getNodeEnvironment();
+        } else {
+            return null;
+        }
+    })();
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (IntegerUtilities) {
+        function integerDivide(numerator, denominator) {
+            return (numerator / denominator) >> 0;
+        }
+        IntegerUtilities.integerDivide = integerDivide;
+
+        function integerMultiplyLow32Bits(n1, n2) {
+            var n1Low16 = n1 & 0x0000ffff;
+            var n1High16 = n1 >>> 16;
+
+            var n2Low16 = n2 & 0x0000ffff;
+            var n2High16 = n2 >>> 16;
+
+            var resultLow32 = (((n1 & 0xffff0000) * n2) >>> 0) + (((n1 & 0x0000ffff) * n2) >>> 0) >>> 0;
+            return resultLow32;
+        }
+        IntegerUtilities.integerMultiplyLow32Bits = integerMultiplyLow32Bits;
+
+        function integerMultiplyHigh32Bits(n1, n2) {
+            var n1Low16 = n1 & 0x0000ffff;
+            var n1High16 = n1 >>> 16;
+
+            var n2Low16 = n2 & 0x0000ffff;
+            var n2High16 = n2 >>> 16;
+
+            var resultHigh32 = n1High16 * n2High16 + ((((n1Low16 * n2Low16) >>> 17) + n1Low16 * n2High16) >>> 15);
+            return resultHigh32;
+        }
+        IntegerUtilities.integerMultiplyHigh32Bits = integerMultiplyHigh32Bits;
+
+        function isInteger(text) {
+            return /^[0-9]+$/.test(text);
+        }
+        IntegerUtilities.isInteger = isInteger;
+
+        function isHexInteger(text) {
+            return /^0(x|X)[0-9a-fA-F]+$/.test(text);
+        }
+        IntegerUtilities.isHexInteger = isHexInteger;
+    })(TypeScript.IntegerUtilities || (TypeScript.IntegerUtilities = {}));
+    var IntegerUtilities = TypeScript.IntegerUtilities;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var LineMap = (function () {
+        function LineMap(_computeLineStarts, length) {
+            this._computeLineStarts = _computeLineStarts;
+            this.length = length;
+            this._lineStarts = null;
+        }
+        LineMap.prototype.toJSON = function (key) {
+            return { lineStarts: this.lineStarts(), length: this.length };
+        };
+
+        LineMap.prototype.equals = function (other) {
+            return this.length === other.length && TypeScript.ArrayUtilities.sequenceEquals(this.lineStarts(), other.lineStarts(), function (v1, v2) {
+                return v1 === v2;
+            });
+        };
+
+        LineMap.prototype.lineStarts = function () {
+            if (this._lineStarts === null) {
+                this._lineStarts = this._computeLineStarts();
+            }
+
+            return this._lineStarts;
+        };
+
+        LineMap.prototype.lineCount = function () {
+            return this.lineStarts().length;
+        };
+
+        LineMap.prototype.getPosition = function (line, character) {
+            return this.lineStarts()[line] + character;
+        };
+
+        LineMap.prototype.getLineNumberFromPosition = function (position) {
+            if (position < 0 || position > this.length) {
+                throw TypeScript.Errors.argumentOutOfRange("position");
+            }
+
+            if (position === this.length) {
+                return this.lineCount() - 1;
+            }
+
+            var lineNumber = TypeScript.ArrayUtilities.binarySearch(this.lineStarts(), position);
+            if (lineNumber < 0) {
+                lineNumber = (~lineNumber) - 1;
+            }
+
+            return lineNumber;
+        };
+
+        LineMap.prototype.getLineStartPosition = function (lineNumber) {
+            return this.lineStarts()[lineNumber];
+        };
+
+        LineMap.prototype.fillLineAndCharacterFromPosition = function (position, lineAndCharacter) {
+            if (position < 0 || position > this.length) {
+                throw TypeScript.Errors.argumentOutOfRange("position");
+            }
+
+            var lineNumber = this.getLineNumberFromPosition(position);
+            lineAndCharacter.line = lineNumber;
+            lineAndCharacter.character = position - this.lineStarts()[lineNumber];
+        };
+
+        LineMap.prototype.getLineAndCharacterFromPosition = function (position) {
+            if (position < 0 || position > this.length) {
+                throw TypeScript.Errors.argumentOutOfRange("position");
+            }
+
+            var lineNumber = this.getLineNumberFromPosition(position);
+
+            return new TypeScript.LineAndCharacter(lineNumber, position - this.lineStarts()[lineNumber]);
+        };
+        LineMap.empty = new LineMap(function () {
+            return [0];
+        }, 0);
+        return LineMap;
+    })();
+    TypeScript.LineMap = LineMap;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var LineAndCharacter = (function () {
+        function LineAndCharacter(line, character) {
+            this._line = 0;
+            this._character = 0;
+            if (line < 0) {
+                throw TypeScript.Errors.argumentOutOfRange("line");
+            }
+
+            if (character < 0) {
+                throw TypeScript.Errors.argumentOutOfRange("character");
+            }
+
+            this._line = line;
+            this._character = character;
+        }
+        LineAndCharacter.prototype.line = function () {
+            return this._line;
+        };
+
+        LineAndCharacter.prototype.character = function () {
+            return this._character;
+        };
+        return LineAndCharacter;
+    })();
+    TypeScript.LineAndCharacter = LineAndCharacter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var MathPrototype = (function () {
+        function MathPrototype() {
+        }
+        MathPrototype.max = function (a, b) {
+            return a >= b ? a : b;
+        };
+
+        MathPrototype.min = function (a, b) {
+            return a <= b ? a : b;
+        };
+        return MathPrototype;
+    })();
+    TypeScript.MathPrototype = MathPrototype;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (Collections) {
+        Collections.DefaultStringTableCapacity = 256;
+
+        var StringTableEntry = (function () {
+            function StringTableEntry(Text, HashCode, Next) {
+                this.Text = Text;
+                this.HashCode = HashCode;
+                this.Next = Next;
+            }
+            return StringTableEntry;
+        })();
+
+        var StringTable = (function () {
+            function StringTable(capacity) {
+                this.count = 0;
+                var size = TypeScript.Hash.getPrime(capacity);
+                this.entries = TypeScript.ArrayUtilities.createArray(size, null);
+            }
+            StringTable.prototype.addCharArray = function (key, start, len) {
+                var hashCode = TypeScript.Hash.computeSimple31BitCharArrayHashCode(key, start, len) & 0x7FFFFFFF;
+
+                var entry = this.findCharArrayEntry(key, start, len, hashCode);
+                if (entry !== null) {
+                    return entry.Text;
+                }
+
+                var slice = key.slice(start, start + len);
+                return this.addEntry(TypeScript.StringUtilities.fromCharCodeArray(slice), hashCode);
+            };
+
+            StringTable.prototype.findCharArrayEntry = function (key, start, len, hashCode) {
+                for (var e = this.entries[hashCode % this.entries.length]; e !== null; e = e.Next) {
+                    if (e.HashCode === hashCode && StringTable.textCharArrayEquals(e.Text, key, start, len)) {
+                        return e;
+                    }
+                }
+
+                return null;
+            };
+
+            StringTable.prototype.addEntry = function (text, hashCode) {
+                var index = hashCode % this.entries.length;
+
+                var e = new StringTableEntry(text, hashCode, this.entries[index]);
+
+                this.entries[index] = e;
+
+                if (this.count === this.entries.length) {
+                    this.grow();
+                }
+
+                this.count++;
+                return e.Text;
+            };
+
+            StringTable.prototype.grow = function () {
+                var newSize = TypeScript.Hash.expandPrime(this.entries.length);
+
+                var oldEntries = this.entries;
+                var newEntries = TypeScript.ArrayUtilities.createArray(newSize, null);
+
+                this.entries = newEntries;
+
+                for (var i = 0; i < oldEntries.length; i++) {
+                    var e = oldEntries[i];
+                    while (e !== null) {
+                        var newIndex = e.HashCode % newSize;
+                        var tmp = e.Next;
+                        e.Next = newEntries[newIndex];
+                        newEntries[newIndex] = e;
+                        e = tmp;
+                    }
+                }
+            };
+
+            StringTable.textCharArrayEquals = function (text, array, start, length) {
+                if (text.length !== length) {
+                    return false;
+                }
+
+                var s = start;
+                for (var i = 0; i < length; i++) {
+                    if (text.charCodeAt(i) !== array[s]) {
+                        return false;
+                    }
+
+                    s++;
+                }
+
+                return true;
+            };
+            return StringTable;
+        })();
+        Collections.StringTable = StringTable;
+
+        Collections.DefaultStringTable = new StringTable(Collections.DefaultStringTableCapacity);
+    })(TypeScript.Collections || (TypeScript.Collections = {}));
+    var Collections = TypeScript.Collections;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var StringUtilities = (function () {
+        function StringUtilities() {
+        }
+        StringUtilities.isString = function (value) {
+            return Object.prototype.toString.apply(value, []) === '[object String]';
+        };
+
+        StringUtilities.fromCharCodeArray = function (array) {
+            return String.fromCharCode.apply(null, array);
+        };
+
+        StringUtilities.endsWith = function (string, value) {
+            return string.substring(string.length - value.length, string.length) === value;
+        };
+
+        StringUtilities.startsWith = function (string, value) {
+            return string.substr(0, value.length) === value;
+        };
+
+        StringUtilities.copyTo = function (source, sourceIndex, destination, destinationIndex, count) {
+            for (var i = 0; i < count; i++) {
+                destination[destinationIndex + i] = source.charCodeAt(sourceIndex + i);
+            }
+        };
+
+        StringUtilities.repeat = function (value, count) {
+            return Array(count + 1).join(value);
+        };
+
+        StringUtilities.stringEquals = function (val1, val2) {
+            return val1 === val2;
+        };
+        return StringUtilities;
+    })();
+    TypeScript.StringUtilities = StringUtilities;
+})(TypeScript || (TypeScript = {}));
+var global = Function("return this").call(null);
+
+var TypeScript;
+(function (TypeScript) {
+    var Clock;
+    (function (Clock) {
+        Clock.now;
+        Clock.resolution;
+
+        if (typeof WScript !== "undefined" && typeof global['WScript'].InitializeProjection !== "undefined") {
+            global['WScript'].InitializeProjection();
+
+            Clock.now = function () {
+                return TestUtilities.QueryPerformanceCounter();
+            };
+
+            Clock.resolution = TestUtilities.QueryPerformanceFrequency();
+        } else {
+            Clock.now = function () {
+                return Date.now();
+            };
+
+            Clock.resolution = 1000;
+        }
+    })(Clock || (Clock = {}));
+
+    var Timer = (function () {
+        function Timer() {
+            this.time = 0;
+        }
+        Timer.prototype.start = function () {
+            this.time = 0;
+            this.startTime = Clock.now();
+        };
+
+        Timer.prototype.end = function () {
+            this.time = (Clock.now() - this.startTime);
+        };
+        return Timer;
+    })();
+    TypeScript.Timer = Timer;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (DiagnosticCategory) {
+        DiagnosticCategory[DiagnosticCategory["Warning"] = 0] = "Warning";
+        DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error";
+        DiagnosticCategory[DiagnosticCategory["Message"] = 2] = "Message";
+        DiagnosticCategory[DiagnosticCategory["NoPrefix"] = 3] = "NoPrefix";
+    })(TypeScript.DiagnosticCategory || (TypeScript.DiagnosticCategory = {}));
+    var DiagnosticCategory = TypeScript.DiagnosticCategory;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    TypeScript.diagnosticInformationMap = {
+        "error TS{0}: {1}": {
+            "code": 0,
+            "category": 3 /* NoPrefix */
+        },
+        "warning TS{0}: {1}": {
+            "code": 1,
+            "category": 3 /* NoPrefix */
+        },
+        "Unrecognized escape sequence.": {
+            "code": 1000,
+            "category": 1 /* Error */
+        },
+        "Unexpected character {0}.": {
+            "code": 1001,
+            "category": 1 /* Error */
+        },
+        "Missing close quote character.": {
+            "code": 1002,
+            "category": 1 /* Error */
+        },
+        "Identifier expected.": {
+            "code": 1003,
+            "category": 1 /* Error */
+        },
+        "'{0}' keyword expected.": {
+            "code": 1004,
+            "category": 1 /* Error */
+        },
+        "'{0}' expected.": {
+            "code": 1005,
+            "category": 1 /* Error */
+        },
+        "Identifier expected; '{0}' is a keyword.": {
+            "code": 1006,
+            "category": 1 /* Error */
+        },
+        "Automatic semicolon insertion not allowed.": {
+            "code": 1007,
+            "category": 1 /* Error */
+        },
+        "Unexpected token; '{0}' expected.": {
+            "code": 1008,
+            "category": 1 /* Error */
+        },
+        "Trailing separator not allowed.": {
+            "code": 1009,
+            "category": 1 /* Error */
+        },
+        "'*/' expected.": {
+            "code": 1010,
+            "category": 1 /* Error */
+        },
+        "'public' or 'private' modifier must precede 'static'.": {
+            "code": 1011,
+            "category": 1 /* Error */
+        },
+        "Unexpected token.": {
+            "code": 1012,
+            "category": 1 /* Error */
+        },
+        "Catch clause parameter cannot have a type annotation.": {
+            "code": 1013,
+            "category": 1 /* Error */
+        },
+        "Rest parameter must be last in list.": {
+            "code": 1014,
+            "category": 1 /* Error */
+        },
+        "Parameter cannot have question mark and initializer.": {
+            "code": 1015,
+            "category": 1 /* Error */
+        },
+        "Required parameter cannot follow optional parameter.": {
+            "code": 1016,
+            "category": 1 /* Error */
+        },
+        "Index signatures cannot have rest parameters.": {
+            "code": 1017,
+            "category": 1 /* Error */
+        },
+        "Index signature parameter cannot have accessibility modifiers.": {
+            "code": 1018,
+            "category": 1 /* Error */
+        },
+        "Index signature parameter cannot have a question mark.": {
+            "code": 1019,
+            "category": 1 /* Error */
+        },
+        "Index signature parameter cannot have an initializer.": {
+            "code": 1020,
+            "category": 1 /* Error */
+        },
+        "Index signature must have a type annotation.": {
+            "code": 1021,
+            "category": 1 /* Error */
+        },
+        "Index signature parameter must have a type annotation.": {
+            "code": 1022,
+            "category": 1 /* Error */
+        },
+        "Index signature parameter type must be 'string' or 'number'.": {
+            "code": 1023,
+            "category": 1 /* Error */
+        },
+        "'extends' clause already seen.": {
+            "code": 1024,
+            "category": 1 /* Error */
+        },
+        "'extends' clause must precede 'implements' clause.": {
+            "code": 1025,
+            "category": 1 /* Error */
+        },
+        "Classes can only extend a single class.": {
+            "code": 1026,
+            "category": 1 /* Error */
+        },
+        "'implements' clause already seen.": {
+            "code": 1027,
+            "category": 1 /* Error */
+        },
+        "Accessibility modifier already seen.": {
+            "code": 1028,
+            "category": 1 /* Error */
+        },
+        "'{0}' modifier must precede '{1}' modifier.": {
+            "code": 1029,
+            "category": 1 /* Error */
+        },
+        "'{0}' modifier already seen.": {
+            "code": 1030,
+            "category": 1 /* Error */
+        },
+        "'{0}' modifier cannot appear on a class element.": {
+            "code": 1031,
+            "category": 1 /* Error */
+        },
+        "Interface declaration cannot have 'implements' clause.": {
+            "code": 1032,
+            "category": 1 /* Error */
+        },
+        "'super' invocation cannot have type arguments.": {
+            "code": 1034,
+            "category": 1 /* Error */
+        },
+        "Only ambient modules can use quoted names.": {
+            "code": 1035,
+            "category": 1 /* Error */
+        },
+        "Statements are not allowed in ambient contexts.": {
+            "code": 1036,
+            "category": 1 /* Error */
+        },
+        "Implementations are not allowed in ambient contexts.": {
+            "code": 1037,
+            "category": 1 /* Error */
+        },
+        "'declare' modifier not allowed for code already in an ambient context.": {
+            "code": 1038,
+            "category": 1 /* Error */
+        },
+        "Initializers are not allowed in ambient contexts.": {
+            "code": 1039,
+            "category": 1 /* Error */
+        },
+        "Parameter property declarations can only be used in a non-ambient constructor declaration.": {
+            "code": 1040,
+            "category": 1 /* Error */
+        },
+        "Function implementation expected.": {
+            "code": 1041,
+            "category": 1 /* Error */
+        },
+        "Constructor implementation expected.": {
+            "code": 1042,
+            "category": 1 /* Error */
+        },
+        "Function overload name must be '{0}'.": {
+            "code": 1043,
+            "category": 1 /* Error */
+        },
+        "'{0}' modifier cannot appear on a module element.": {
+            "code": 1044,
+            "category": 1 /* Error */
+        },
+        "'declare' modifier cannot appear on an interface declaration.": {
+            "code": 1045,
+            "category": 1 /* Error */
+        },
+        "'declare' modifier required for top level element.": {
+            "code": 1046,
+            "category": 1 /* Error */
+        },
+        "Rest parameter cannot be optional.": {
+            "code": 1047,
+            "category": 1 /* Error */
+        },
+        "Rest parameter cannot have an initializer.": {
+            "code": 1048,
+            "category": 1 /* Error */
+        },
+        "'set' accessor must have one and only one parameter.": {
+            "code": 1049,
+            "category": 1 /* Error */
+        },
+        "'set' accessor parameter cannot be optional.": {
+            "code": 1051,
+            "category": 1 /* Error */
+        },
+        "'set' accessor parameter cannot have an initializer.": {
+            "code": 1052,
+            "category": 1 /* Error */
+        },
+        "'set' accessor cannot have rest parameter.": {
+            "code": 1053,
+            "category": 1 /* Error */
+        },
+        "'get' accessor cannot have parameters.": {
+            "code": 1054,
+            "category": 1 /* Error */
+        },
+        "Modifiers cannot appear here.": {
+            "code": 1055,
+            "category": 1 /* Error */
+        },
+        "Accessors are only available when targeting ECMAScript 5 and higher.": {
+            "code": 1056,
+            "category": 1 /* Error */
+        },
+        "Class name cannot be '{0}'.": {
+            "code": 1057,
+            "category": 1 /* Error */
+        },
+        "Interface name cannot be '{0}'.": {
+            "code": 1058,
+            "category": 1 /* Error */
+        },
+        "Enum name cannot be '{0}'.": {
+            "code": 1059,
+            "category": 1 /* Error */
+        },
+        "Module name cannot be '{0}'.": {
+            "code": 1060,
+            "category": 1 /* Error */
+        },
+        "Enum member must have initializer.": {
+            "code": 1061,
+            "category": 1 /* Error */
+        },
+        "Export assignment cannot be used in internal modules.": {
+            "code": 1063,
+            "category": 1 /* Error */
+        },
+        "Export assignment not allowed in module with exported element.": {
+            "code": 1064,
+            "category": 1 /* Error */
+        },
+        "Module cannot have multiple export assignments.": {
+            "code": 1065,
+            "category": 1 /* Error */
+        },
+        "Ambient enum elements can only have integer literal initializers.": {
+            "code": 1066,
+            "category": 1 /* Error */
+        },
+        "module, class, interface, enum, import or statement": {
+            "code": 1067,
+            "category": 3 /* NoPrefix */
+        },
+        "constructor, function, accessor or variable": {
+            "code": 1068,
+            "category": 3 /* NoPrefix */
+        },
+        "statement": {
+            "code": 1069,
+            "category": 3 /* NoPrefix */
+        },
+        "case or default clause": {
+            "code": 1070,
+            "category": 3 /* NoPrefix */
+        },
+        "identifier": {
+            "code": 1071,
+            "category": 3 /* NoPrefix */
+        },
+        "call, construct, index, property or function signature": {
+            "code": 1072,
+            "category": 3 /* NoPrefix */
+        },
+        "expression": {
+            "code": 1073,
+            "category": 3 /* NoPrefix */
+        },
+        "type name": {
+            "code": 1074,
+            "category": 3 /* NoPrefix */
+        },
+        "property or accessor": {
+            "code": 1075,
+            "category": 3 /* NoPrefix */
+        },
+        "parameter": {
+            "code": 1076,
+            "category": 3 /* NoPrefix */
+        },
+        "type": {
+            "code": 1077,
+            "category": 3 /* NoPrefix */
+        },
+        "type parameter": {
+            "code": 1078,
+            "category": 3 /* NoPrefix */
+        },
+        "'declare' modifier not allowed on import declaration.": {
+            "code": 1079,
+            "category": 1 /* Error */
+        },
+        "Function overload must be static.": {
+            "code": 1080,
+            "category": 1 /* Error */
+        },
+        "Function overload must not be static.": {
+            "code": 1081,
+            "category": 1 /* Error */
+        },
+        "Parameter property declarations cannot be used in a constructor overload.": {
+            "code": 1083,
+            "category": 1 /* Error */
+        },
+        "Invalid 'reference' directive syntax.": {
+            "code": 1084,
+            "category": 1 /* Error */
+        },
+        "Octal literals are not available when targeting ECMAScript 5 and higher.": {
+            "code": 1085,
+            "category": 1 /* Error */
+        },
+        "Accessors are not allowed in ambient contexts.": {
+            "code": 1086,
+            "category": 1 /* Error */
+        },
+        "'{0}' modifier cannot appear on a constructor declaration.": {
+            "code": 1089,
+            "category": 1 /* Error */
+        },
+        "'{0}' modifier cannot appear on a parameter.": {
+            "code": 1090,
+            "category": 1 /* Error */
+        },
+        "Only a single variable declaration is allowed in a 'for...in' statement.": {
+            "code": 1091,
+            "category": 1 /* Error */
+        },
+        "Type parameters cannot appear on a constructor declaration.": {
+            "code": 1091,
+            "category": 1 /* Error */
+        },
+        "Type annotation cannot appear on a constructor declaration.": {
+            "code": 1092,
+            "category": 1 /* Error */
+        },
+        "Duplicate identifier '{0}'.": {
+            "code": 2000,
+            "category": 1 /* Error */
+        },
+        "The name '{0}' does not exist in the current scope.": {
+            "code": 2001,
+            "category": 1 /* Error */
+        },
+        "The name '{0}' does not refer to a value.": {
+            "code": 2002,
+            "category": 1 /* Error */
+        },
+        "'super' can only be used inside a class instance method.": {
+            "code": 2003,
+            "category": 1 /* Error */
+        },
+        "The left-hand side of an assignment expression must be a variable, property or indexer.": {
+            "code": 2004,
+            "category": 1 /* Error */
+        },
+        "Value of type '{0}' is not callable. Did you mean to include 'new'?": {
+            "code": 2161,
+            "category": 1 /* Error */
+        },
+        "Value of type '{0}' is not callable.": {
+            "code": 2006,
+            "category": 1 /* Error */
+        },
+        "Value of type '{0}' is not newable.": {
+            "code": 2007,
+            "category": 1 /* Error */
+        },
+        "Value of type '{0}' is not indexable by type '{1}'.": {
+            "code": 2008,
+            "category": 1 /* Error */
+        },
+        "Operator '{0}' cannot be applied to types '{1}' and '{2}'.": {
+            "code": 2009,
+            "category": 1 /* Error */
+        },
+        "Operator '{0}' cannot be applied to types '{1}' and '{2}': {3}": {
+            "code": 2010,
+            "category": 1 /* Error */
+        },
+        "Cannot convert '{0}' to '{1}'.": {
+            "code": 2011,
+            "category": 1 /* Error */
+        },
+        "Cannot convert '{0}' to '{1}':{NL}{2}": {
+            "code": 2012,
+            "category": 1 /* Error */
+        },
+        "Expected var, class, interface, or module.": {
+            "code": 2013,
+            "category": 1 /* Error */
+        },
+        "Operator '{0}' cannot be applied to type '{1}'.": {
+            "code": 2014,
+            "category": 1 /* Error */
+        },
+        "Getter '{0}' already declared.": {
+            "code": 2015,
+            "category": 1 /* Error */
+        },
+        "Setter '{0}' already declared.": {
+            "code": 2016,
+            "category": 1 /* Error */
+        },
+        "Exported class '{0}' extends private class '{1}'.": {
+            "code": 2018,
+            "category": 1 /* Error */
+        },
+        "Exported class '{0}' implements private interface '{1}'.": {
+            "code": 2019,
+            "category": 1 /* Error */
+        },
+        "Exported interface '{0}' extends private interface '{1}'.": {
+            "code": 2020,
+            "category": 1 /* Error */
+        },
+        "Exported class '{0}' extends class from inaccessible module {1}.": {
+            "code": 2021,
+            "category": 1 /* Error */
+        },
+        "Exported class '{0}' implements interface from inaccessible module {1}.": {
+            "code": 2022,
+            "category": 1 /* Error */
+        },
+        "Exported interface '{0}' extends interface from inaccessible module {1}.": {
+            "code": 2023,
+            "category": 1 /* Error */
+        },
+        "Public static property '{0}' of exported class has or is using private type '{1}'.": {
+            "code": 2024,
+            "category": 1 /* Error */
+        },
+        "Public property '{0}' of exported class has or is using private type '{1}'.": {
+            "code": 2025,
+            "category": 1 /* Error */
+        },
+        "Property '{0}' of exported interface has or is using private type '{1}'.": {
+            "code": 2026,
+            "category": 1 /* Error */
+        },
+        "Exported variable '{0}' has or is using private type '{1}'.": {
+            "code": 2027,
+            "category": 1 /* Error */
+        },
+        "Public static property '{0}' of exported class is using inaccessible module {1}.": {
+            "code": 2028,
+            "category": 1 /* Error */
+        },
+        "Public property '{0}' of exported class is using inaccessible module {1}.": {
+            "code": 2029,
+            "category": 1 /* Error */
+        },
+        "Property '{0}' of exported interface is using inaccessible module {1}.": {
+            "code": 2030,
+            "category": 1 /* Error */
+        },
+        "Exported variable '{0}' is using inaccessible module {1}.": {
+            "code": 2031,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of constructor from exported class has or is using private type '{1}'.": {
+            "code": 2032,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public static property setter from exported class has or is using private type '{1}'.": {
+            "code": 2033,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public property setter from exported class has or is using private type '{1}'.": {
+            "code": 2034,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.": {
+            "code": 2035,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of call signature from exported interface has or is using private type '{1}'.": {
+            "code": 2036,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public static method from exported class has or is using private type '{1}'.": {
+            "code": 2037,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public method from exported class has or is using private type '{1}'.": {
+            "code": 2038,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of method from exported interface has or is using private type '{1}'.": {
+            "code": 2039,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of exported function has or is using private type '{1}'.": {
+            "code": 2040,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of constructor from exported class is using inaccessible module {1}.": {
+            "code": 2041,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public static property setter from exported class is using inaccessible module {1}.": {
+            "code": 2042,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public property setter from exported class is using inaccessible module {1}.": {
+            "code": 2043,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.": {
+            "code": 2044,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of call signature from exported interface is using inaccessible module {1}": {
+            "code": 2045,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public static method from exported class is using inaccessible module {1}.": {
+            "code": 2046,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of public method from exported class is using inaccessible module {1}.": {
+            "code": 2047,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of method from exported interface is using inaccessible module {1}.": {
+            "code": 2048,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of exported function is using inaccessible module {1}.": {
+            "code": 2049,
+            "category": 1 /* Error */
+        },
+        "Return type of public static property getter from exported class has or is using private type '{0}'.": {
+            "code": 2050,
+            "category": 1 /* Error */
+        },
+        "Return type of public property getter from exported class has or is using private type '{0}'.": {
+            "code": 2051,
+            "category": 1 /* Error */
+        },
+        "Return type of constructor signature from exported interface has or is using private type '{0}'.": {
+            "code": 2052,
+            "category": 1 /* Error */
+        },
+        "Return type of call signature from exported interface has or is using private type '{0}'.": {
+            "code": 2053,
+            "category": 1 /* Error */
+        },
+        "Return type of index signature from exported interface has or is using private type '{0}'.": {
+            "code": 2054,
+            "category": 1 /* Error */
+        },
+        "Return type of public static method from exported class has or is using private type '{0}'.": {
+            "code": 2055,
+            "category": 1 /* Error */
+        },
+        "Return type of public method from exported class has or is using private type '{0}'.": {
+            "code": 2056,
+            "category": 1 /* Error */
+        },
+        "Return type of method from exported interface has or is using private type '{0}'.": {
+            "code": 2057,
+            "category": 1 /* Error */
+        },
+        "Return type of exported function has or is using private type '{0}'.": {
+            "code": 2058,
+            "category": 1 /* Error */
+        },
+        "Return type of public static property getter from exported class is using inaccessible module {0}.": {
+            "code": 2059,
+            "category": 1 /* Error */
+        },
+        "Return type of public property getter from exported class is using inaccessible module {0}.": {
+            "code": 2060,
+            "category": 1 /* Error */
+        },
+        "Return type of constructor signature from exported interface is using inaccessible module {0}.": {
+            "code": 2061,
+            "category": 1 /* Error */
+        },
+        "Return type of call signature from exported interface is using inaccessible module {0}.": {
+            "code": 2062,
+            "category": 1 /* Error */
+        },
+        "Return type of index signature from exported interface is using inaccessible module {0}.": {
+            "code": 2063,
+            "category": 1 /* Error */
+        },
+        "Return type of public static method from exported class is using inaccessible module {0}.": {
+            "code": 2064,
+            "category": 1 /* Error */
+        },
+        "Return type of public method from exported class is using inaccessible module {0}.": {
+            "code": 2065,
+            "category": 1 /* Error */
+        },
+        "Return type of method from exported interface is using inaccessible module {0}.": {
+            "code": 2066,
+            "category": 1 /* Error */
+        },
+        "Return type of exported function is using inaccessible module {0}.": {
+            "code": 2067,
+            "category": 1 /* Error */
+        },
+        "'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.": {
+            "code": 2068,
+            "category": 1 /* Error */
+        },
+        "A parameter list must follow a generic type argument list. '(' expected.": {
+            "code": 2069,
+            "category": 1 /* Error */
+        },
+        "Multiple constructor implementations are not allowed.": {
+            "code": 2070,
+            "category": 1 /* Error */
+        },
+        "Unable to resolve external module '{0}'.": {
+            "code": 2071,
+            "category": 1 /* Error */
+        },
+        "Module cannot be aliased to a non-module type.": {
+            "code": 2072,
+            "category": 1 /* Error */
+        },
+        "A class may only extend another class.": {
+            "code": 2073,
+            "category": 1 /* Error */
+        },
+        "A class may only implement another class or interface.": {
+            "code": 2074,
+            "category": 1 /* Error */
+        },
+        "An interface may only extend another class or interface.": {
+            "code": 2075,
+            "category": 1 /* Error */
+        },
+        "Unable to resolve type.": {
+            "code": 2077,
+            "category": 1 /* Error */
+        },
+        "Unable to resolve type of '{0}'.": {
+            "code": 2078,
+            "category": 1 /* Error */
+        },
+        "Unable to resolve type parameter constraint.": {
+            "code": 2079,
+            "category": 1 /* Error */
+        },
+        "Type parameter constraint cannot be a primitive type.": {
+            "code": 2080,
+            "category": 1 /* Error */
+        },
+        "Supplied parameters do not match any signature of call target.": {
+            "code": 2081,
+            "category": 1 /* Error */
+        },
+        "Supplied parameters do not match any signature of call target:{NL}{0}": {
+            "code": 2082,
+            "category": 1 /* Error */
+        },
+        "Invalid 'new' expression.": {
+            "code": 2083,
+            "category": 1 /* Error */
+        },
+        "Call signatures used in a 'new' expression must have a 'void' return type.": {
+            "code": 2084,
+            "category": 1 /* Error */
+        },
+        "Could not select overload for 'new' expression.": {
+            "code": 2085,
+            "category": 1 /* Error */
+        },
+        "Type '{0}' does not satisfy the constraint '{1}' for type parameter '{2}'.": {
+            "code": 2086,
+            "category": 1 /* Error */
+        },
+        "Could not select overload for 'call' expression.": {
+            "code": 2087,
+            "category": 1 /* Error */
+        },
+        "Cannot invoke an expression whose type lacks a call signature.": {
+            "code": 2088,
+            "category": 1 /* Error */
+        },
+        "Calls to 'super' are only valid inside a class.": {
+            "code": 2089,
+            "category": 1 /* Error */
+        },
+        "Generic type '{0}' requires {1} type argument(s).": {
+            "code": 2090,
+            "category": 1 /* Error */
+        },
+        "Type of array literal cannot be determined. Best common type could not be found for array elements.": {
+            "code": 2092,
+            "category": 1 /* Error */
+        },
+        "Could not find enclosing symbol for dotted name '{0}'.": {
+            "code": 2093,
+            "category": 1 /* Error */
+        },
+        "The property '{0}' does not exist on value of type '{1}'.": {
+            "code": 2094,
+            "category": 1 /* Error */
+        },
+        "Could not find symbol '{0}'.": {
+            "code": 2095,
+            "category": 1 /* Error */
+        },
+        "'get' and 'set' accessor must have the same type.": {
+            "code": 2096,
+            "category": 1 /* Error */
+        },
+        "'this' cannot be referenced in current location.": {
+            "code": 2097,
+            "category": 1 /* Error */
+        },
+        "Static members cannot reference class type parameters.": {
+            "code": 2099,
+            "category": 1 /* Error */
+        },
+        "Class '{0}' is recursively referenced as a base type of itself.": {
+            "code": 2100,
+            "category": 1 /* Error */
+        },
+        "Interface '{0}' is recursively referenced as a base type of itself.": {
+            "code": 2101,
+            "category": 1 /* Error */
+        },
+        "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.": {
+            "code": 2102,
+            "category": 1 /* Error */
+        },
+        "'super' cannot be referenced in non-derived classes.": {
+            "code": 2103,
+            "category": 1 /* Error */
+        },
+        "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties.": {
+            "code": 2104,
+            "category": 1 /* Error */
+        },
+        "Constructors for derived classes must contain a 'super' call.": {
+            "code": 2105,
+            "category": 1 /* Error */
+        },
+        "Super calls are not permitted outside constructors or in nested functions inside constructors.": {
+            "code": 2106,
+            "category": 1 /* Error */
+        },
+        "'{0}.{1}' is inaccessible.": {
+            "code": 2107,
+            "category": 1 /* Error */
+        },
+        "'this' cannot be referenced within module bodies.": {
+            "code": 2108,
+            "category": 1 /* Error */
+        },
+        "Invalid '+' expression - types not known to support the addition operator.": {
+            "code": 2111,
+            "category": 1 /* Error */
+        },
+        "The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.": {
+            "code": 2112,
+            "category": 1 /* Error */
+        },
+        "The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.": {
+            "code": 2113,
+            "category": 1 /* Error */
+        },
+        "The type of a unary arithmetic operation operand must be of type 'any', 'number' or an enum type.": {
+            "code": 2114,
+            "category": 1 /* Error */
+        },
+        "Variable declarations of a 'for' statement cannot use a type annotation.": {
+            "code": 2115,
+            "category": 1 /* Error */
+        },
+        "Variable declarations of a 'for' statement must be of types 'string' or 'any'.": {
+            "code": 2116,
+            "category": 1 /* Error */
+        },
+        "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter.": {
+            "code": 2117,
+            "category": 1 /* Error */
+        },
+        "The left-hand side of an 'in' expression must be of types 'any', 'string' or 'number'.": {
+            "code": 2118,
+            "category": 1 /* Error */
+        },
+        "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter.": {
+            "code": 2119,
+            "category": 1 /* Error */
+        },
+        "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.": {
+            "code": 2120,
+            "category": 1 /* Error */
+        },
+        "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type.": {
+            "code": 2121,
+            "category": 1 /* Error */
+        },
+        "Setters cannot return a value.": {
+            "code": 2122,
+            "category": 1 /* Error */
+        },
+        "Tried to query type of uninitialized module '{0}'.": {
+            "code": 2123,
+            "category": 1 /* Error */
+        },
+        "Tried to set variable type to uninitialized module type '{0}'.": {
+            "code": 2124,
+            "category": 1 /* Error */
+        },
+        "Type '{0}' does not have type parameters.": {
+            "code": 2125,
+            "category": 1 /* Error */
+        },
+        "Getters must return a value.": {
+            "code": 2126,
+            "category": 1 /* Error */
+        },
+        "Getter and setter accessors do not agree in visibility.": {
+            "code": 2127,
+            "category": 1 /* Error */
+        },
+        "Invalid left-hand side of assignment expression.": {
+            "code": 2130,
+            "category": 1 /* Error */
+        },
+        "Function declared a non-void return type, but has no return expression.": {
+            "code": 2131,
+            "category": 1 /* Error */
+        },
+        "Cannot resolve return type reference.": {
+            "code": 2132,
+            "category": 1 /* Error */
+        },
+        "Constructors cannot have a return type of 'void'.": {
+            "code": 2133,
+            "category": 1 /* Error */
+        },
+        "Subsequent variable declarations must have the same type.  Variable '{0}' must be of type '{1}', but here has type '{2}'.": {
+            "code": 2134,
+            "category": 1 /* Error */
+        },
+        "All symbols within a with block will be resolved to 'any'.": {
+            "code": 2135,
+            "category": 1 /* Error */
+        },
+        "Import declarations in an internal module cannot reference an external module.": {
+            "code": 2136,
+            "category": 1 /* Error */
+        },
+        "Class {0} declares interface {1} but does not implement it:{NL}{2}": {
+            "code": 2137,
+            "category": 1 /* Error */
+        },
+        "Class {0} declares class {1} as an interface but does not implement it:{NL}{2}": {
+            "code": 2138,
+            "category": 1 /* Error */
+        },
+        "The operand of an increment or decrement operator must be a variable, property or indexer.": {
+            "code": 2139,
+            "category": 1 /* Error */
+        },
+        "'this' cannot be referenced in static initializers in a class body.": {
+            "code": 2140,
+            "category": 1 /* Error */
+        },
+        "Class '{0}' cannot extend class '{1}':{NL}{2}": {
+            "code": 2141,
+            "category": 1 /* Error */
+        },
+        "Interface '{0}' cannot extend class '{1}':{NL}{2}": {
+            "code": 2142,
+            "category": 1 /* Error */
+        },
+        "Interface '{0}' cannot extend interface '{1}':{NL}{2}": {
+            "code": 2143,
+            "category": 1 /* Error */
+        },
+        "Duplicate overload signature for '{0}'.": {
+            "code": 2144,
+            "category": 1 /* Error */
+        },
+        "Duplicate constructor overload signature.": {
+            "code": 2145,
+            "category": 1 /* Error */
+        },
+        "Duplicate overload call signature.": {
+            "code": 2146,
+            "category": 1 /* Error */
+        },
+        "Duplicate overload construct signature.": {
+            "code": 2147,
+            "category": 1 /* Error */
+        },
+        "Overload signature is not compatible with function definition.": {
+            "code": 2148,
+            "category": 1 /* Error */
+        },
+        "Overload signature is not compatible with function definition:{NL}{0}": {
+            "code": 2149,
+            "category": 1 /* Error */
+        },
+        "Overload signatures must all be public or private.": {
+            "code": 2150,
+            "category": 1 /* Error */
+        },
+        "Overload signatures must all be exported or not exported.": {
+            "code": 2151,
+            "category": 1 /* Error */
+        },
+        "Overload signatures must all be ambient or non-ambient.": {
+            "code": 2152,
+            "category": 1 /* Error */
+        },
+        "Overload signatures must all be optional or required.": {
+            "code": 2153,
+            "category": 1 /* Error */
+        },
+        "Specialized overload signature is not assignable to any non-specialized signature.": {
+            "code": 2154,
+            "category": 1 /* Error */
+        },
+        "'this' cannot be referenced in constructor arguments.": {
+            "code": 2155,
+            "category": 1 /* Error */
+        },
+        "Instance member cannot be accessed off a class.": {
+            "code": 2157,
+            "category": 1 /* Error */
+        },
+        "Untyped function calls may not accept type arguments.": {
+            "code": 2158,
+            "category": 1 /* Error */
+        },
+        "Non-generic functions may not accept type arguments.": {
+            "code": 2159,
+            "category": 1 /* Error */
+        },
+        "A generic type may not reference itself with a wrapped form of its own type parameters.": {
+            "code": 2160,
+            "category": 1 /* Error */
+        },
+        "Rest parameters must be array types.": {
+            "code": 2162,
+            "category": 1 /* Error */
+        },
+        "Overload signature implementation cannot use specialized type.": {
+            "code": 2163,
+            "category": 1 /* Error */
+        },
+        "Export assignments may only be used at the top-level of external modules.": {
+            "code": 2164,
+            "category": 1 /* Error */
+        },
+        "Export assignments may only be made with variables, functions, classes, interfaces, enums and internal modules.": {
+            "code": 2165,
+            "category": 1 /* Error */
+        },
+        "Only public methods of the base class are accessible via the 'super' keyword.": {
+            "code": 2166,
+            "category": 1 /* Error */
+        },
+        "Numeric indexer type '{0}' must be assignable to string indexer type '{1}'.": {
+            "code": 2167,
+            "category": 1 /* Error */
+        },
+        "Numeric indexer type '{0}' must be assignable to string indexer type '{1}':{NL}{2}": {
+            "code": 2168,
+            "category": 1 /* Error */
+        },
+        "All numerically named properties must be assignable to numeric indexer type '{0}'.": {
+            "code": 2169,
+            "category": 1 /* Error */
+        },
+        "All numerically named properties must be assignable to numeric indexer type '{0}':{NL}{1}": {
+            "code": 2170,
+            "category": 1 /* Error */
+        },
+        "All named properties must be assignable to string indexer type '{0}'.": {
+            "code": 2171,
+            "category": 1 /* Error */
+        },
+        "All named properties must be assignable to string indexer type '{0}':{NL}{1}": {
+            "code": 2172,
+            "category": 1 /* Error */
+        },
+        "Generic type references must include all type arguments.": {
+            "code": 2173,
+            "category": 1 /* Error */
+        },
+        "Default arguments are only allowed in implementation.": {
+            "code": 2174,
+            "category": 1 /* Error */
+        },
+        "Overloads cannot differ only by return type.": {
+            "code": 2175,
+            "category": 1 /* Error */
+        },
+        "Function expression declared a non-void return type, but has no return expression.": {
+            "code": 2176,
+            "category": 1 /* Error */
+        },
+        "Import declaration referencing identifier from internal module can only be made with variables, functions, classes, interfaces, enums and internal modules.": {
+            "code": 2177,
+            "category": 1 /* Error */
+        },
+        "Could not find symbol '{0}' in module '{1}'.": {
+            "code": 2178,
+            "category": 1 /* Error */
+        },
+        "Unable to resolve module reference '{0}'.": {
+            "code": 2179,
+            "category": 1 /* Error */
+        },
+        "Could not find module '{0}' in module '{1}'.": {
+            "code": 2180,
+            "category": 1 /* Error */
+        },
+        "Exported import declaration '{0}' is assigned value with type that has or is using private type '{1}'.": {
+            "code": 2181,
+            "category": 1 /* Error */
+        },
+        "Exported import declaration '{0}' is assigned value with type that is using inaccessible module '{1}'.": {
+            "code": 2182,
+            "category": 1 /* Error */
+        },
+        "Exported import declaration '{0}' is assigned type that has or is using private type '{1}'.": {
+            "code": 2183,
+            "category": 1 /* Error */
+        },
+        "Exported import declaration '{0}' is assigned type that is using inaccessible module '{1}'.": {
+            "code": 2184,
+            "category": 1 /* Error */
+        },
+        "Exported import declaration '{0}' is assigned container that is or is using inaccessible module '{1}'.": {
+            "code": 2185,
+            "category": 1 /* Error */
+        },
+        "Type name '{0}' in extends clause does not reference constructor function for '{1}'.": {
+            "code": 2186,
+            "category": 1 /* Error */
+        },
+        "Internal module reference '{0}' in import declaration does not reference module instance for '{1}'.": {
+            "code": 2187,
+            "category": 1 /* Error */
+        },
+        "Module '{0}' cannot merge with previous declaration of '{1}' in a different file '{2}'.": {
+            "code": 2188,
+            "category": 1 /* Error */
+        },
+        "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}':{NL}{3}": {
+            "code": 2189,
+            "category": 1 /* Error */
+        },
+        "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it.": {
+            "code": 2190,
+            "category": 1 /* Error */
+        },
+        "Ambient external module declaration cannot be reopened.": {
+            "code": 2191,
+            "category": 1 /* Error */
+        },
+        "All declarations of merged declaration '{0}' must be exported or not exported.": {
+            "code": 2192,
+            "category": 1 /* Error */
+        },
+        "'super' cannot be referenced in constructor arguments.": {
+            "code": 2193,
+            "category": 1 /* Error */
+        },
+        "Return type of constructor signature must be assignable to the instance type of the class.": {
+            "code": 2194,
+            "category": 1 /* Error */
+        },
+        "Ambient external module declaration must be defined in global context.": {
+            "code": 2195,
+            "category": 1 /* Error */
+        },
+        "Ambient external module declaration cannot specify relative module name.": {
+            "code": 2196,
+            "category": 1 /* Error */
+        },
+        "Import declaration in an ambient external module declaration cannot reference external module through relative external module name.": {
+            "code": 2197,
+            "category": 1 /* Error */
+        },
+        "Could not find the best common type of types of all return statement expressions.": {
+            "code": 2198,
+            "category": 1 /* Error */
+        },
+        "Import declaration cannot refer to external module reference when --noResolve option is set.": {
+            "code": 2199,
+            "category": 1 /* Error */
+        },
+        "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference.": {
+            "code": 2200,
+            "category": 1 /* Error */
+        },
+        "'continue' statement can only be used within an enclosing iteration statement.": {
+            "code": 2201,
+            "category": 1 /* Error */
+        },
+        "'break' statement can only be used within an enclosing iteration or switch statement.": {
+            "code": 2202,
+            "category": 1 /* Error */
+        },
+        "Jump target not found.": {
+            "code": 2203,
+            "category": 1 /* Error */
+        },
+        "Jump target cannot cross function boundary.": {
+            "code": 2204,
+            "category": 1 /* Error */
+        },
+        "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference.": {
+            "code": 2205,
+            "category": 1 /* Error */
+        },
+        "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference.": {
+            "code": 2206,
+            "category": 1 /* Error */
+        },
+        "Expression resolves to '_super' that compiler uses to capture base class reference.": {
+            "code": 2207,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.": {
+            "code": 2208,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of call signature from exported interface has or is using private type '{1}'.": {
+            "code": 2209,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of public static method from exported class has or is using private type '{1}'.": {
+            "code": 2210,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of public method from exported class has or is using private type '{1}'.": {
+            "code": 2211,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of method from exported interface has or is using private type '{1}'.": {
+            "code": 2212,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of exported function has or is using private type '{1}'.": {
+            "code": 2213,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.": {
+            "code": 2214,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of call signature from exported interface is using inaccessible module {1}": {
+            "code": 2215,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of public static method from exported class is using inaccessible module {1}.": {
+            "code": 2216,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of public method from exported class is using inaccessible module {1}.": {
+            "code": 2217,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of method from exported interface is using inaccessible module {1}.": {
+            "code": 2218,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of exported function is using inaccessible module {1}.": {
+            "code": 2219,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of exported class has or is using private type '{1}'.": {
+            "code": 2220,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of exported interface has or is using private type '{1}'.": {
+            "code": 2221,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of exported class is using inaccessible module {1}.": {
+            "code": 2222,
+            "category": 1 /* Error */
+        },
+        "TypeParameter '{0}' of exported interface is using inaccessible module {1}.": {
+            "code": 2223,
+            "category": 1 /* Error */
+        },
+        "Duplicate identifier '_i'. Compiler uses '_i' to initialize rest parameter.": {
+            "code": 2224,
+            "category": 1 /* Error */
+        },
+        "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.": {
+            "code": 2225,
+            "category": 1 /* Error */
+        },
+        "Type of conditional '{0}' must be identical to '{1}' or '{2}'.": {
+            "code": 2226,
+            "category": 1 /* Error */
+        },
+        "Type of conditional '{0}' must be identical to '{1}', '{2}' or '{3}'.": {
+            "code": 2227,
+            "category": 1 /* Error */
+        },
+        "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of an external module.": {
+            "code": 2228,
+            "category": 1 /* Error */
+        },
+        "Constraint of a type parameter cannot reference any type parameter from the same type parameter list.": {
+            "code": 2229,
+            "category": 1 /* Error */
+        },
+        "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor.": {
+            "code": 2230,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' cannot be referenced in its initializer.": {
+            "code": 2231,
+            "category": 1 /* Error */
+        },
+        "Duplicate string index signature.": {
+            "code": 2232,
+            "category": 1 /* Error */
+        },
+        "Duplicate number index signature.": {
+            "code": 2233,
+            "category": 1 /* Error */
+        },
+        "All declarations of an interface must have identical type parameters.": {
+            "code": 2234,
+            "category": 1 /* Error */
+        },
+        "Expression resolves to variable declaration '_i' that compiler uses to initialize rest parameter.": {
+            "code": 2235,
+            "category": 1 /* Error */
+        },
+        "Type '{0}' is missing property '{1}' from type '{2}'.": {
+            "code": 4000,
+            "category": 3 /* NoPrefix */
+        },
+        "Types of property '{0}' of types '{1}' and '{2}' are incompatible.": {
+            "code": 4001,
+            "category": 3 /* NoPrefix */
+        },
+        "Types of property '{0}' of types '{1}' and '{2}' are incompatible:{NL}{3}": {
+            "code": 4002,
+            "category": 3 /* NoPrefix */
+        },
+        "Property '{0}' defined as private in type '{1}' is defined as public in type '{2}'.": {
+            "code": 4003,
+            "category": 3 /* NoPrefix */
+        },
+        "Property '{0}' defined as public in type '{1}' is defined as private in type '{2}'.": {
+            "code": 4004,
+            "category": 3 /* NoPrefix */
+        },
+        "Types '{0}' and '{1}' define property '{2}' as private.": {
+            "code": 4005,
+            "category": 3 /* NoPrefix */
+        },
+        "Call signatures of types '{0}' and '{1}' are incompatible.": {
+            "code": 4006,
+            "category": 3 /* NoPrefix */
+        },
+        "Call signatures of types '{0}' and '{1}' are incompatible:{NL}{2}": {
+            "code": 4007,
+            "category": 3 /* NoPrefix */
+        },
+        "Type '{0}' requires a call signature, but type '{1}' lacks one.": {
+            "code": 4008,
+            "category": 3 /* NoPrefix */
+        },
+        "Construct signatures of types '{0}' and '{1}' are incompatible.": {
+            "code": 4009,
+            "category": 3 /* NoPrefix */
+        },
+        "Construct signatures of types '{0}' and '{1}' are incompatible:{NL}{2}": {
+            "code": 4010,
+            "category": 3 /* NoPrefix */
+        },
+        "Type '{0}' requires a construct signature, but type '{1}' lacks one.": {
+            "code": 4011,
+            "category": 3 /* NoPrefix */
+        },
+        "Index signatures of types '{0}' and '{1}' are incompatible.": {
+            "code": 4012,
+            "category": 3 /* NoPrefix */
+        },
+        "Index signatures of types '{0}' and '{1}' are incompatible:{NL}{2}": {
+            "code": 4013,
+            "category": 3 /* NoPrefix */
+        },
+        "Call signature expects {0} or fewer parameters.": {
+            "code": 4014,
+            "category": 3 /* NoPrefix */
+        },
+        "Could not apply type '{0}' to argument {1} which is of type '{2}'.": {
+            "code": 4015,
+            "category": 3 /* NoPrefix */
+        },
+        "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function.": {
+            "code": 4016,
+            "category": 3 /* NoPrefix */
+        },
+        "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function.": {
+            "code": 4017,
+            "category": 3 /* NoPrefix */
+        },
+        "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor.": {
+            "code": 4018,
+            "category": 3 /* NoPrefix */
+        },
+        "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property.": {
+            "code": 4019,
+            "category": 3 /* NoPrefix */
+        },
+        "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible.": {
+            "code": 4020,
+            "category": 3 /* NoPrefix */
+        },
+        "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible:{NL}{3}": {
+            "code": 4021,
+            "category": 3 /* NoPrefix */
+        },
+        "Type reference cannot refer to container '{0}'.": {
+            "code": 4022,
+            "category": 1 /* Error */
+        },
+        "Type reference must refer to type.": {
+            "code": 4023,
+            "category": 1 /* Error */
+        },
+        "In enums with multiple declarations only one declaration can omit an initializer for the first enum element.": {
+            "code": 4024,
+            "category": 1 /* Error */
+        },
+        " (+ {0} overload(s))": {
+            "code": 4025,
+            "category": 2 /* Message */
+        },
+        "Variable declaration cannot have the same name as an import declaration.": {
+            "code": 4026,
+            "category": 1 /* Error */
+        },
+        "Signature expected {0} type arguments, got {1} instead.": {
+            "code": 4027,
+            "category": 1 /* Error */
+        },
+        "Property '{0}' defined as optional in type '{1}', but is required in type '{2}'.": {
+            "code": 4028,
+            "category": 3 /* NoPrefix */
+        },
+        "Types '{0}' and '{1}' originating in infinitely expanding type reference do not refer to same named type.": {
+            "code": 4029,
+            "category": 3 /* NoPrefix */
+        },
+        "Types '{0}' and '{1}' originating in infinitely expanding type reference have incompatible type arguments.": {
+            "code": 4030,
+            "category": 3 /* NoPrefix */
+        },
+        "Types '{0}' and '{1}' originating in infinitely expanding type reference have incompatible type arguments:{NL}{2}": {
+            "code": 4031,
+            "category": 3 /* NoPrefix */
+        },
+        "Named properties '{0}' of types '{1}' and '{2}' are not identical.": {
+            "code": 4032,
+            "category": 3 /* NoPrefix */
+        },
+        "Types of string indexer of types '{0}' and '{1}' are not identical.": {
+            "code": 4033,
+            "category": 3 /* NoPrefix */
+        },
+        "Types of number indexer of types '{0}' and '{1}' are not identical.": {
+            "code": 4034,
+            "category": 3 /* NoPrefix */
+        },
+        "Type of number indexer in type '{0}' is not assignable to string indexer type in type '{1}'.{NL}{2}": {
+            "code": 4035,
+            "category": 3 /* NoPrefix */
+        },
+        "Type of property '{0}' in type '{1}' is not assignable to string indexer type in type '{2}'.{NL}{3}": {
+            "code": 4036,
+            "category": 3 /* NoPrefix */
+        },
+        "Type of property '{0}' in type '{1}' is not assignable to number indexer type in type '{2}'.{NL}{3}": {
+            "code": 4037,
+            "category": 3 /* NoPrefix */
+        },
+        "Static property '{0}' defined as private in type '{1}' is defined as public in type '{2}'.": {
+            "code": 4038,
+            "category": 3 /* NoPrefix */
+        },
+        "Static property '{0}' defined as public in type '{1}' is defined as private in type '{2}'.": {
+            "code": 4039,
+            "category": 3 /* NoPrefix */
+        },
+        "Types '{0}' and '{1}' define static property '{2}' as private.": {
+            "code": 4040,
+            "category": 3 /* NoPrefix */
+        },
+        "Current host does not support '{0}' option.": {
+            "code": 5001,
+            "category": 1 /* Error */
+        },
+        "ECMAScript target version '{0}' not supported.  Specify a valid target version: '{1}' (default), or '{2}'": {
+            "code": 5002,
+            "category": 1 /* Error */
+        },
+        "Module code generation '{0}' not supported.": {
+            "code": 5003,
+            "category": 1 /* Error */
+        },
+        "Could not find file: '{0}'.": {
+            "code": 5004,
+            "category": 1 /* Error */
+        },
+        "A file cannot have a reference to itself.": {
+            "code": 5006,
+            "category": 1 /* Error */
+        },
+        "Cannot resolve referenced file: '{0}'.": {
+            "code": 5007,
+            "category": 1 /* Error */
+        },
+        "Cannot find the common subdirectory path for the input files.": {
+            "code": 5009,
+            "category": 1 /* Error */
+        },
+        "Emit Error: {0}.": {
+            "code": 5011,
+            "category": 1 /* Error */
+        },
+        "Cannot read file '{0}': {1}": {
+            "code": 5012,
+            "category": 1 /* Error */
+        },
+        "Unsupported file encoding.": {
+            "code": 5013,
+            "category": 3 /* NoPrefix */
+        },
+        "Locale must be of the form <language> or <language>-<territory>. For example '{0}' or '{1}'.": {
+            "code": 5014,
+            "category": 1 /* Error */
+        },
+        "Unsupported locale: '{0}'.": {
+            "code": 5015,
+            "category": 1 /* Error */
+        },
+        "Execution Failed.{NL}": {
+            "code": 5016,
+            "category": 1 /* Error */
+        },
+        "Invalid call to 'up'": {
+            "code": 5019,
+            "category": 1 /* Error */
+        },
+        "Invalid call to 'down'": {
+            "code": 5020,
+            "category": 1 /* Error */
+        },
+        "Base64 value '{0}' finished with a continuation bit.": {
+            "code": 5021,
+            "category": 1 /* Error */
+        },
+        "Unknown option '{0}'": {
+            "code": 5023,
+            "category": 1 /* Error */
+        },
+        "Expected {0} arguments to message, got {1} instead.": {
+            "code": 5024,
+            "category": 1 /* Error */
+        },
+        "Expected the message '{0}' to have {1} arguments, but it had {2}": {
+            "code": 5025,
+            "category": 1 /* Error */
+        },
+        "Could not delete file '{0}'": {
+            "code": 5034,
+            "category": 1 /* Error */
+        },
+        "Could not create directory '{0}'": {
+            "code": 5035,
+            "category": 1 /* Error */
+        },
+        "Error while executing file '{0}': ": {
+            "code": 5036,
+            "category": 1 /* Error */
+        },
+        "Cannot compile external modules unless the '--module' flag is provided.": {
+            "code": 5037,
+            "category": 1 /* Error */
+        },
+        "Option mapRoot cannot be specified without specifying sourcemap option.": {
+            "code": 5038,
+            "category": 1 /* Error */
+        },
+        "Option sourceRoot cannot be specified without specifying sourcemap option.": {
+            "code": 5039,
+            "category": 1 /* Error */
+        },
+        "Options mapRoot and sourceRoot cannot be specified without specifying sourcemap option.": {
+            "code": 5040,
+            "category": 1 /* Error */
+        },
+        "Option '{0}' specified without '{1}'": {
+            "code": 5041,
+            "category": 1 /* Error */
+        },
+        "'codepage' option not supported on current platform.": {
+            "code": 5042,
+            "category": 1 /* Error */
+        },
+        "Concatenate and emit output to single file.": {
+            "code": 6001,
+            "category": 2 /* Message */
+        },
+        "Generates corresponding {0} file.": {
+            "code": 6002,
+            "category": 2 /* Message */
+        },
+        "Specifies the location where debugger should locate map files instead of generated locations.": {
+            "code": 6003,
+            "category": 2 /* Message */
+        },
+        "Specifies the location where debugger should locate TypeScript files instead of source locations.": {
+            "code": 6004,
+            "category": 2 /* Message */
+        },
+        "Watch input files.": {
+            "code": 6005,
+            "category": 2 /* Message */
+        },
+        "Redirect output structure to the directory.": {
+            "code": 6006,
+            "category": 2 /* Message */
+        },
+        "Do not emit comments to output.": {
+            "code": 6009,
+            "category": 2 /* Message */
+        },
+        "Skip resolution and preprocessing.": {
+            "code": 6010,
+            "category": 2 /* Message */
+        },
+        "Specify ECMAScript target version: '{0}' (default), or '{1}'": {
+            "code": 6015,
+            "category": 2 /* Message */
+        },
+        "Specify module code generation: '{0}' or '{1}'": {
+            "code": 6016,
+            "category": 2 /* Message */
+        },
+        "Print this message.": {
+            "code": 6017,
+            "category": 2 /* Message */
+        },
+        "Print the compiler's version: {0}": {
+            "code": 6019,
+            "category": 2 /* Message */
+        },
+        "Allow use of deprecated '{0}' keyword when referencing an external module.": {
+            "code": 6021,
+            "category": 2 /* Message */
+        },
+        "Specify locale for errors and messages. For example '{0}' or '{1}'": {
+            "code": 6022,
+            "category": 2 /* Message */
+        },
+        "Syntax:   {0}": {
+            "code": 6023,
+            "category": 2 /* Message */
+        },
+        "options": {
+            "code": 6024,
+            "category": 2 /* Message */
+        },
+        "file1": {
+            "code": 6025,
+            "category": 2 /* Message */
+        },
+        "Examples:": {
+            "code": 6026,
+            "category": 2 /* Message */
+        },
+        "Options:": {
+            "code": 6027,
+            "category": 2 /* Message */
+        },
+        "Insert command line options and files from a file.": {
+            "code": 6030,
+            "category": 2 /* Message */
+        },
+        "Version {0}": {
+            "code": 6029,
+            "category": 2 /* Message */
+        },
+        "Use the '{0}' flag to see options.": {
+            "code": 6031,
+            "category": 2 /* Message */
+        },
+        "{NL}Recompiling ({0}):": {
+            "code": 6032,
+            "category": 2 /* Message */
+        },
+        "STRING": {
+            "code": 6033,
+            "category": 2 /* Message */
+        },
+        "KIND": {
+            "code": 6034,
+            "category": 2 /* Message */
+        },
+        "file2": {
+            "code": 6035,
+            "category": 2 /* Message */
+        },
+        "VERSION": {
+            "code": 6036,
+            "category": 2 /* Message */
+        },
+        "LOCATION": {
+            "code": 6037,
+            "category": 2 /* Message */
+        },
+        "DIRECTORY": {
+            "code": 6038,
+            "category": 2 /* Message */
+        },
+        "NUMBER": {
+            "code": 6039,
+            "category": 2 /* Message */
+        },
+        "Specify the codepage to use when opening source files.": {
+            "code": 6040,
+            "category": 2 /* Message */
+        },
+        "Additional locations:": {
+            "code": 6041,
+            "category": 2 /* Message */
+        },
+        "This version of the Javascript runtime does not support the '{0}' function.": {
+            "code": 7000,
+            "category": 1 /* Error */
+        },
+        "Unknown rule.": {
+            "code": 7002,
+            "category": 1 /* Error */
+        },
+        "Invalid line number ({0})": {
+            "code": 7003,
+            "category": 1 /* Error */
+        },
+        "Warn on expressions and declarations with an implied 'any' type.": {
+            "code": 7004,
+            "category": 2 /* Message */
+        },
+        "Variable '{0}' implicitly has an 'any' type.": {
+            "code": 7005,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of '{1}' implicitly has an 'any' type.": {
+            "code": 7006,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of function type implicitly has an 'any' type.": {
+            "code": 7007,
+            "category": 1 /* Error */
+        },
+        "Member '{0}' of object type implicitly has an 'any' type.": {
+            "code": 7008,
+            "category": 1 /* Error */
+        },
+        "'new' expression, which lacks a constructor signature, implicitly has an 'any' type.": {
+            "code": 7009,
+            "category": 1 /* Error */
+        },
+        "'{0}', which lacks return-type annotation, implicitly has an 'any' return type.": {
+            "code": 7010,
+            "category": 1 /* Error */
+        },
+        "Function expression, which lacks return-type annotation, implicitly has an 'any' return type.": {
+            "code": 7011,
+            "category": 1 /* Error */
+        },
+        "Parameter '{0}' of lambda function implicitly has an 'any' type.": {
+            "code": 7012,
+            "category": 1 /* Error */
+        },
+        "Constructor signature, which lacks return-type annotation, implicitly has an 'any' return type.": {
+            "code": 7013,
+            "category": 1 /* Error */
+        },
+        "Lambda Function, which lacks return-type annotation, implicitly has an 'any' return type.": {
+            "code": 7014,
+            "category": 1 /* Error */
+        },
+        "Array Literal implicitly has an 'any' type from widening.": {
+            "code": 7015,
+            "category": 1 /* Error */
+        },
+        "'{0}', which lacks 'get' accessor and parameter type annotation on 'set' accessor, implicitly has an 'any' type.": {
+            "code": 7016,
+            "category": 1 /* Error */
+        },
+        "Index signature of object type implicitly has an 'any' type.": {
+            "code": 7017,
+            "category": 1 /* Error */
+        },
+        "Object literal's property '{0}' implicitly has an 'any' type from widening.": {
+            "code": 7018,
+            "category": 1 /* Error */
+        }
+    };
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (CharacterCodes) {
+        CharacterCodes[CharacterCodes["nullCharacter"] = 0] = "nullCharacter";
+        CharacterCodes[CharacterCodes["maxAsciiCharacter"] = 127] = "maxAsciiCharacter";
+
+        CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
+        CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
+        CharacterCodes[CharacterCodes["lineSeparator"] = 0x2028] = "lineSeparator";
+        CharacterCodes[CharacterCodes["paragraphSeparator"] = 0x2029] = "paragraphSeparator";
+
+        CharacterCodes[CharacterCodes["nextLine"] = 0x0085] = "nextLine";
+
+        CharacterCodes[CharacterCodes["space"] = 0x0020] = "space";
+        CharacterCodes[CharacterCodes["nonBreakingSpace"] = 0x00A0] = "nonBreakingSpace";
+        CharacterCodes[CharacterCodes["enQuad"] = 0x2000] = "enQuad";
+        CharacterCodes[CharacterCodes["emQuad"] = 0x2001] = "emQuad";
+        CharacterCodes[CharacterCodes["enSpace"] = 0x2002] = "enSpace";
+        CharacterCodes[CharacterCodes["emSpace"] = 0x2003] = "emSpace";
+        CharacterCodes[CharacterCodes["threePerEmSpace"] = 0x2004] = "threePerEmSpace";
+        CharacterCodes[CharacterCodes["fourPerEmSpace"] = 0x2005] = "fourPerEmSpace";
+        CharacterCodes[CharacterCodes["sixPerEmSpace"] = 0x2006] = "sixPerEmSpace";
+        CharacterCodes[CharacterCodes["figureSpace"] = 0x2007] = "figureSpace";
+        CharacterCodes[CharacterCodes["punctuationSpace"] = 0x2008] = "punctuationSpace";
+        CharacterCodes[CharacterCodes["thinSpace"] = 0x2009] = "thinSpace";
+        CharacterCodes[CharacterCodes["hairSpace"] = 0x200A] = "hairSpace";
+        CharacterCodes[CharacterCodes["zeroWidthSpace"] = 0x200B] = "zeroWidthSpace";
+        CharacterCodes[CharacterCodes["narrowNoBreakSpace"] = 0x202F] = "narrowNoBreakSpace";
+        CharacterCodes[CharacterCodes["ideographicSpace"] = 0x3000] = "ideographicSpace";
+
+        CharacterCodes[CharacterCodes["_"] = 95] = "_";
+        CharacterCodes[CharacterCodes["$"] = 36] = "$";
+
+        CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
+        CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
+        CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
+
+        CharacterCodes[CharacterCodes["a"] = 97] = "a";
+        CharacterCodes[CharacterCodes["b"] = 98] = "b";
+        CharacterCodes[CharacterCodes["c"] = 99] = "c";
+        CharacterCodes[CharacterCodes["d"] = 100] = "d";
+        CharacterCodes[CharacterCodes["e"] = 101] = "e";
+        CharacterCodes[CharacterCodes["f"] = 102] = "f";
+        CharacterCodes[CharacterCodes["g"] = 103] = "g";
+        CharacterCodes[CharacterCodes["h"] = 104] = "h";
+        CharacterCodes[CharacterCodes["i"] = 105] = "i";
+        CharacterCodes[CharacterCodes["k"] = 107] = "k";
+        CharacterCodes[CharacterCodes["l"] = 108] = "l";
+        CharacterCodes[CharacterCodes["m"] = 109] = "m";
+        CharacterCodes[CharacterCodes["n"] = 110] = "n";
+        CharacterCodes[CharacterCodes["o"] = 111] = "o";
+        CharacterCodes[CharacterCodes["p"] = 112] = "p";
+        CharacterCodes[CharacterCodes["q"] = 113] = "q";
+        CharacterCodes[CharacterCodes["r"] = 114] = "r";
+        CharacterCodes[CharacterCodes["s"] = 115] = "s";
+        CharacterCodes[CharacterCodes["t"] = 116] = "t";
+        CharacterCodes[CharacterCodes["u"] = 117] = "u";
+        CharacterCodes[CharacterCodes["v"] = 118] = "v";
+        CharacterCodes[CharacterCodes["w"] = 119] = "w";
+        CharacterCodes[CharacterCodes["x"] = 120] = "x";
+        CharacterCodes[CharacterCodes["y"] = 121] = "y";
+        CharacterCodes[CharacterCodes["z"] = 122] = "z";
+
+        CharacterCodes[CharacterCodes["A"] = 65] = "A";
+        CharacterCodes[CharacterCodes["E"] = 69] = "E";
+        CharacterCodes[CharacterCodes["F"] = 70] = "F";
+        CharacterCodes[CharacterCodes["X"] = 88] = "X";
+        CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
+
+        CharacterCodes[CharacterCodes["ampersand"] = 38] = "ampersand";
+        CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
+        CharacterCodes[CharacterCodes["at"] = 64] = "at";
+        CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
+        CharacterCodes[CharacterCodes["bar"] = 124] = "bar";
+        CharacterCodes[CharacterCodes["caret"] = 94] = "caret";
+        CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
+        CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
+        CharacterCodes[CharacterCodes["closeParen"] = 41] = "closeParen";
+        CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
+        CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
+        CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
+        CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
+        CharacterCodes[CharacterCodes["equals"] = 61] = "equals";
+        CharacterCodes[CharacterCodes["exclamation"] = 33] = "exclamation";
+        CharacterCodes[CharacterCodes["greaterThan"] = 62] = "greaterThan";
+        CharacterCodes[CharacterCodes["lessThan"] = 60] = "lessThan";
+        CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
+        CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
+        CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
+        CharacterCodes[CharacterCodes["openParen"] = 40] = "openParen";
+        CharacterCodes[CharacterCodes["percent"] = 37] = "percent";
+        CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
+        CharacterCodes[CharacterCodes["question"] = 63] = "question";
+        CharacterCodes[CharacterCodes["semicolon"] = 59] = "semicolon";
+        CharacterCodes[CharacterCodes["singleQuote"] = 39] = "singleQuote";
+        CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
+        CharacterCodes[CharacterCodes["tilde"] = 126] = "tilde";
+
+        CharacterCodes[CharacterCodes["backspace"] = 8] = "backspace";
+        CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
+        CharacterCodes[CharacterCodes["byteOrderMark"] = 0xFEFF] = "byteOrderMark";
+        CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
+        CharacterCodes[CharacterCodes["verticalTab"] = 11] = "verticalTab";
+    })(TypeScript.CharacterCodes || (TypeScript.CharacterCodes = {}));
+    var CharacterCodes = TypeScript.CharacterCodes;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    
+
+    (function (ScriptSnapshot) {
+        var StringScriptSnapshot = (function () {
+            function StringScriptSnapshot(text) {
+                this.text = text;
+                this._lineStartPositions = null;
+            }
+            StringScriptSnapshot.prototype.getText = function (start, end) {
+                return this.text.substring(start, end);
+            };
+
+            StringScriptSnapshot.prototype.getLength = function () {
+                return this.text.length;
+            };
+
+            StringScriptSnapshot.prototype.getLineStartPositions = function () {
+                if (!this._lineStartPositions) {
+                    this._lineStartPositions = TypeScript.TextUtilities.parseLineStarts(this.text);
+                }
+
+                return this._lineStartPositions;
+            };
+
+            StringScriptSnapshot.prototype.getTextChangeRangeSinceVersion = function (scriptVersion) {
+                throw TypeScript.Errors.notYetImplemented();
+            };
+            return StringScriptSnapshot;
+        })();
+
+        function fromString(text) {
+            return new StringScriptSnapshot(text);
+        }
+        ScriptSnapshot.fromString = fromString;
+    })(TypeScript.ScriptSnapshot || (TypeScript.ScriptSnapshot = {}));
+    var ScriptSnapshot = TypeScript.ScriptSnapshot;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (LineMap1) {
+        function fromSimpleText(text) {
+            return new TypeScript.LineMap(function () {
+                return TypeScript.TextUtilities.parseLineStarts({ charCodeAt: function (index) {
+                        return text.charCodeAt(index);
+                    }, length: text.length() });
+            }, text.length());
+        }
+        LineMap1.fromSimpleText = fromSimpleText;
+
+        function fromScriptSnapshot(scriptSnapshot) {
+            return new TypeScript.LineMap(function () {
+                return scriptSnapshot.getLineStartPositions();
+            }, scriptSnapshot.getLength());
+        }
+        LineMap1.fromScriptSnapshot = fromScriptSnapshot;
+
+        function fromString(text) {
+            return new TypeScript.LineMap(function () {
+                return TypeScript.TextUtilities.parseLineStarts(text);
+            }, text.length);
+        }
+        LineMap1.fromString = fromString;
+    })(TypeScript.LineMap1 || (TypeScript.LineMap1 = {}));
+    var LineMap1 = TypeScript.LineMap1;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (TextFactory) {
+        function getStartAndLengthOfLineBreakEndingAt(text, index, info) {
+            var c = text.charCodeAt(index);
+            if (c === 10 /* lineFeed */) {
+                if (index > 0 && text.charCodeAt(index - 1) === 13 /* carriageReturn */) {
+                    info.startPosition = index - 1;
+                    info.length = 2;
+                } else {
+                    info.startPosition = index;
+                    info.length = 1;
+                }
+            } else if (TypeScript.TextUtilities.isAnyLineBreakCharacter(c)) {
+                info.startPosition = index;
+                info.length = 1;
+            } else {
+                info.startPosition = index + 1;
+                info.length = 0;
+            }
+        }
+
+        var LinebreakInfo = (function () {
+            function LinebreakInfo(startPosition, length) {
+                this.startPosition = startPosition;
+                this.length = length;
+            }
+            return LinebreakInfo;
+        })();
+
+        var TextLine = (function () {
+            function TextLine(text, body, lineBreakLength, lineNumber) {
+                this._text = null;
+                this._textSpan = null;
+                if (text === null) {
+                    throw TypeScript.Errors.argumentNull('text');
+                }
+                TypeScript.Debug.assert(lineBreakLength >= 0);
+                TypeScript.Debug.assert(lineNumber >= 0);
+                this._text = text;
+                this._textSpan = body;
+                this._lineBreakLength = lineBreakLength;
+                this._lineNumber = lineNumber;
+            }
+            TextLine.prototype.start = function () {
+                return this._textSpan.start();
+            };
+
+            TextLine.prototype.end = function () {
+                return this._textSpan.end();
+            };
+
+            TextLine.prototype.endIncludingLineBreak = function () {
+                return this.end() + this._lineBreakLength;
+            };
+
+            TextLine.prototype.extent = function () {
+                return this._textSpan;
+            };
+
+            TextLine.prototype.extentIncludingLineBreak = function () {
+                return TypeScript.TextSpan.fromBounds(this.start(), this.endIncludingLineBreak());
+            };
+
+            TextLine.prototype.toString = function () {
+                return this._text.toString(this._textSpan);
+            };
+
+            TextLine.prototype.lineNumber = function () {
+                return this._lineNumber;
+            };
+            return TextLine;
+        })();
+
+        var TextBase = (function () {
+            function TextBase() {
+                this.linebreakInfo = new LinebreakInfo(0, 0);
+                this.lastLineFoundForPosition = null;
+            }
+            TextBase.prototype.length = function () {
+                throw TypeScript.Errors.abstract();
+            };
+
+            TextBase.prototype.charCodeAt = function (position) {
+                throw TypeScript.Errors.abstract();
+            };
+
+            TextBase.prototype.checkSubSpan = function (span) {
+                if (span.start() < 0 || span.start() > this.length() || span.end() > this.length()) {
+                    throw TypeScript.Errors.argumentOutOfRange("span");
+                }
+            };
+
+            TextBase.prototype.toString = function (span) {
+                if (typeof span === "undefined") { span = null; }
+                throw TypeScript.Errors.abstract();
+            };
+
+            TextBase.prototype.subText = function (span) {
+                this.checkSubSpan(span);
+
+                return new SubText(this, span);
+            };
+
+            TextBase.prototype.substr = function (start, length, intern) {
+                throw TypeScript.Errors.abstract();
+            };
+
+            TextBase.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) {
+                throw TypeScript.Errors.abstract();
+            };
+
+            TextBase.prototype.lineCount = function () {
+                return this._lineStarts().length;
+            };
+
+            TextBase.prototype.lines = function () {
+                var lines = [];
+
+                var length = this.lineCount();
+                for (var i = 0; i < length; ++i) {
+                    lines[i] = this.getLineFromLineNumber(i);
+                }
+
+                return lines;
+            };
+
+            TextBase.prototype.lineMap = function () {
+                var _this = this;
+                return new TypeScript.LineMap(function () {
+                    return _this._lineStarts();
+                }, this.length());
+            };
+
+            TextBase.prototype._lineStarts = function () {
+                throw TypeScript.Errors.abstract();
+            };
+
+            TextBase.prototype.getLineFromLineNumber = function (lineNumber) {
+                var lineStarts = this._lineStarts();
+
+                if (lineNumber < 0 || lineNumber >= lineStarts.length) {
+                    throw TypeScript.Errors.argumentOutOfRange("lineNumber");
+                }
+
+                var first = lineStarts[lineNumber];
+                if (lineNumber === lineStarts.length - 1) {
+                    return new TextLine(this, new TypeScript.TextSpan(first, this.length() - first), 0, lineNumber);
+                } else {
+                    getStartAndLengthOfLineBreakEndingAt(this, lineStarts[lineNumber + 1] - 1, this.linebreakInfo);
+                    return new TextLine(this, new TypeScript.TextSpan(first, this.linebreakInfo.startPosition - first), this.linebreakInfo.length, lineNumber);
+                }
+            };
+
+            TextBase.prototype.getLineFromPosition = function (position) {
+                var lastFound = this.lastLineFoundForPosition;
+                if (lastFound !== null && lastFound.start() <= position && lastFound.endIncludingLineBreak() > position) {
+                    return lastFound;
+                }
+
+                var lineNumber = this.getLineNumberFromPosition(position);
+
+                var result = this.getLineFromLineNumber(lineNumber);
+                this.lastLineFoundForPosition = result;
+                return result;
+            };
+
+            TextBase.prototype.getLineNumberFromPosition = function (position) {
+                if (position < 0 || position > this.length()) {
+                    throw TypeScript.Errors.argumentOutOfRange("position");
+                }
+
+                if (position === this.length()) {
+                    return this.lineCount() - 1;
+                }
+
+                var lineNumber = TypeScript.ArrayUtilities.binarySearch(this._lineStarts(), position);
+                if (lineNumber < 0) {
+                    lineNumber = (~lineNumber) - 1;
+                }
+
+                return lineNumber;
+            };
+
+            TextBase.prototype.getLinePosition = function (position) {
+                if (position < 0 || position > this.length()) {
+                    throw TypeScript.Errors.argumentOutOfRange("position");
+                }
+
+                var lineNumber = this.getLineNumberFromPosition(position);
+
+                return new TypeScript.LineAndCharacter(lineNumber, position - this._lineStarts()[lineNumber]);
+            };
+            return TextBase;
+        })();
+
+        var SubText = (function (_super) {
+            __extends(SubText, _super);
+            function SubText(text, span) {
+                _super.call(this);
+                this._lazyLineStarts = null;
+
+                if (text === null) {
+                    throw TypeScript.Errors.argumentNull("text");
+                }
+
+                if (span.start() < 0 || span.start() >= text.length() || span.end() < 0 || span.end() > text.length()) {
+                    throw TypeScript.Errors.argument("span");
+                }
+
+                this.text = text;
+                this.span = span;
+            }
+            SubText.prototype.length = function () {
+                return this.span.length();
+            };
+
+            SubText.prototype.charCodeAt = function (position) {
+                if (position < 0 || position > this.length()) {
+                    throw TypeScript.Errors.argumentOutOfRange("position");
+                }
+
+                return this.text.charCodeAt(this.span.start() + position);
+            };
+
+            SubText.prototype.subText = function (span) {
+                this.checkSubSpan(span);
+
+                return new SubText(this.text, this.getCompositeSpan(span.start(), span.length()));
+            };
+
+            SubText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) {
+                var span = this.getCompositeSpan(sourceIndex, count);
+                this.text.copyTo(span.start(), destination, destinationIndex, span.length());
+            };
+
+            SubText.prototype.substr = function (start, length, intern) {
+                var startInOriginalText = this.span.start() + start;
+                return this.text.substr(startInOriginalText, length, intern);
+            };
+
+            SubText.prototype.getCompositeSpan = function (start, length) {
+                var compositeStart = TypeScript.MathPrototype.min(this.text.length(), this.span.start() + start);
+                var compositeEnd = TypeScript.MathPrototype.min(this.text.length(), compositeStart + length);
+                return new TypeScript.TextSpan(compositeStart, compositeEnd - compositeStart);
+            };
+
+            SubText.prototype._lineStarts = function () {
+                var _this = this;
+                if (!this._lazyLineStarts) {
+                    this._lazyLineStarts = TypeScript.TextUtilities.parseLineStarts({ charCodeAt: function (index) {
+                            return _this.charCodeAt(index);
+                        }, length: this.length() });
+                }
+
+                return this._lazyLineStarts;
+            };
+            return SubText;
+        })(TextBase);
+
+        var StringText = (function (_super) {
+            __extends(StringText, _super);
+            function StringText(data) {
+                _super.call(this);
+                this.source = null;
+                this._lazyLineStarts = null;
+
+                if (data === null) {
+                    throw TypeScript.Errors.argumentNull("data");
+                }
+
+                this.source = data;
+            }
+            StringText.prototype.length = function () {
+                return this.source.length;
+            };
+
+            StringText.prototype.charCodeAt = function (position) {
+                if (position < 0 || position >= this.source.length) {
+                    throw TypeScript.Errors.argumentOutOfRange("position");
+                }
+
+                return this.source.charCodeAt(position);
+            };
+
+            StringText.prototype.substr = function (start, length, intern) {
+                return this.source.substr(start, length);
+            };
+
+            StringText.prototype.toString = function (span) {
+                if (typeof span === "undefined") { span = null; }
+                if (span === null) {
+                    span = new TypeScript.TextSpan(0, this.length());
+                }
+
+                this.checkSubSpan(span);
+
+                if (span.start() === 0 && span.length() === this.length()) {
+                    return this.source;
+                }
+
+                return this.source.substr(span.start(), span.length());
+            };
+
+            StringText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) {
+                TypeScript.StringUtilities.copyTo(this.source, sourceIndex, destination, destinationIndex, count);
+            };
+
+            StringText.prototype._lineStarts = function () {
+                if (this._lazyLineStarts === null) {
+                    this._lazyLineStarts = TypeScript.TextUtilities.parseLineStarts(this.source);
+                }
+
+                return this._lazyLineStarts;
+            };
+            return StringText;
+        })(TextBase);
+
+        function createText(value) {
+            return new StringText(value);
+        }
+        TextFactory.createText = createText;
+    })(TypeScript.TextFactory || (TypeScript.TextFactory = {}));
+    var TextFactory = TypeScript.TextFactory;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    (function (SimpleText) {
+        var SimpleSubText = (function () {
+            function SimpleSubText(text, span) {
+                this.text = null;
+                this.span = null;
+                if (text === null) {
+                    throw TypeScript.Errors.argumentNull("text");
+                }
+
+                if (span.start() < 0 || span.start() >= text.length() || span.end() < 0 || span.end() > text.length()) {
+                    throw TypeScript.Errors.argument("span");
+                }
+
+                this.text = text;
+                this.span = span;
+            }
+            SimpleSubText.prototype.checkSubSpan = function (span) {
+                if (span.start() < 0 || span.start() > this.length() || span.end() > this.length()) {
+                    throw TypeScript.Errors.argumentOutOfRange("span");
+                }
+            };
+
+            SimpleSubText.prototype.checkSubPosition = function (position) {
+                if (position < 0 || position >= this.length()) {
+                    throw TypeScript.Errors.argumentOutOfRange("position");
+                }
+            };
+
+            SimpleSubText.prototype.length = function () {
+                return this.span.length();
+            };
+
+            SimpleSubText.prototype.subText = function (span) {
+                this.checkSubSpan(span);
+
+                return new SimpleSubText(this.text, this.getCompositeSpan(span.start(), span.length()));
+            };
+
+            SimpleSubText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) {
+                var span = this.getCompositeSpan(sourceIndex, count);
+                this.text.copyTo(span.start(), destination, destinationIndex, span.length());
+            };
+
+            SimpleSubText.prototype.substr = function (start, length, intern) {
+                var span = this.getCompositeSpan(start, length);
+                return this.text.substr(span.start(), span.length(), intern);
+            };
+
+            SimpleSubText.prototype.getCompositeSpan = function (start, length) {
+                var compositeStart = TypeScript.MathPrototype.min(this.text.length(), this.span.start() + start);
+                var compositeEnd = TypeScript.MathPrototype.min(this.text.length(), compositeStart + length);
+                return new TypeScript.TextSpan(compositeStart, compositeEnd - compositeStart);
+            };
+
+            SimpleSubText.prototype.charCodeAt = function (index) {
+                this.checkSubPosition(index);
+                return this.text.charCodeAt(this.span.start() + index);
+            };
+
+            SimpleSubText.prototype.lineMap = function () {
+                return TypeScript.LineMap1.fromSimpleText(this);
+            };
+            return SimpleSubText;
+        })();
+
+        var SimpleStringText = (function () {
+            function SimpleStringText(value) {
+                this.value = value;
+                this._lineMap = null;
+            }
+            SimpleStringText.prototype.length = function () {
+                return this.value.length;
+            };
+
+            SimpleStringText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) {
+                TypeScript.StringUtilities.copyTo(this.value, sourceIndex, destination, destinationIndex, count);
+            };
+
+            SimpleStringText.prototype.substr = function (start, length, intern) {
+                if (intern) {
+                    var array = length <= SimpleStringText.charArray.length ? SimpleStringText.charArray : TypeScript.ArrayUtilities.createArray(length, 0);
+                    this.copyTo(start, array, 0, length);
+                    return TypeScript.Collections.DefaultStringTable.addCharArray(array, 0, length);
+                }
+
+                return this.value.substr(start, length);
+            };
+
+            SimpleStringText.prototype.subText = function (span) {
+                return new SimpleSubText(this, span);
+            };
+
+            SimpleStringText.prototype.charCodeAt = function (index) {
+                return this.value.charCodeAt(index);
+            };
+
+            SimpleStringText.prototype.lineMap = function () {
+                if (!this._lineMap) {
+                    this._lineMap = TypeScript.LineMap1.fromString(this.value);
+                }
+
+                return this._lineMap;
+            };
+            SimpleStringText.charArray = TypeScript.ArrayUtilities.createArray(1024, 0);
+            return SimpleStringText;
+        })();
+
+        var SimpleScriptSnapshotText = (function () {
+            function SimpleScriptSnapshotText(scriptSnapshot) {
+                this.scriptSnapshot = scriptSnapshot;
+            }
+            SimpleScriptSnapshotText.prototype.charCodeAt = function (index) {
+                return this.scriptSnapshot.getText(index, index + 1).charCodeAt(0);
+            };
+
+            SimpleScriptSnapshotText.prototype.length = function () {
+                return this.scriptSnapshot.getLength();
+            };
+
+            SimpleScriptSnapshotText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) {
+                var text = this.scriptSnapshot.getText(sourceIndex, sourceIndex + count);
+                TypeScript.StringUtilities.copyTo(text, 0, destination, destinationIndex, count);
+            };
+
+            SimpleScriptSnapshotText.prototype.substr = function (start, length, intern) {
+                return this.scriptSnapshot.getText(start, start + length);
+            };
+
+            SimpleScriptSnapshotText.prototype.subText = function (span) {
+                return new SimpleSubText(this, span);
+            };
+
+            SimpleScriptSnapshotText.prototype.lineMap = function () {
+                var _this = this;
+                return new TypeScript.LineMap(function () {
+                    return _this.scriptSnapshot.getLineStartPositions();
+                }, this.length());
+            };
+            return SimpleScriptSnapshotText;
+        })();
+
+        function fromString(value) {
+            return new SimpleStringText(value);
+        }
+        SimpleText.fromString = fromString;
+
+        function fromScriptSnapshot(scriptSnapshot) {
+            return new SimpleScriptSnapshotText(scriptSnapshot);
+        }
+        SimpleText.fromScriptSnapshot = fromScriptSnapshot;
+    })(TypeScript.SimpleText || (TypeScript.SimpleText = {}));
+    var SimpleText = TypeScript.SimpleText;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (TextUtilities) {
+        function parseLineStarts(text) {
+            var length = text.length;
+
+            if (0 === length) {
+                var result = new Array();
+                result.push(0);
+                return result;
+            }
+
+            var position = 0;
+            var index = 0;
+            var arrayBuilder = new Array();
+            var lineNumber = 0;
+
+            while (index < length) {
+                var c = text.charCodeAt(index);
+                var lineBreakLength;
+
+                if (c > 13 /* carriageReturn */ && c <= 127) {
+                    index++;
+                    continue;
+                } else if (c === 13 /* carriageReturn */ && index + 1 < length && text.charCodeAt(index + 1) === 10 /* lineFeed */) {
+                    lineBreakLength = 2;
+                } else if (c === 10 /* lineFeed */) {
+                    lineBreakLength = 1;
+                } else {
+                    lineBreakLength = TextUtilities.getLengthOfLineBreak(text, index);
+                }
+
+                if (0 === lineBreakLength) {
+                    index++;
+                } else {
+                    arrayBuilder.push(position);
+                    index += lineBreakLength;
+                    position = index;
+                    lineNumber++;
+                }
+            }
+
+            arrayBuilder.push(position);
+
+            return arrayBuilder;
+        }
+        TextUtilities.parseLineStarts = parseLineStarts;
+
+        function getLengthOfLineBreakSlow(text, index, c) {
+            if (c === 13 /* carriageReturn */) {
+                var next = index + 1;
+                return (next < text.length) && 10 /* lineFeed */ === text.charCodeAt(next) ? 2 : 1;
+            } else if (isAnyLineBreakCharacter(c)) {
+                return 1;
+            } else {
+                return 0;
+            }
+        }
+        TextUtilities.getLengthOfLineBreakSlow = getLengthOfLineBreakSlow;
+
+        function getLengthOfLineBreak(text, index) {
+            var c = text.charCodeAt(index);
+
+            if (c > 13 /* carriageReturn */ && c <= 127) {
+                return 0;
+            }
+
+            return getLengthOfLineBreakSlow(text, index, c);
+        }
+        TextUtilities.getLengthOfLineBreak = getLengthOfLineBreak;
+
+        function isAnyLineBreakCharacter(c) {
+            return c === 10 /* lineFeed */ || c === 13 /* carriageReturn */ || c === 133 /* nextLine */ || c === 8232 /* lineSeparator */ || c === 8233 /* paragraphSeparator */;
+        }
+        TextUtilities.isAnyLineBreakCharacter = isAnyLineBreakCharacter;
+    })(TypeScript.TextUtilities || (TypeScript.TextUtilities = {}));
+    var TextUtilities = TypeScript.TextUtilities;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var TextSpan = (function () {
+        function TextSpan(start, length) {
+            if (start < 0) {
+                TypeScript.Errors.argument("start");
+            }
+
+            if (length < 0) {
+                TypeScript.Errors.argument("length");
+            }
+
+            this._start = start;
+            this._length = length;
+        }
+        TextSpan.prototype.start = function () {
+            return this._start;
+        };
+
+        TextSpan.prototype.length = function () {
+            return this._length;
+        };
+
+        TextSpan.prototype.end = function () {
+            return this._start + this._length;
+        };
+
+        TextSpan.prototype.isEmpty = function () {
+            return this._length === 0;
+        };
+
+        TextSpan.prototype.containsPosition = function (position) {
+            return position >= this._start && position < this.end();
+        };
+
+        TextSpan.prototype.containsTextSpan = function (span) {
+            return span._start >= this._start && span.end() <= this.end();
+        };
+
+        TextSpan.prototype.overlapsWith = function (span) {
+            var overlapStart = TypeScript.MathPrototype.max(this._start, span._start);
+            var overlapEnd = TypeScript.MathPrototype.min(this.end(), span.end());
+
+            return overlapStart < overlapEnd;
+        };
+
+        TextSpan.prototype.overlap = function (span) {
+            var overlapStart = TypeScript.MathPrototype.max(this._start, span._start);
+            var overlapEnd = TypeScript.MathPrototype.min(this.end(), span.end());
+
+            if (overlapStart < overlapEnd) {
+                return TextSpan.fromBounds(overlapStart, overlapEnd);
+            }
+
+            return null;
+        };
+
+        TextSpan.prototype.intersectsWithTextSpan = function (span) {
+            return span._start <= this.end() && span.end() >= this._start;
+        };
+
+        TextSpan.prototype.intersectsWith = function (start, length) {
+            var end = start + length;
+            return start <= this.end() && end >= this._start;
+        };
+
+        TextSpan.prototype.intersectsWithPosition = function (position) {
+            return position <= this.end() && position >= this._start;
+        };
+
+        TextSpan.prototype.intersection = function (span) {
+            var intersectStart = TypeScript.MathPrototype.max(this._start, span._start);
+            var intersectEnd = TypeScript.MathPrototype.min(this.end(), span.end());
+
+            if (intersectStart <= intersectEnd) {
+                return TextSpan.fromBounds(intersectStart, intersectEnd);
+            }
+
+            return null;
+        };
+
+        TextSpan.fromBounds = function (start, end) {
+            TypeScript.Debug.assert(start >= 0);
+            TypeScript.Debug.assert(end - start >= 0);
+            return new TextSpan(start, end - start);
+        };
+        return TextSpan;
+    })();
+    TypeScript.TextSpan = TextSpan;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var TextChangeRange = (function () {
+        function TextChangeRange(span, newLength) {
+            if (newLength < 0) {
+                throw TypeScript.Errors.argumentOutOfRange("newLength");
+            }
+
+            this._span = span;
+            this._newLength = newLength;
+        }
+        TextChangeRange.prototype.span = function () {
+            return this._span;
+        };
+
+        TextChangeRange.prototype.newLength = function () {
+            return this._newLength;
+        };
+
+        TextChangeRange.prototype.newSpan = function () {
+            return new TypeScript.TextSpan(this.span().start(), this.newLength());
+        };
+
+        TextChangeRange.prototype.isUnchanged = function () {
+            return this.span().isEmpty() && this.newLength() === 0;
+        };
+
+        TextChangeRange.collapseChangesFromSingleVersion = function (changes) {
+            var diff = 0;
+            var start = 1073741823 /* Max31BitInteger */;
+            var end = 0;
+
+            for (var i = 0; i < changes.length; i++) {
+                var change = changes[i];
+                diff += change.newLength() - change.span().length();
+
+                if (change.span().start() < start) {
+                    start = change.span().start();
+                }
+
+                if (change.span().end() > end) {
+                    end = change.span().end();
+                }
+            }
+
+            if (start > end) {
+                return null;
+            }
+
+            var combined = TypeScript.TextSpan.fromBounds(start, end);
+            var newLen = combined.length() + diff;
+
+            return new TextChangeRange(combined, newLen);
+        };
+
+        TextChangeRange.collapseChangesAcrossMultipleVersions = function (changes) {
+            if (changes.length === 0) {
+                return TextChangeRange.unchanged;
+            }
+
+            if (changes.length === 1) {
+                return changes[0];
+            }
+
+            var change0 = changes[0];
+
+            var oldStartN = change0.span().start();
+            var oldEndN = change0.span().end();
+            var newEndN = oldStartN + change0.newLength();
+
+            for (var i = 1; i < changes.length; i++) {
+                var nextChange = changes[i];
+
+                var oldStart1 = oldStartN;
+                var oldEnd1 = oldEndN;
+                var newEnd1 = newEndN;
+
+                var oldStart2 = nextChange.span().start();
+                var oldEnd2 = nextChange.span().end();
+                var newEnd2 = oldStart2 + nextChange.newLength();
+
+                oldStartN = TypeScript.MathPrototype.min(oldStart1, oldStart2);
+                oldEndN = TypeScript.MathPrototype.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1));
+                newEndN = TypeScript.MathPrototype.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2));
+            }
+
+            return new TextChangeRange(TypeScript.TextSpan.fromBounds(oldStartN, oldEndN), newEndN - oldStartN);
+        };
+        TextChangeRange.unchanged = new TextChangeRange(new TypeScript.TextSpan(0, 0), 0);
+        return TextChangeRange;
+    })();
+    TypeScript.TextChangeRange = TextChangeRange;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var CharacterInfo = (function () {
+        function CharacterInfo() {
+        }
+        CharacterInfo.isDecimalDigit = function (c) {
+            return c >= 48 /* _0 */ && c <= 57 /* _9 */;
+        };
+        CharacterInfo.isOctalDigit = function (c) {
+            return c >= 48 /* _0 */ && c <= 55 /* _7 */;
+        };
+
+        CharacterInfo.isHexDigit = function (c) {
+            return CharacterInfo.isDecimalDigit(c) || (c >= 65 /* A */ && c <= 70 /* F */) || (c >= 97 /* a */ && c <= 102 /* f */);
+        };
+
+        CharacterInfo.hexValue = function (c) {
+            return CharacterInfo.isDecimalDigit(c) ? (c - 48 /* _0 */) : (c >= 65 /* A */ && c <= 70 /* F */) ? c - 65 /* A */ + 10 : c - 97 /* a */ + 10;
+        };
+
+        CharacterInfo.isWhitespace = function (ch) {
+            switch (ch) {
+                case 32 /* space */:
+                case 160 /* nonBreakingSpace */:
+                case 8192 /* enQuad */:
+                case 8193 /* emQuad */:
+                case 8194 /* enSpace */:
+                case 8195 /* emSpace */:
+                case 8196 /* threePerEmSpace */:
+                case 8197 /* fourPerEmSpace */:
+                case 8198 /* sixPerEmSpace */:
+                case 8199 /* figureSpace */:
+                case 8200 /* punctuationSpace */:
+                case 8201 /* thinSpace */:
+                case 8202 /* hairSpace */:
+                case 8203 /* zeroWidthSpace */:
+                case 8239 /* narrowNoBreakSpace */:
+                case 12288 /* ideographicSpace */:
+
+                case 9 /* tab */:
+                case 11 /* verticalTab */:
+                case 12 /* formFeed */:
+                case 65279 /* byteOrderMark */:
+                    return true;
+            }
+
+            return false;
+        };
+
+        CharacterInfo.isLineTerminator = function (ch) {
+            switch (ch) {
+                case 13 /* carriageReturn */:
+                case 10 /* lineFeed */:
+                case 8233 /* paragraphSeparator */:
+                case 8232 /* lineSeparator */:
+                    return true;
+            }
+
+            return false;
+        };
+        return CharacterInfo;
+    })();
+    TypeScript.CharacterInfo = CharacterInfo;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (SyntaxConstants) {
+        SyntaxConstants[SyntaxConstants["TriviaNewLineMask"] = 0x00000001] = "TriviaNewLineMask";
+        SyntaxConstants[SyntaxConstants["TriviaCommentMask"] = 0x00000002] = "TriviaCommentMask";
+        SyntaxConstants[SyntaxConstants["TriviaFullWidthShift"] = 2] = "TriviaFullWidthShift";
+
+        SyntaxConstants[SyntaxConstants["NodeDataComputed"] = 0x00000001] = "NodeDataComputed";
+        SyntaxConstants[SyntaxConstants["NodeIncrementallyUnusableMask"] = 0x00000002] = "NodeIncrementallyUnusableMask";
+        SyntaxConstants[SyntaxConstants["NodeParsedInStrictModeMask"] = 0x00000004] = "NodeParsedInStrictModeMask";
+        SyntaxConstants[SyntaxConstants["NodeFullWidthShift"] = 3] = "NodeFullWidthShift";
+
+        SyntaxConstants[SyntaxConstants["IsVariableWidthKeyword"] = 1 << 31] = "IsVariableWidthKeyword";
+    })(TypeScript.SyntaxConstants || (TypeScript.SyntaxConstants = {}));
+    var SyntaxConstants = TypeScript.SyntaxConstants;
+})(TypeScript || (TypeScript = {}));
+var FormattingOptions = (function () {
+    function FormattingOptions(useTabs, spacesPerTab, indentSpaces, newLineCharacter) {
+        this.useTabs = useTabs;
+        this.spacesPerTab = spacesPerTab;
+        this.indentSpaces = indentSpaces;
+        this.newLineCharacter = newLineCharacter;
+    }
+    FormattingOptions.defaultOptions = new FormattingOptions(false, 4, 4, "\r\n");
+    return FormattingOptions;
+})();
+var TypeScript;
+(function (TypeScript) {
+    (function (Indentation) {
+        function columnForEndOfToken(token, syntaxInformationMap, options) {
+            return columnForStartOfToken(token, syntaxInformationMap, options) + token.width();
+        }
+        Indentation.columnForEndOfToken = columnForEndOfToken;
+
+        function columnForStartOfToken(token, syntaxInformationMap, options) {
+            var firstTokenInLine = syntaxInformationMap.firstTokenInLineContainingToken(token);
+            var leadingTextInReverse = [];
+
+            var current = token;
+            while (current !== firstTokenInLine) {
+                current = syntaxInformationMap.previousToken(current);
+
+                if (current === firstTokenInLine) {
+                    leadingTextInReverse.push(current.trailingTrivia().fullText());
+                    leadingTextInReverse.push(current.text());
+                } else {
+                    leadingTextInReverse.push(current.fullText());
+                }
+            }
+
+            collectLeadingTriviaTextToStartOfLine(firstTokenInLine, leadingTextInReverse);
+
+            return columnForLeadingTextInReverse(leadingTextInReverse, options);
+        }
+        Indentation.columnForStartOfToken = columnForStartOfToken;
+
+        function columnForStartOfFirstTokenInLineContainingToken(token, syntaxInformationMap, options) {
+            var firstTokenInLine = syntaxInformationMap.firstTokenInLineContainingToken(token);
+            var leadingTextInReverse = [];
+
+            collectLeadingTriviaTextToStartOfLine(firstTokenInLine, leadingTextInReverse);
+
+            return columnForLeadingTextInReverse(leadingTextInReverse, options);
+        }
+        Indentation.columnForStartOfFirstTokenInLineContainingToken = columnForStartOfFirstTokenInLineContainingToken;
+
+        function collectLeadingTriviaTextToStartOfLine(firstTokenInLine, leadingTextInReverse) {
+            var leadingTrivia = firstTokenInLine.leadingTrivia();
+
+            for (var i = leadingTrivia.count() - 1; i >= 0; i--) {
+                var trivia = leadingTrivia.syntaxTriviaAt(i);
+                if (trivia.kind() === 5 /* NewLineTrivia */) {
+                    break;
+                }
+
+                if (trivia.kind() === 6 /* MultiLineCommentTrivia */) {
+                    var lineSegments = TypeScript.Syntax.splitMultiLineCommentTriviaIntoMultipleLines(trivia);
+                    leadingTextInReverse.push(TypeScript.ArrayUtilities.last(lineSegments));
+
+                    if (lineSegments.length > 0) {
+                        break;
+                    }
+                }
+
+                leadingTextInReverse.push(trivia.fullText());
+            }
+        }
+
+        function columnForLeadingTextInReverse(leadingTextInReverse, options) {
+            var column = 0;
+
+            for (var i = leadingTextInReverse.length - 1; i >= 0; i--) {
+                var text = leadingTextInReverse[i];
+                column = columnForPositionInStringWorker(text, text.length, column, options);
+            }
+
+            return column;
+        }
+
+        function columnForPositionInString(input, position, options) {
+            return columnForPositionInStringWorker(input, position, 0, options);
+        }
+        Indentation.columnForPositionInString = columnForPositionInString;
+
+        function columnForPositionInStringWorker(input, position, startColumn, options) {
+            var column = startColumn;
+            var spacesPerTab = options.spacesPerTab;
+
+            for (var j = 0; j < position; j++) {
+                var ch = input.charCodeAt(j);
+
+                if (ch === 9 /* tab */) {
+                    column += spacesPerTab - column % spacesPerTab;
+                } else {
+                    column++;
+                }
+            }
+
+            return column;
+        }
+
+        function indentationString(column, options) {
+            var numberOfTabs = 0;
+            var numberOfSpaces = TypeScript.MathPrototype.max(0, column);
+
+            if (options.useTabs) {
+                numberOfTabs = Math.floor(column / options.spacesPerTab);
+                numberOfSpaces -= numberOfTabs * options.spacesPerTab;
+            }
+
+            return TypeScript.StringUtilities.repeat('\t', numberOfTabs) + TypeScript.StringUtilities.repeat(' ', numberOfSpaces);
+        }
+        Indentation.indentationString = indentationString;
+
+        function indentationTrivia(column, options) {
+            return TypeScript.Syntax.whitespace(this.indentationString(column, options));
+        }
+        Indentation.indentationTrivia = indentationTrivia;
+
+        function firstNonWhitespacePosition(value) {
+            for (var i = 0; i < value.length; i++) {
+                var ch = value.charCodeAt(i);
+                if (!TypeScript.CharacterInfo.isWhitespace(ch)) {
+                    return i;
+                }
+            }
+
+            return value.length;
+        }
+        Indentation.firstNonWhitespacePosition = firstNonWhitespacePosition;
+    })(TypeScript.Indentation || (TypeScript.Indentation = {}));
+    var Indentation = TypeScript.Indentation;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (LanguageVersion) {
+        LanguageVersion[LanguageVersion["EcmaScript3"] = 0] = "EcmaScript3";
+        LanguageVersion[LanguageVersion["EcmaScript5"] = 1] = "EcmaScript5";
+    })(TypeScript.LanguageVersion || (TypeScript.LanguageVersion = {}));
+    var LanguageVersion = TypeScript.LanguageVersion;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var ParseOptions = (function () {
+        function ParseOptions(languageVersion, allowAutomaticSemicolonInsertion) {
+            this._languageVersion = languageVersion;
+            this._allowAutomaticSemicolonInsertion = allowAutomaticSemicolonInsertion;
+        }
+        ParseOptions.prototype.toJSON = function (key) {
+            return { allowAutomaticSemicolonInsertion: this._allowAutomaticSemicolonInsertion };
+        };
+
+        ParseOptions.prototype.languageVersion = function () {
+            return this._languageVersion;
+        };
+
+        ParseOptions.prototype.allowAutomaticSemicolonInsertion = function () {
+            return this._allowAutomaticSemicolonInsertion;
+        };
+        return ParseOptions;
+    })();
+    TypeScript.ParseOptions = ParseOptions;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var PositionedElement = (function () {
+        function PositionedElement(parent, element, fullStart) {
+            this._parent = parent;
+            this._element = element;
+            this._fullStart = fullStart;
+        }
+        PositionedElement.create = function (parent, element, fullStart) {
+            if (element === null) {
+                return null;
+            }
+
+            if (element.isNode()) {
+                return new PositionedNode(parent, element, fullStart);
+            } else if (element.isToken()) {
+                return new PositionedToken(parent, element, fullStart);
+            } else if (element.isList()) {
+                return new PositionedList(parent, element, fullStart);
+            } else if (element.isSeparatedList()) {
+                return new PositionedSeparatedList(parent, element, fullStart);
+            } else {
+                throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        PositionedElement.prototype.parent = function () {
+            return this._parent;
+        };
+
+        PositionedElement.prototype.parentElement = function () {
+            return this._parent && this._parent._element;
+        };
+
+        PositionedElement.prototype.element = function () {
+            return this._element;
+        };
+
+        PositionedElement.prototype.kind = function () {
+            return this.element().kind();
+        };
+
+        PositionedElement.prototype.childIndex = function (child) {
+            return TypeScript.Syntax.childIndex(this.element(), child);
+        };
+
+        PositionedElement.prototype.childCount = function () {
+            return this.element().childCount();
+        };
+
+        PositionedElement.prototype.childAt = function (index) {
+            var offset = TypeScript.Syntax.childOffsetAt(this.element(), index);
+            return PositionedElement.create(this, this.element().childAt(index), this.fullStart() + offset);
+        };
+
+        PositionedElement.prototype.childStart = function (child) {
+            var offset = TypeScript.Syntax.childOffset(this.element(), child);
+            return this.fullStart() + offset + child.leadingTriviaWidth();
+        };
+
+        PositionedElement.prototype.childEnd = function (child) {
+            var offset = TypeScript.Syntax.childOffset(this.element(), child);
+            return this.fullStart() + offset + child.leadingTriviaWidth() + child.width();
+        };
+
+        PositionedElement.prototype.childStartAt = function (index) {
+            var offset = TypeScript.Syntax.childOffsetAt(this.element(), index);
+            var child = this.element().childAt(index);
+            return this.fullStart() + offset + child.leadingTriviaWidth();
+        };
+
+        PositionedElement.prototype.childEndAt = function (index) {
+            var offset = TypeScript.Syntax.childOffsetAt(this.element(), index);
+            var child = this.element().childAt(index);
+            return this.fullStart() + offset + child.leadingTriviaWidth() + child.width();
+        };
+
+        PositionedElement.prototype.getPositionedChild = function (child) {
+            var offset = TypeScript.Syntax.childOffset(this.element(), child);
+            return PositionedElement.create(this, child, this.fullStart() + offset);
+        };
+
+        PositionedElement.prototype.fullStart = function () {
+            return this._fullStart;
+        };
+
+        PositionedElement.prototype.fullEnd = function () {
+            return this.fullStart() + this.element().fullWidth();
+        };
+
+        PositionedElement.prototype.fullWidth = function () {
+            return this.element().fullWidth();
+        };
+
+        PositionedElement.prototype.start = function () {
+            return this.fullStart() + this.element().leadingTriviaWidth();
+        };
+
+        PositionedElement.prototype.end = function () {
+            return this.fullStart() + this.element().leadingTriviaWidth() + this.element().width();
+        };
+
+        PositionedElement.prototype.root = function () {
+            var current = this;
+            while (current.parent() !== null) {
+                current = current.parent();
+            }
+
+            return current;
+        };
+
+        PositionedElement.prototype.containingNode = function () {
+            var current = this.parent();
+
+            while (current !== null && !current.element().isNode()) {
+                current = current.parent();
+            }
+
+            return current;
+        };
+        return PositionedElement;
+    })();
+    TypeScript.PositionedElement = PositionedElement;
+
+    var PositionedNodeOrToken = (function (_super) {
+        __extends(PositionedNodeOrToken, _super);
+        function PositionedNodeOrToken(parent, nodeOrToken, fullStart) {
+            _super.call(this, parent, nodeOrToken, fullStart);
+        }
+        PositionedNodeOrToken.prototype.nodeOrToken = function () {
+            return this.element();
+        };
+        return PositionedNodeOrToken;
+    })(PositionedElement);
+    TypeScript.PositionedNodeOrToken = PositionedNodeOrToken;
+
+    var PositionedNode = (function (_super) {
+        __extends(PositionedNode, _super);
+        function PositionedNode(parent, node, fullStart) {
+            _super.call(this, parent, node, fullStart);
+        }
+        PositionedNode.prototype.node = function () {
+            return this.element();
+        };
+        return PositionedNode;
+    })(PositionedNodeOrToken);
+    TypeScript.PositionedNode = PositionedNode;
+
+    var PositionedToken = (function (_super) {
+        __extends(PositionedToken, _super);
+        function PositionedToken(parent, token, fullStart) {
+            _super.call(this, parent, token, fullStart);
+        }
+        PositionedToken.prototype.token = function () {
+            return this.element();
+        };
+
+        PositionedToken.prototype.previousToken = function (includeSkippedTokens) {
+            if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; }
+            var triviaList = this.token().leadingTrivia();
+            if (includeSkippedTokens && triviaList && triviaList.hasSkippedToken()) {
+                var currentTriviaEndPosition = this.start();
+                for (var i = triviaList.count() - 1; i >= 0; i--) {
+                    var trivia = triviaList.syntaxTriviaAt(i);
+                    if (trivia.isSkippedToken()) {
+                        return new PositionedSkippedToken(this, trivia.skippedToken(), currentTriviaEndPosition - trivia.fullWidth());
+                    }
+
+                    currentTriviaEndPosition -= trivia.fullWidth();
+                }
+            }
+
+            var start = this.fullStart();
+            if (start === 0) {
+                return null;
+            }
+
+            return this.root().node().findToken(start - 1, includeSkippedTokens);
+        };
+
+        PositionedToken.prototype.nextToken = function (includeSkippedTokens) {
+            if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; }
+            if (this.token().tokenKind === 10 /* EndOfFileToken */) {
+                return null;
+            }
+
+            var triviaList = this.token().trailingTrivia();
+            if (includeSkippedTokens && triviaList && triviaList.hasSkippedToken()) {
+                var fullStart = this.end();
+                for (var i = 0, n = triviaList.count(); i < n; i++) {
+                    var trivia = triviaList.syntaxTriviaAt(i);
+                    if (trivia.isSkippedToken()) {
+                        return new PositionedSkippedToken(this, trivia.skippedToken(), fullStart);
+                    }
+
+                    fullStart += trivia.fullWidth();
+                }
+            }
+
+            return this.root().node().findToken(this.fullEnd(), includeSkippedTokens);
+        };
+        return PositionedToken;
+    })(PositionedNodeOrToken);
+    TypeScript.PositionedToken = PositionedToken;
+
+    var PositionedList = (function (_super) {
+        __extends(PositionedList, _super);
+        function PositionedList(parent, list, fullStart) {
+            _super.call(this, parent, list, fullStart);
+        }
+        PositionedList.prototype.list = function () {
+            return this.element();
+        };
+        return PositionedList;
+    })(PositionedElement);
+    TypeScript.PositionedList = PositionedList;
+
+    var PositionedSeparatedList = (function (_super) {
+        __extends(PositionedSeparatedList, _super);
+        function PositionedSeparatedList(parent, list, fullStart) {
+            _super.call(this, parent, list, fullStart);
+        }
+        PositionedSeparatedList.prototype.list = function () {
+            return this.element();
+        };
+        return PositionedSeparatedList;
+    })(PositionedElement);
+    TypeScript.PositionedSeparatedList = PositionedSeparatedList;
+
+    var PositionedSkippedToken = (function (_super) {
+        __extends(PositionedSkippedToken, _super);
+        function PositionedSkippedToken(parentToken, token, fullStart) {
+            _super.call(this, parentToken.parent(), token, fullStart);
+            this._parentToken = parentToken;
+        }
+        PositionedSkippedToken.prototype.parentToken = function () {
+            return this._parentToken;
+        };
+
+        PositionedSkippedToken.prototype.previousToken = function (includeSkippedTokens) {
+            if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; }
+            var start = this.fullStart();
+
+            if (includeSkippedTokens) {
+                var previousToken;
+
+                if (start >= this.parentToken().end()) {
+                    previousToken = TypeScript.Syntax.findSkippedTokenInTrailingTriviaList(this.parentToken(), start - 1);
+
+                    if (previousToken) {
+                        return previousToken;
+                    }
+
+                    return this.parentToken();
+                } else {
+                    previousToken = TypeScript.Syntax.findSkippedTokenInLeadingTriviaList(this.parentToken(), start - 1);
+
+                    if (previousToken) {
+                        return previousToken;
+                    }
+                }
+            }
+
+            var start = this.parentToken().fullStart();
+            if (start === 0) {
+                return null;
+            }
+
+            return this.root().node().findToken(start - 1, includeSkippedTokens);
+        };
+
+        PositionedSkippedToken.prototype.nextToken = function (includeSkippedTokens) {
+            if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; }
+            if (this.token().tokenKind === 10 /* EndOfFileToken */) {
+                return null;
+            }
+
+            if (includeSkippedTokens) {
+                var end = this.end();
+                var nextToken;
+
+                if (end <= this.parentToken().start()) {
+                    nextToken = TypeScript.Syntax.findSkippedTokenInLeadingTriviaList(this.parentToken(), end);
+
+                    if (nextToken) {
+                        return nextToken;
+                    }
+
+                    return this.parentToken();
+                } else {
+                    nextToken = TypeScript.Syntax.findSkippedTokenInTrailingTriviaList(this.parentToken(), end);
+
+                    if (nextToken) {
+                        return nextToken;
+                    }
+                }
+            }
+
+            return this.root().node().findToken(this.parentToken().fullEnd(), includeSkippedTokens);
+        };
+        return PositionedSkippedToken;
+    })(PositionedToken);
+    TypeScript.PositionedSkippedToken = PositionedSkippedToken;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (SyntaxKind) {
+        SyntaxKind[SyntaxKind["None"] = 0] = "None";
+        SyntaxKind[SyntaxKind["List"] = 1] = "List";
+        SyntaxKind[SyntaxKind["SeparatedList"] = 2] = "SeparatedList";
+        SyntaxKind[SyntaxKind["TriviaList"] = 3] = "TriviaList";
+
+        SyntaxKind[SyntaxKind["WhitespaceTrivia"] = 4] = "WhitespaceTrivia";
+        SyntaxKind[SyntaxKind["NewLineTrivia"] = 5] = "NewLineTrivia";
+        SyntaxKind[SyntaxKind["MultiLineCommentTrivia"] = 6] = "MultiLineCommentTrivia";
+        SyntaxKind[SyntaxKind["SingleLineCommentTrivia"] = 7] = "SingleLineCommentTrivia";
+        SyntaxKind[SyntaxKind["SkippedTokenTrivia"] = 8] = "SkippedTokenTrivia";
+
+        SyntaxKind[SyntaxKind["ErrorToken"] = 9] = "ErrorToken";
+        SyntaxKind[SyntaxKind["EndOfFileToken"] = 10] = "EndOfFileToken";
+
+        SyntaxKind[SyntaxKind["IdentifierName"] = 11] = "IdentifierName";
+
+        SyntaxKind[SyntaxKind["RegularExpressionLiteral"] = 12] = "RegularExpressionLiteral";
+        SyntaxKind[SyntaxKind["NumericLiteral"] = 13] = "NumericLiteral";
+        SyntaxKind[SyntaxKind["StringLiteral"] = 14] = "StringLiteral";
+
+        SyntaxKind[SyntaxKind["BreakKeyword"] = 15] = "BreakKeyword";
+        SyntaxKind[SyntaxKind["CaseKeyword"] = 16] = "CaseKeyword";
+        SyntaxKind[SyntaxKind["CatchKeyword"] = 17] = "CatchKeyword";
+        SyntaxKind[SyntaxKind["ContinueKeyword"] = 18] = "ContinueKeyword";
+        SyntaxKind[SyntaxKind["DebuggerKeyword"] = 19] = "DebuggerKeyword";
+        SyntaxKind[SyntaxKind["DefaultKeyword"] = 20] = "DefaultKeyword";
+        SyntaxKind[SyntaxKind["DeleteKeyword"] = 21] = "DeleteKeyword";
+        SyntaxKind[SyntaxKind["DoKeyword"] = 22] = "DoKeyword";
+        SyntaxKind[SyntaxKind["ElseKeyword"] = 23] = "ElseKeyword";
+        SyntaxKind[SyntaxKind["FalseKeyword"] = 24] = "FalseKeyword";
+        SyntaxKind[SyntaxKind["FinallyKeyword"] = 25] = "FinallyKeyword";
+        SyntaxKind[SyntaxKind["ForKeyword"] = 26] = "ForKeyword";
+        SyntaxKind[SyntaxKind["FunctionKeyword"] = 27] = "FunctionKeyword";
+        SyntaxKind[SyntaxKind["IfKeyword"] = 28] = "IfKeyword";
+        SyntaxKind[SyntaxKind["InKeyword"] = 29] = "InKeyword";
+        SyntaxKind[SyntaxKind["InstanceOfKeyword"] = 30] = "InstanceOfKeyword";
+        SyntaxKind[SyntaxKind["NewKeyword"] = 31] = "NewKeyword";
+        SyntaxKind[SyntaxKind["NullKeyword"] = 32] = "NullKeyword";
+        SyntaxKind[SyntaxKind["ReturnKeyword"] = 33] = "ReturnKeyword";
+        SyntaxKind[SyntaxKind["SwitchKeyword"] = 34] = "SwitchKeyword";
+        SyntaxKind[SyntaxKind["ThisKeyword"] = 35] = "ThisKeyword";
+        SyntaxKind[SyntaxKind["ThrowKeyword"] = 36] = "ThrowKeyword";
+        SyntaxKind[SyntaxKind["TrueKeyword"] = 37] = "TrueKeyword";
+        SyntaxKind[SyntaxKind["TryKeyword"] = 38] = "TryKeyword";
+        SyntaxKind[SyntaxKind["TypeOfKeyword"] = 39] = "TypeOfKeyword";
+        SyntaxKind[SyntaxKind["VarKeyword"] = 40] = "VarKeyword";
+        SyntaxKind[SyntaxKind["VoidKeyword"] = 41] = "VoidKeyword";
+        SyntaxKind[SyntaxKind["WhileKeyword"] = 42] = "WhileKeyword";
+        SyntaxKind[SyntaxKind["WithKeyword"] = 43] = "WithKeyword";
+
+        SyntaxKind[SyntaxKind["ClassKeyword"] = 44] = "ClassKeyword";
+        SyntaxKind[SyntaxKind["ConstKeyword"] = 45] = "ConstKeyword";
+        SyntaxKind[SyntaxKind["EnumKeyword"] = 46] = "EnumKeyword";
+        SyntaxKind[SyntaxKind["ExportKeyword"] = 47] = "ExportKeyword";
+        SyntaxKind[SyntaxKind["ExtendsKeyword"] = 48] = "ExtendsKeyword";
+        SyntaxKind[SyntaxKind["ImportKeyword"] = 49] = "ImportKeyword";
+        SyntaxKind[SyntaxKind["SuperKeyword"] = 50] = "SuperKeyword";
+
+        SyntaxKind[SyntaxKind["ImplementsKeyword"] = 51] = "ImplementsKeyword";
+        SyntaxKind[SyntaxKind["InterfaceKeyword"] = 52] = "InterfaceKeyword";
+        SyntaxKind[SyntaxKind["LetKeyword"] = 53] = "LetKeyword";
+        SyntaxKind[SyntaxKind["PackageKeyword"] = 54] = "PackageKeyword";
+        SyntaxKind[SyntaxKind["PrivateKeyword"] = 55] = "PrivateKeyword";
+        SyntaxKind[SyntaxKind["ProtectedKeyword"] = 56] = "ProtectedKeyword";
+        SyntaxKind[SyntaxKind["PublicKeyword"] = 57] = "PublicKeyword";
+        SyntaxKind[SyntaxKind["StaticKeyword"] = 58] = "StaticKeyword";
+        SyntaxKind[SyntaxKind["YieldKeyword"] = 59] = "YieldKeyword";
+
+        SyntaxKind[SyntaxKind["AnyKeyword"] = 60] = "AnyKeyword";
+        SyntaxKind[SyntaxKind["BooleanKeyword"] = 61] = "BooleanKeyword";
+        SyntaxKind[SyntaxKind["ConstructorKeyword"] = 62] = "ConstructorKeyword";
+        SyntaxKind[SyntaxKind["DeclareKeyword"] = 63] = "DeclareKeyword";
+        SyntaxKind[SyntaxKind["GetKeyword"] = 64] = "GetKeyword";
+        SyntaxKind[SyntaxKind["ModuleKeyword"] = 65] = "ModuleKeyword";
+        SyntaxKind[SyntaxKind["RequireKeyword"] = 66] = "RequireKeyword";
+        SyntaxKind[SyntaxKind["NumberKeyword"] = 67] = "NumberKeyword";
+        SyntaxKind[SyntaxKind["SetKeyword"] = 68] = "SetKeyword";
+        SyntaxKind[SyntaxKind["StringKeyword"] = 69] = "StringKeyword";
+
+        SyntaxKind[SyntaxKind["OpenBraceToken"] = 70] = "OpenBraceToken";
+        SyntaxKind[SyntaxKind["CloseBraceToken"] = 71] = "CloseBraceToken";
+        SyntaxKind[SyntaxKind["OpenParenToken"] = 72] = "OpenParenToken";
+        SyntaxKind[SyntaxKind["CloseParenToken"] = 73] = "CloseParenToken";
+        SyntaxKind[SyntaxKind["OpenBracketToken"] = 74] = "OpenBracketToken";
+        SyntaxKind[SyntaxKind["CloseBracketToken"] = 75] = "CloseBracketToken";
+        SyntaxKind[SyntaxKind["DotToken"] = 76] = "DotToken";
+        SyntaxKind[SyntaxKind["DotDotDotToken"] = 77] = "DotDotDotToken";
+        SyntaxKind[SyntaxKind["SemicolonToken"] = 78] = "SemicolonToken";
+        SyntaxKind[SyntaxKind["CommaToken"] = 79] = "CommaToken";
+        SyntaxKind[SyntaxKind["LessThanToken"] = 80] = "LessThanToken";
+        SyntaxKind[SyntaxKind["GreaterThanToken"] = 81] = "GreaterThanToken";
+        SyntaxKind[SyntaxKind["LessThanEqualsToken"] = 82] = "LessThanEqualsToken";
+        SyntaxKind[SyntaxKind["GreaterThanEqualsToken"] = 83] = "GreaterThanEqualsToken";
+        SyntaxKind[SyntaxKind["EqualsEqualsToken"] = 84] = "EqualsEqualsToken";
+        SyntaxKind[SyntaxKind["EqualsGreaterThanToken"] = 85] = "EqualsGreaterThanToken";
+        SyntaxKind[SyntaxKind["ExclamationEqualsToken"] = 86] = "ExclamationEqualsToken";
+        SyntaxKind[SyntaxKind["EqualsEqualsEqualsToken"] = 87] = "EqualsEqualsEqualsToken";
+        SyntaxKind[SyntaxKind["ExclamationEqualsEqualsToken"] = 88] = "ExclamationEqualsEqualsToken";
+        SyntaxKind[SyntaxKind["PlusToken"] = 89] = "PlusToken";
+        SyntaxKind[SyntaxKind["MinusToken"] = 90] = "MinusToken";
+        SyntaxKind[SyntaxKind["AsteriskToken"] = 91] = "AsteriskToken";
+        SyntaxKind[SyntaxKind["PercentToken"] = 92] = "PercentToken";
+        SyntaxKind[SyntaxKind["PlusPlusToken"] = 93] = "PlusPlusToken";
+        SyntaxKind[SyntaxKind["MinusMinusToken"] = 94] = "MinusMinusToken";
+        SyntaxKind[SyntaxKind["LessThanLessThanToken"] = 95] = "LessThanLessThanToken";
+        SyntaxKind[SyntaxKind["GreaterThanGreaterThanToken"] = 96] = "GreaterThanGreaterThanToken";
+        SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanToken"] = 97] = "GreaterThanGreaterThanGreaterThanToken";
+        SyntaxKind[SyntaxKind["AmpersandToken"] = 98] = "AmpersandToken";
+        SyntaxKind[SyntaxKind["BarToken"] = 99] = "BarToken";
+        SyntaxKind[SyntaxKind["CaretToken"] = 100] = "CaretToken";
+        SyntaxKind[SyntaxKind["ExclamationToken"] = 101] = "ExclamationToken";
+        SyntaxKind[SyntaxKind["TildeToken"] = 102] = "TildeToken";
+        SyntaxKind[SyntaxKind["AmpersandAmpersandToken"] = 103] = "AmpersandAmpersandToken";
+        SyntaxKind[SyntaxKind["BarBarToken"] = 104] = "BarBarToken";
+        SyntaxKind[SyntaxKind["QuestionToken"] = 105] = "QuestionToken";
+        SyntaxKind[SyntaxKind["ColonToken"] = 106] = "ColonToken";
+        SyntaxKind[SyntaxKind["EqualsToken"] = 107] = "EqualsToken";
+        SyntaxKind[SyntaxKind["PlusEqualsToken"] = 108] = "PlusEqualsToken";
+        SyntaxKind[SyntaxKind["MinusEqualsToken"] = 109] = "MinusEqualsToken";
+        SyntaxKind[SyntaxKind["AsteriskEqualsToken"] = 110] = "AsteriskEqualsToken";
+        SyntaxKind[SyntaxKind["PercentEqualsToken"] = 111] = "PercentEqualsToken";
+        SyntaxKind[SyntaxKind["LessThanLessThanEqualsToken"] = 112] = "LessThanLessThanEqualsToken";
+        SyntaxKind[SyntaxKind["GreaterThanGreaterThanEqualsToken"] = 113] = "GreaterThanGreaterThanEqualsToken";
+        SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanEqualsToken"] = 114] = "GreaterThanGreaterThanGreaterThanEqualsToken";
+        SyntaxKind[SyntaxKind["AmpersandEqualsToken"] = 115] = "AmpersandEqualsToken";
+        SyntaxKind[SyntaxKind["BarEqualsToken"] = 116] = "BarEqualsToken";
+        SyntaxKind[SyntaxKind["CaretEqualsToken"] = 117] = "CaretEqualsToken";
+        SyntaxKind[SyntaxKind["SlashToken"] = 118] = "SlashToken";
+        SyntaxKind[SyntaxKind["SlashEqualsToken"] = 119] = "SlashEqualsToken";
+
+        SyntaxKind[SyntaxKind["SourceUnit"] = 120] = "SourceUnit";
+
+        SyntaxKind[SyntaxKind["QualifiedName"] = 121] = "QualifiedName";
+
+        SyntaxKind[SyntaxKind["ObjectType"] = 122] = "ObjectType";
+        SyntaxKind[SyntaxKind["FunctionType"] = 123] = "FunctionType";
+        SyntaxKind[SyntaxKind["ArrayType"] = 124] = "ArrayType";
+        SyntaxKind[SyntaxKind["ConstructorType"] = 125] = "ConstructorType";
+        SyntaxKind[SyntaxKind["GenericType"] = 126] = "GenericType";
+        SyntaxKind[SyntaxKind["TypeQuery"] = 127] = "TypeQuery";
+
+        SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 128] = "InterfaceDeclaration";
+        SyntaxKind[SyntaxKind["FunctionDeclaration"] = 129] = "FunctionDeclaration";
+        SyntaxKind[SyntaxKind["ModuleDeclaration"] = 130] = "ModuleDeclaration";
+        SyntaxKind[SyntaxKind["ClassDeclaration"] = 131] = "ClassDeclaration";
+        SyntaxKind[SyntaxKind["EnumDeclaration"] = 132] = "EnumDeclaration";
+        SyntaxKind[SyntaxKind["ImportDeclaration"] = 133] = "ImportDeclaration";
+        SyntaxKind[SyntaxKind["ExportAssignment"] = 134] = "ExportAssignment";
+
+        SyntaxKind[SyntaxKind["MemberFunctionDeclaration"] = 135] = "MemberFunctionDeclaration";
+        SyntaxKind[SyntaxKind["MemberVariableDeclaration"] = 136] = "MemberVariableDeclaration";
+        SyntaxKind[SyntaxKind["ConstructorDeclaration"] = 137] = "ConstructorDeclaration";
+        SyntaxKind[SyntaxKind["IndexMemberDeclaration"] = 138] = "IndexMemberDeclaration";
+
+        SyntaxKind[SyntaxKind["GetAccessor"] = 139] = "GetAccessor";
+        SyntaxKind[SyntaxKind["SetAccessor"] = 140] = "SetAccessor";
+
+        SyntaxKind[SyntaxKind["PropertySignature"] = 141] = "PropertySignature";
+        SyntaxKind[SyntaxKind["CallSignature"] = 142] = "CallSignature";
+        SyntaxKind[SyntaxKind["ConstructSignature"] = 143] = "ConstructSignature";
+        SyntaxKind[SyntaxKind["IndexSignature"] = 144] = "IndexSignature";
+        SyntaxKind[SyntaxKind["MethodSignature"] = 145] = "MethodSignature";
+
+        SyntaxKind[SyntaxKind["Block"] = 146] = "Block";
+        SyntaxKind[SyntaxKind["IfStatement"] = 147] = "IfStatement";
+        SyntaxKind[SyntaxKind["VariableStatement"] = 148] = "VariableStatement";
+        SyntaxKind[SyntaxKind["ExpressionStatement"] = 149] = "ExpressionStatement";
+        SyntaxKind[SyntaxKind["ReturnStatement"] = 150] = "ReturnStatement";
+        SyntaxKind[SyntaxKind["SwitchStatement"] = 151] = "SwitchStatement";
+        SyntaxKind[SyntaxKind["BreakStatement"] = 152] = "BreakStatement";
+        SyntaxKind[SyntaxKind["ContinueStatement"] = 153] = "ContinueStatement";
+        SyntaxKind[SyntaxKind["ForStatement"] = 154] = "ForStatement";
+        SyntaxKind[SyntaxKind["ForInStatement"] = 155] = "ForInStatement";
+        SyntaxKind[SyntaxKind["EmptyStatement"] = 156] = "EmptyStatement";
+        SyntaxKind[SyntaxKind["ThrowStatement"] = 157] = "ThrowStatement";
+        SyntaxKind[SyntaxKind["WhileStatement"] = 158] = "WhileStatement";
+        SyntaxKind[SyntaxKind["TryStatement"] = 159] = "TryStatement";
+        SyntaxKind[SyntaxKind["LabeledStatement"] = 160] = "LabeledStatement";
+        SyntaxKind[SyntaxKind["DoStatement"] = 161] = "DoStatement";
+        SyntaxKind[SyntaxKind["DebuggerStatement"] = 162] = "DebuggerStatement";
+        SyntaxKind[SyntaxKind["WithStatement"] = 163] = "WithStatement";
+
+        SyntaxKind[SyntaxKind["PlusExpression"] = 164] = "PlusExpression";
+        SyntaxKind[SyntaxKind["NegateExpression"] = 165] = "NegateExpression";
+        SyntaxKind[SyntaxKind["BitwiseNotExpression"] = 166] = "BitwiseNotExpression";
+        SyntaxKind[SyntaxKind["LogicalNotExpression"] = 167] = "LogicalNotExpression";
+        SyntaxKind[SyntaxKind["PreIncrementExpression"] = 168] = "PreIncrementExpression";
+        SyntaxKind[SyntaxKind["PreDecrementExpression"] = 169] = "PreDecrementExpression";
+        SyntaxKind[SyntaxKind["DeleteExpression"] = 170] = "DeleteExpression";
+        SyntaxKind[SyntaxKind["TypeOfExpression"] = 171] = "TypeOfExpression";
+        SyntaxKind[SyntaxKind["VoidExpression"] = 172] = "VoidExpression";
+        SyntaxKind[SyntaxKind["CommaExpression"] = 173] = "CommaExpression";
+        SyntaxKind[SyntaxKind["AssignmentExpression"] = 174] = "AssignmentExpression";
+        SyntaxKind[SyntaxKind["AddAssignmentExpression"] = 175] = "AddAssignmentExpression";
+        SyntaxKind[SyntaxKind["SubtractAssignmentExpression"] = 176] = "SubtractAssignmentExpression";
+        SyntaxKind[SyntaxKind["MultiplyAssignmentExpression"] = 177] = "MultiplyAssignmentExpression";
+        SyntaxKind[SyntaxKind["DivideAssignmentExpression"] = 178] = "DivideAssignmentExpression";
+        SyntaxKind[SyntaxKind["ModuloAssignmentExpression"] = 179] = "ModuloAssignmentExpression";
+        SyntaxKind[SyntaxKind["AndAssignmentExpression"] = 180] = "AndAssignmentExpression";
+        SyntaxKind[SyntaxKind["ExclusiveOrAssignmentExpression"] = 181] = "ExclusiveOrAssignmentExpression";
+        SyntaxKind[SyntaxKind["OrAssignmentExpression"] = 182] = "OrAssignmentExpression";
+        SyntaxKind[SyntaxKind["LeftShiftAssignmentExpression"] = 183] = "LeftShiftAssignmentExpression";
+        SyntaxKind[SyntaxKind["SignedRightShiftAssignmentExpression"] = 184] = "SignedRightShiftAssignmentExpression";
+        SyntaxKind[SyntaxKind["UnsignedRightShiftAssignmentExpression"] = 185] = "UnsignedRightShiftAssignmentExpression";
+        SyntaxKind[SyntaxKind["ConditionalExpression"] = 186] = "ConditionalExpression";
+        SyntaxKind[SyntaxKind["LogicalOrExpression"] = 187] = "LogicalOrExpression";
+        SyntaxKind[SyntaxKind["LogicalAndExpression"] = 188] = "LogicalAndExpression";
+        SyntaxKind[SyntaxKind["BitwiseOrExpression"] = 189] = "BitwiseOrExpression";
+        SyntaxKind[SyntaxKind["BitwiseExclusiveOrExpression"] = 190] = "BitwiseExclusiveOrExpression";
+        SyntaxKind[SyntaxKind["BitwiseAndExpression"] = 191] = "BitwiseAndExpression";
+        SyntaxKind[SyntaxKind["EqualsWithTypeConversionExpression"] = 192] = "EqualsWithTypeConversionExpression";
+        SyntaxKind[SyntaxKind["NotEqualsWithTypeConversionExpression"] = 193] = "NotEqualsWithTypeConversionExpression";
+        SyntaxKind[SyntaxKind["EqualsExpression"] = 194] = "EqualsExpression";
+        SyntaxKind[SyntaxKind["NotEqualsExpression"] = 195] = "NotEqualsExpression";
+        SyntaxKind[SyntaxKind["LessThanExpression"] = 196] = "LessThanExpression";
+        SyntaxKind[SyntaxKind["GreaterThanExpression"] = 197] = "GreaterThanExpression";
+        SyntaxKind[SyntaxKind["LessThanOrEqualExpression"] = 198] = "LessThanOrEqualExpression";
+        SyntaxKind[SyntaxKind["GreaterThanOrEqualExpression"] = 199] = "GreaterThanOrEqualExpression";
+        SyntaxKind[SyntaxKind["InstanceOfExpression"] = 200] = "InstanceOfExpression";
+        SyntaxKind[SyntaxKind["InExpression"] = 201] = "InExpression";
+        SyntaxKind[SyntaxKind["LeftShiftExpression"] = 202] = "LeftShiftExpression";
+        SyntaxKind[SyntaxKind["SignedRightShiftExpression"] = 203] = "SignedRightShiftExpression";
+        SyntaxKind[SyntaxKind["UnsignedRightShiftExpression"] = 204] = "UnsignedRightShiftExpression";
+        SyntaxKind[SyntaxKind["MultiplyExpression"] = 205] = "MultiplyExpression";
+        SyntaxKind[SyntaxKind["DivideExpression"] = 206] = "DivideExpression";
+        SyntaxKind[SyntaxKind["ModuloExpression"] = 207] = "ModuloExpression";
+        SyntaxKind[SyntaxKind["AddExpression"] = 208] = "AddExpression";
+        SyntaxKind[SyntaxKind["SubtractExpression"] = 209] = "SubtractExpression";
+        SyntaxKind[SyntaxKind["PostIncrementExpression"] = 210] = "PostIncrementExpression";
+        SyntaxKind[SyntaxKind["PostDecrementExpression"] = 211] = "PostDecrementExpression";
+        SyntaxKind[SyntaxKind["MemberAccessExpression"] = 212] = "MemberAccessExpression";
+        SyntaxKind[SyntaxKind["InvocationExpression"] = 213] = "InvocationExpression";
+        SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 214] = "ArrayLiteralExpression";
+        SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 215] = "ObjectLiteralExpression";
+        SyntaxKind[SyntaxKind["ObjectCreationExpression"] = 216] = "ObjectCreationExpression";
+        SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 217] = "ParenthesizedExpression";
+        SyntaxKind[SyntaxKind["ParenthesizedArrowFunctionExpression"] = 218] = "ParenthesizedArrowFunctionExpression";
+        SyntaxKind[SyntaxKind["SimpleArrowFunctionExpression"] = 219] = "SimpleArrowFunctionExpression";
+        SyntaxKind[SyntaxKind["CastExpression"] = 220] = "CastExpression";
+        SyntaxKind[SyntaxKind["ElementAccessExpression"] = 221] = "ElementAccessExpression";
+        SyntaxKind[SyntaxKind["FunctionExpression"] = 222] = "FunctionExpression";
+        SyntaxKind[SyntaxKind["OmittedExpression"] = 223] = "OmittedExpression";
+
+        SyntaxKind[SyntaxKind["VariableDeclaration"] = 224] = "VariableDeclaration";
+        SyntaxKind[SyntaxKind["VariableDeclarator"] = 225] = "VariableDeclarator";
+
+        SyntaxKind[SyntaxKind["ArgumentList"] = 226] = "ArgumentList";
+        SyntaxKind[SyntaxKind["ParameterList"] = 227] = "ParameterList";
+        SyntaxKind[SyntaxKind["TypeArgumentList"] = 228] = "TypeArgumentList";
+        SyntaxKind[SyntaxKind["TypeParameterList"] = 229] = "TypeParameterList";
+
+        SyntaxKind[SyntaxKind["ExtendsHeritageClause"] = 230] = "ExtendsHeritageClause";
+        SyntaxKind[SyntaxKind["ImplementsHeritageClause"] = 231] = "ImplementsHeritageClause";
+        SyntaxKind[SyntaxKind["EqualsValueClause"] = 232] = "EqualsValueClause";
+        SyntaxKind[SyntaxKind["CaseSwitchClause"] = 233] = "CaseSwitchClause";
+        SyntaxKind[SyntaxKind["DefaultSwitchClause"] = 234] = "DefaultSwitchClause";
+        SyntaxKind[SyntaxKind["ElseClause"] = 235] = "ElseClause";
+        SyntaxKind[SyntaxKind["CatchClause"] = 236] = "CatchClause";
+        SyntaxKind[SyntaxKind["FinallyClause"] = 237] = "FinallyClause";
+
+        SyntaxKind[SyntaxKind["TypeParameter"] = 238] = "TypeParameter";
+        SyntaxKind[SyntaxKind["Constraint"] = 239] = "Constraint";
+
+        SyntaxKind[SyntaxKind["SimplePropertyAssignment"] = 240] = "SimplePropertyAssignment";
+
+        SyntaxKind[SyntaxKind["FunctionPropertyAssignment"] = 241] = "FunctionPropertyAssignment";
+
+        SyntaxKind[SyntaxKind["Parameter"] = 242] = "Parameter";
+        SyntaxKind[SyntaxKind["EnumElement"] = 243] = "EnumElement";
+        SyntaxKind[SyntaxKind["TypeAnnotation"] = 244] = "TypeAnnotation";
+        SyntaxKind[SyntaxKind["ExternalModuleReference"] = 245] = "ExternalModuleReference";
+        SyntaxKind[SyntaxKind["ModuleNameModuleReference"] = 246] = "ModuleNameModuleReference";
+        SyntaxKind[SyntaxKind["Last"] = SyntaxKind.ModuleNameModuleReference] = "Last";
+
+        SyntaxKind[SyntaxKind["FirstStandardKeyword"] = SyntaxKind.BreakKeyword] = "FirstStandardKeyword";
+        SyntaxKind[SyntaxKind["LastStandardKeyword"] = SyntaxKind.WithKeyword] = "LastStandardKeyword";
+
+        SyntaxKind[SyntaxKind["FirstFutureReservedKeyword"] = SyntaxKind.ClassKeyword] = "FirstFutureReservedKeyword";
+        SyntaxKind[SyntaxKind["LastFutureReservedKeyword"] = SyntaxKind.SuperKeyword] = "LastFutureReservedKeyword";
+
+        SyntaxKind[SyntaxKind["FirstFutureReservedStrictKeyword"] = SyntaxKind.ImplementsKeyword] = "FirstFutureReservedStrictKeyword";
+        SyntaxKind[SyntaxKind["LastFutureReservedStrictKeyword"] = SyntaxKind.YieldKeyword] = "LastFutureReservedStrictKeyword";
+
+        SyntaxKind[SyntaxKind["FirstTypeScriptKeyword"] = SyntaxKind.AnyKeyword] = "FirstTypeScriptKeyword";
+        SyntaxKind[SyntaxKind["LastTypeScriptKeyword"] = SyntaxKind.StringKeyword] = "LastTypeScriptKeyword";
+
+        SyntaxKind[SyntaxKind["FirstKeyword"] = SyntaxKind.FirstStandardKeyword] = "FirstKeyword";
+        SyntaxKind[SyntaxKind["LastKeyword"] = SyntaxKind.LastTypeScriptKeyword] = "LastKeyword";
+
+        SyntaxKind[SyntaxKind["FirstToken"] = SyntaxKind.ErrorToken] = "FirstToken";
+        SyntaxKind[SyntaxKind["LastToken"] = SyntaxKind.SlashEqualsToken] = "LastToken";
+
+        SyntaxKind[SyntaxKind["FirstPunctuation"] = SyntaxKind.OpenBraceToken] = "FirstPunctuation";
+        SyntaxKind[SyntaxKind["LastPunctuation"] = SyntaxKind.SlashEqualsToken] = "LastPunctuation";
+
+        SyntaxKind[SyntaxKind["FirstFixedWidth"] = SyntaxKind.FirstKeyword] = "FirstFixedWidth";
+        SyntaxKind[SyntaxKind["LastFixedWidth"] = SyntaxKind.LastPunctuation] = "LastFixedWidth";
+
+        SyntaxKind[SyntaxKind["FirstTrivia"] = SyntaxKind.WhitespaceTrivia] = "FirstTrivia";
+        SyntaxKind[SyntaxKind["LastTrivia"] = SyntaxKind.SkippedTokenTrivia] = "LastTrivia";
+    })(TypeScript.SyntaxKind || (TypeScript.SyntaxKind = {}));
+    var SyntaxKind = TypeScript.SyntaxKind;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (SyntaxFacts) {
+        var textToKeywordKind = {
+            "any": 60 /* AnyKeyword */,
+            "boolean": 61 /* BooleanKeyword */,
+            "break": 15 /* BreakKeyword */,
+            "case": 16 /* CaseKeyword */,
+            "catch": 17 /* CatchKeyword */,
+            "class": 44 /* ClassKeyword */,
+            "continue": 18 /* ContinueKeyword */,
+            "const": 45 /* ConstKeyword */,
+            "constructor": 62 /* ConstructorKeyword */,
+            "debugger": 19 /* DebuggerKeyword */,
+            "declare": 63 /* DeclareKeyword */,
+            "default": 20 /* DefaultKeyword */,
+            "delete": 21 /* DeleteKeyword */,
+            "do": 22 /* DoKeyword */,
+            "else": 23 /* ElseKeyword */,
+            "enum": 46 /* EnumKeyword */,
+            "export": 47 /* ExportKeyword */,
+            "extends": 48 /* ExtendsKeyword */,
+            "false": 24 /* FalseKeyword */,
+            "finally": 25 /* FinallyKeyword */,
+            "for": 26 /* ForKeyword */,
+            "function": 27 /* FunctionKeyword */,
+            "get": 64 /* GetKeyword */,
+            "if": 28 /* IfKeyword */,
+            "implements": 51 /* ImplementsKeyword */,
+            "import": 49 /* ImportKeyword */,
+            "in": 29 /* InKeyword */,
+            "instanceof": 30 /* InstanceOfKeyword */,
+            "interface": 52 /* InterfaceKeyword */,
+            "let": 53 /* LetKeyword */,
+            "module": 65 /* ModuleKeyword */,
+            "new": 31 /* NewKeyword */,
+            "null": 32 /* NullKeyword */,
+            "number": 67 /* NumberKeyword */,
+            "package": 54 /* PackageKeyword */,
+            "private": 55 /* PrivateKeyword */,
+            "protected": 56 /* ProtectedKeyword */,
+            "public": 57 /* PublicKeyword */,
+            "require": 66 /* RequireKeyword */,
+            "return": 33 /* ReturnKeyword */,
+            "set": 68 /* SetKeyword */,
+            "static": 58 /* StaticKeyword */,
+            "string": 69 /* StringKeyword */,
+            "super": 50 /* SuperKeyword */,
+            "switch": 34 /* SwitchKeyword */,
+            "this": 35 /* ThisKeyword */,
+            "throw": 36 /* ThrowKeyword */,
+            "true": 37 /* TrueKeyword */,
+            "try": 38 /* TryKeyword */,
+            "typeof": 39 /* TypeOfKeyword */,
+            "var": 40 /* VarKeyword */,
+            "void": 41 /* VoidKeyword */,
+            "while": 42 /* WhileKeyword */,
+            "with": 43 /* WithKeyword */,
+            "yield": 59 /* YieldKeyword */,
+            "{": 70 /* OpenBraceToken */,
+            "}": 71 /* CloseBraceToken */,
+            "(": 72 /* OpenParenToken */,
+            ")": 73 /* CloseParenToken */,
+            "[": 74 /* OpenBracketToken */,
+            "]": 75 /* CloseBracketToken */,
+            ".": 76 /* DotToken */,
+            "...": 77 /* DotDotDotToken */,
+            ";": 78 /* SemicolonToken */,
+            ",": 79 /* CommaToken */,
+            "<": 80 /* LessThanToken */,
+            ">": 81 /* GreaterThanToken */,
+            "<=": 82 /* LessThanEqualsToken */,
+            ">=": 83 /* GreaterThanEqualsToken */,
+            "==": 84 /* EqualsEqualsToken */,
+            "=>": 85 /* EqualsGreaterThanToken */,
+            "!=": 86 /* ExclamationEqualsToken */,
+            "===": 87 /* EqualsEqualsEqualsToken */,
+            "!==": 88 /* ExclamationEqualsEqualsToken */,
+            "+": 89 /* PlusToken */,
+            "-": 90 /* MinusToken */,
+            "*": 91 /* AsteriskToken */,
+            "%": 92 /* PercentToken */,
+            "++": 93 /* PlusPlusToken */,
+            "--": 94 /* MinusMinusToken */,
+            "<<": 95 /* LessThanLessThanToken */,
+            ">>": 96 /* GreaterThanGreaterThanToken */,
+            ">>>": 97 /* GreaterThanGreaterThanGreaterThanToken */,
+            "&": 98 /* AmpersandToken */,
+            "|": 99 /* BarToken */,
+            "^": 100 /* CaretToken */,
+            "!": 101 /* ExclamationToken */,
+            "~": 102 /* TildeToken */,
+            "&&": 103 /* AmpersandAmpersandToken */,
+            "||": 104 /* BarBarToken */,
+            "?": 105 /* QuestionToken */,
+            ":": 106 /* ColonToken */,
+            "=": 107 /* EqualsToken */,
+            "+=": 108 /* PlusEqualsToken */,
+            "-=": 109 /* MinusEqualsToken */,
+            "*=": 110 /* AsteriskEqualsToken */,
+            "%=": 111 /* PercentEqualsToken */,
+            "<<=": 112 /* LessThanLessThanEqualsToken */,
+            ">>=": 113 /* GreaterThanGreaterThanEqualsToken */,
+            ">>>=": 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */,
+            "&=": 115 /* AmpersandEqualsToken */,
+            "|=": 116 /* BarEqualsToken */,
+            "^=": 117 /* CaretEqualsToken */,
+            "/": 118 /* SlashToken */,
+            "/=": 119 /* SlashEqualsToken */
+        };
+
+        var kindToText = new Array();
+
+        for (var name in textToKeywordKind) {
+            if (textToKeywordKind.hasOwnProperty(name)) {
+                kindToText[textToKeywordKind[name]] = name;
+            }
+        }
+
+        kindToText[62 /* ConstructorKeyword */] = "constructor";
+
+        function getTokenKind(text) {
+            if (textToKeywordKind.hasOwnProperty(text)) {
+                return textToKeywordKind[text];
+            }
+
+            return 0 /* None */;
+        }
+        SyntaxFacts.getTokenKind = getTokenKind;
+
+        function getText(kind) {
+            var result = kindToText[kind];
+            return result !== undefined ? result : null;
+        }
+        SyntaxFacts.getText = getText;
+
+        function isTokenKind(kind) {
+            return kind >= 9 /* FirstToken */ && kind <= 119 /* LastToken */;
+        }
+        SyntaxFacts.isTokenKind = isTokenKind;
+
+        function isAnyKeyword(kind) {
+            return kind >= 15 /* FirstKeyword */ && kind <= 69 /* LastKeyword */;
+        }
+        SyntaxFacts.isAnyKeyword = isAnyKeyword;
+
+        function isStandardKeyword(kind) {
+            return kind >= 15 /* FirstStandardKeyword */ && kind <= 43 /* LastStandardKeyword */;
+        }
+        SyntaxFacts.isStandardKeyword = isStandardKeyword;
+
+        function isFutureReservedKeyword(kind) {
+            return kind >= 44 /* FirstFutureReservedKeyword */ && kind <= 50 /* LastFutureReservedKeyword */;
+        }
+        SyntaxFacts.isFutureReservedKeyword = isFutureReservedKeyword;
+
+        function isFutureReservedStrictKeyword(kind) {
+            return kind >= 51 /* FirstFutureReservedStrictKeyword */ && kind <= 59 /* LastFutureReservedStrictKeyword */;
+        }
+        SyntaxFacts.isFutureReservedStrictKeyword = isFutureReservedStrictKeyword;
+
+        function isAnyPunctuation(kind) {
+            return kind >= 70 /* FirstPunctuation */ && kind <= 119 /* LastPunctuation */;
+        }
+        SyntaxFacts.isAnyPunctuation = isAnyPunctuation;
+
+        function isPrefixUnaryExpressionOperatorToken(tokenKind) {
+            return getPrefixUnaryExpressionFromOperatorToken(tokenKind) !== 0 /* None */;
+        }
+        SyntaxFacts.isPrefixUnaryExpressionOperatorToken = isPrefixUnaryExpressionOperatorToken;
+
+        function isBinaryExpressionOperatorToken(tokenKind) {
+            return getBinaryExpressionFromOperatorToken(tokenKind) !== 0 /* None */;
+        }
+        SyntaxFacts.isBinaryExpressionOperatorToken = isBinaryExpressionOperatorToken;
+
+        function getPrefixUnaryExpressionFromOperatorToken(tokenKind) {
+            switch (tokenKind) {
+                case 89 /* PlusToken */:
+                    return 164 /* PlusExpression */;
+                case 90 /* MinusToken */:
+                    return 165 /* NegateExpression */;
+                case 102 /* TildeToken */:
+                    return 166 /* BitwiseNotExpression */;
+                case 101 /* ExclamationToken */:
+                    return 167 /* LogicalNotExpression */;
+                case 93 /* PlusPlusToken */:
+                    return 168 /* PreIncrementExpression */;
+                case 94 /* MinusMinusToken */:
+                    return 169 /* PreDecrementExpression */;
+
+                default:
+                    return 0 /* None */;
+            }
+        }
+        SyntaxFacts.getPrefixUnaryExpressionFromOperatorToken = getPrefixUnaryExpressionFromOperatorToken;
+
+        function getPostfixUnaryExpressionFromOperatorToken(tokenKind) {
+            switch (tokenKind) {
+                case 93 /* PlusPlusToken */:
+                    return 210 /* PostIncrementExpression */;
+                case 94 /* MinusMinusToken */:
+                    return 211 /* PostDecrementExpression */;
+                default:
+                    return 0 /* None */;
+            }
+        }
+        SyntaxFacts.getPostfixUnaryExpressionFromOperatorToken = getPostfixUnaryExpressionFromOperatorToken;
+
+        function getBinaryExpressionFromOperatorToken(tokenKind) {
+            switch (tokenKind) {
+                case 91 /* AsteriskToken */:
+                    return 205 /* MultiplyExpression */;
+
+                case 118 /* SlashToken */:
+                    return 206 /* DivideExpression */;
+
+                case 92 /* PercentToken */:
+                    return 207 /* ModuloExpression */;
+
+                case 89 /* PlusToken */:
+                    return 208 /* AddExpression */;
+
+                case 90 /* MinusToken */:
+                    return 209 /* SubtractExpression */;
+
+                case 95 /* LessThanLessThanToken */:
+                    return 202 /* LeftShiftExpression */;
+
+                case 96 /* GreaterThanGreaterThanToken */:
+                    return 203 /* SignedRightShiftExpression */;
+
+                case 97 /* GreaterThanGreaterThanGreaterThanToken */:
+                    return 204 /* UnsignedRightShiftExpression */;
+
+                case 80 /* LessThanToken */:
+                    return 196 /* LessThanExpression */;
+
+                case 81 /* GreaterThanToken */:
+                    return 197 /* GreaterThanExpression */;
+
+                case 82 /* LessThanEqualsToken */:
+                    return 198 /* LessThanOrEqualExpression */;
+
+                case 83 /* GreaterThanEqualsToken */:
+                    return 199 /* GreaterThanOrEqualExpression */;
+
+                case 30 /* InstanceOfKeyword */:
+                    return 200 /* InstanceOfExpression */;
+
+                case 29 /* InKeyword */:
+                    return 201 /* InExpression */;
+
+                case 84 /* EqualsEqualsToken */:
+                    return 192 /* EqualsWithTypeConversionExpression */;
+
+                case 86 /* ExclamationEqualsToken */:
+                    return 193 /* NotEqualsWithTypeConversionExpression */;
+
+                case 87 /* EqualsEqualsEqualsToken */:
+                    return 194 /* EqualsExpression */;
+
+                case 88 /* ExclamationEqualsEqualsToken */:
+                    return 195 /* NotEqualsExpression */;
+
+                case 98 /* AmpersandToken */:
+                    return 191 /* BitwiseAndExpression */;
+
+                case 100 /* CaretToken */:
+                    return 190 /* BitwiseExclusiveOrExpression */;
+
+                case 99 /* BarToken */:
+                    return 189 /* BitwiseOrExpression */;
+
+                case 103 /* AmpersandAmpersandToken */:
+                    return 188 /* LogicalAndExpression */;
+
+                case 104 /* BarBarToken */:
+                    return 187 /* LogicalOrExpression */;
+
+                case 116 /* BarEqualsToken */:
+                    return 182 /* OrAssignmentExpression */;
+
+                case 115 /* AmpersandEqualsToken */:
+                    return 180 /* AndAssignmentExpression */;
+
+                case 117 /* CaretEqualsToken */:
+                    return 181 /* ExclusiveOrAssignmentExpression */;
+
+                case 112 /* LessThanLessThanEqualsToken */:
+                    return 183 /* LeftShiftAssignmentExpression */;
+
+                case 113 /* GreaterThanGreaterThanEqualsToken */:
+                    return 184 /* SignedRightShiftAssignmentExpression */;
+
+                case 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
+                    return 185 /* UnsignedRightShiftAssignmentExpression */;
+
+                case 108 /* PlusEqualsToken */:
+                    return 175 /* AddAssignmentExpression */;
+
+                case 109 /* MinusEqualsToken */:
+                    return 176 /* SubtractAssignmentExpression */;
+
+                case 110 /* AsteriskEqualsToken */:
+                    return 177 /* MultiplyAssignmentExpression */;
+
+                case 119 /* SlashEqualsToken */:
+                    return 178 /* DivideAssignmentExpression */;
+
+                case 111 /* PercentEqualsToken */:
+                    return 179 /* ModuloAssignmentExpression */;
+
+                case 107 /* EqualsToken */:
+                    return 174 /* AssignmentExpression */;
+
+                case 79 /* CommaToken */:
+                    return 173 /* CommaExpression */;
+
+                default:
+                    return 0 /* None */;
+            }
+        }
+        SyntaxFacts.getBinaryExpressionFromOperatorToken = getBinaryExpressionFromOperatorToken;
+
+        function getOperatorTokenFromBinaryExpression(tokenKind) {
+            switch (tokenKind) {
+                case 205 /* MultiplyExpression */:
+                    return 91 /* AsteriskToken */;
+
+                case 206 /* DivideExpression */:
+                    return 118 /* SlashToken */;
+
+                case 207 /* ModuloExpression */:
+                    return 92 /* PercentToken */;
+
+                case 208 /* AddExpression */:
+                    return 89 /* PlusToken */;
+
+                case 209 /* SubtractExpression */:
+                    return 90 /* MinusToken */;
+
+                case 202 /* LeftShiftExpression */:
+                    return 95 /* LessThanLessThanToken */;
+
+                case 203 /* SignedRightShiftExpression */:
+                    return 96 /* GreaterThanGreaterThanToken */;
+
+                case 204 /* UnsignedRightShiftExpression */:
+                    return 97 /* GreaterThanGreaterThanGreaterThanToken */;
+
+                case 196 /* LessThanExpression */:
+                    return 80 /* LessThanToken */;
+
+                case 197 /* GreaterThanExpression */:
+                    return 81 /* GreaterThanToken */;
+
+                case 198 /* LessThanOrEqualExpression */:
+                    return 82 /* LessThanEqualsToken */;
+
+                case 199 /* GreaterThanOrEqualExpression */:
+                    return 83 /* GreaterThanEqualsToken */;
+
+                case 200 /* InstanceOfExpression */:
+                    return 30 /* InstanceOfKeyword */;
+
+                case 201 /* InExpression */:
+                    return 29 /* InKeyword */;
+
+                case 192 /* EqualsWithTypeConversionExpression */:
+                    return 84 /* EqualsEqualsToken */;
+
+                case 193 /* NotEqualsWithTypeConversionExpression */:
+                    return 86 /* ExclamationEqualsToken */;
+
+                case 194 /* EqualsExpression */:
+                    return 87 /* EqualsEqualsEqualsToken */;
+
+                case 195 /* NotEqualsExpression */:
+                    return 88 /* ExclamationEqualsEqualsToken */;
+
+                case 191 /* BitwiseAndExpression */:
+                    return 98 /* AmpersandToken */;
+
+                case 190 /* BitwiseExclusiveOrExpression */:
+                    return 100 /* CaretToken */;
+
+                case 189 /* BitwiseOrExpression */:
+                    return 99 /* BarToken */;
+
+                case 188 /* LogicalAndExpression */:
+                    return 103 /* AmpersandAmpersandToken */;
+
+                case 187 /* LogicalOrExpression */:
+                    return 104 /* BarBarToken */;
+
+                case 182 /* OrAssignmentExpression */:
+                    return 116 /* BarEqualsToken */;
+
+                case 180 /* AndAssignmentExpression */:
+                    return 115 /* AmpersandEqualsToken */;
+
+                case 181 /* ExclusiveOrAssignmentExpression */:
+                    return 117 /* CaretEqualsToken */;
+
+                case 183 /* LeftShiftAssignmentExpression */:
+                    return 112 /* LessThanLessThanEqualsToken */;
+
+                case 184 /* SignedRightShiftAssignmentExpression */:
+                    return 113 /* GreaterThanGreaterThanEqualsToken */;
+
+                case 185 /* UnsignedRightShiftAssignmentExpression */:
+                    return 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */;
+
+                case 175 /* AddAssignmentExpression */:
+                    return 108 /* PlusEqualsToken */;
+
+                case 176 /* SubtractAssignmentExpression */:
+                    return 109 /* MinusEqualsToken */;
+
+                case 177 /* MultiplyAssignmentExpression */:
+                    return 110 /* AsteriskEqualsToken */;
+
+                case 178 /* DivideAssignmentExpression */:
+                    return 119 /* SlashEqualsToken */;
+
+                case 179 /* ModuloAssignmentExpression */:
+                    return 111 /* PercentEqualsToken */;
+
+                case 174 /* AssignmentExpression */:
+                    return 107 /* EqualsToken */;
+
+                case 173 /* CommaExpression */:
+                    return 79 /* CommaToken */;
+
+                default:
+                    return 0 /* None */;
+            }
+        }
+        SyntaxFacts.getOperatorTokenFromBinaryExpression = getOperatorTokenFromBinaryExpression;
+
+        function isAnyDivideToken(kind) {
+            switch (kind) {
+                case 118 /* SlashToken */:
+                case 119 /* SlashEqualsToken */:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        SyntaxFacts.isAnyDivideToken = isAnyDivideToken;
+
+        function isAnyDivideOrRegularExpressionToken(kind) {
+            switch (kind) {
+                case 118 /* SlashToken */:
+                case 119 /* SlashEqualsToken */:
+                case 12 /* RegularExpressionLiteral */:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        SyntaxFacts.isAnyDivideOrRegularExpressionToken = isAnyDivideOrRegularExpressionToken;
+    })(TypeScript.SyntaxFacts || (TypeScript.SyntaxFacts = {}));
+    var SyntaxFacts = TypeScript.SyntaxFacts;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var isKeywordStartCharacter = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false);
+    var isIdentifierStartCharacter = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false);
+    var isIdentifierPartCharacter = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false);
+    var isNumericLiteralStart = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false);
+
+    for (var character = 0; character < 127 /* maxAsciiCharacter */; character++) {
+        if (character >= 97 /* a */ && character <= 122 /* z */) {
+            isIdentifierStartCharacter[character] = true;
+            isIdentifierPartCharacter[character] = true;
+        } else if ((character >= 65 /* A */ && character <= 90 /* Z */) || character === 95 /* _ */ || character === 36 /* $ */) {
+            isIdentifierStartCharacter[character] = true;
+            isIdentifierPartCharacter[character] = true;
+        } else if (character >= 48 /* _0 */ && character <= 57 /* _9 */) {
+            isIdentifierPartCharacter[character] = true;
+            isNumericLiteralStart[character] = true;
+        }
+    }
+
+    isNumericLiteralStart[46 /* dot */] = true;
+
+    for (var keywordKind = 15 /* FirstKeyword */; keywordKind <= 69 /* LastKeyword */; keywordKind++) {
+        var keyword = TypeScript.SyntaxFacts.getText(keywordKind);
+        isKeywordStartCharacter[keyword.charCodeAt(0)] = true;
+    }
+
+    var Scanner = (function () {
+        function Scanner(fileName, text, languageVersion, window) {
+            if (typeof window === "undefined") { window = TypeScript.ArrayUtilities.createArray(2048, 0); }
+            this.slidingWindow = new TypeScript.SlidingWindow(this, window, 0, text.length());
+            this.fileName = fileName;
+            this.text = text;
+            this._languageVersion = languageVersion;
+        }
+        Scanner.prototype.languageVersion = function () {
+            return this._languageVersion;
+        };
+
+        Scanner.prototype.fetchMoreItems = function (argument, sourceIndex, window, destinationIndex, spaceAvailable) {
+            var charactersRemaining = this.text.length() - sourceIndex;
+            var amountToRead = TypeScript.MathPrototype.min(charactersRemaining, spaceAvailable);
+            this.text.copyTo(sourceIndex, window, destinationIndex, amountToRead);
+            return amountToRead;
+        };
+
+        Scanner.prototype.currentCharCode = function () {
+            return this.slidingWindow.currentItem(null);
+        };
+
+        Scanner.prototype.absoluteIndex = function () {
+            return this.slidingWindow.absoluteIndex();
+        };
+
+        Scanner.prototype.setAbsoluteIndex = function (index) {
+            this.slidingWindow.setAbsoluteIndex(index);
+        };
+
+        Scanner.prototype.scan = function (diagnostics, allowRegularExpression) {
+            var diagnosticsLength = diagnostics.length;
+            var fullStart = this.slidingWindow.absoluteIndex();
+            var leadingTriviaInfo = this.scanTriviaInfo(diagnostics, false);
+
+            var start = this.slidingWindow.absoluteIndex();
+            var kindAndFlags = this.scanSyntaxToken(diagnostics, allowRegularExpression);
+            var end = this.slidingWindow.absoluteIndex();
+
+            var trailingTriviaInfo = this.scanTriviaInfo(diagnostics, true);
+            var fullEnd = this.slidingWindow.absoluteIndex();
+
+            var isVariableWidthKeyword = (kindAndFlags & -2147483648 /* IsVariableWidthKeyword */) !== 0;
+            var kind = kindAndFlags & ~-2147483648 /* IsVariableWidthKeyword */;
+
+            var token = this.createToken(fullStart, leadingTriviaInfo, start, kind, end, fullEnd, trailingTriviaInfo, isVariableWidthKeyword);
+
+            return diagnosticsLength !== diagnostics.length ? TypeScript.Syntax.realizeToken(token) : token;
+        };
+
+        Scanner.prototype.createToken = function (fullStart, leadingTriviaInfo, start, kind, end, fullEnd, trailingTriviaInfo, isVariableWidthKeyword) {
+            if (!isVariableWidthKeyword && kind >= 15 /* FirstFixedWidth */) {
+                if (leadingTriviaInfo === 0) {
+                    if (trailingTriviaInfo === 0) {
+                        return new TypeScript.Syntax.FixedWidthTokenWithNoTrivia(kind);
+                    } else {
+                        var fullText = this.text.substr(fullStart, fullEnd - fullStart, false);
+                        return new TypeScript.Syntax.FixedWidthTokenWithTrailingTrivia(fullText, kind, trailingTriviaInfo);
+                    }
+                } else if (trailingTriviaInfo === 0) {
+                    var fullText = this.text.substr(fullStart, fullEnd - fullStart, false);
+                    return new TypeScript.Syntax.FixedWidthTokenWithLeadingTrivia(fullText, kind, leadingTriviaInfo);
+                } else {
+                    var fullText = this.text.substr(fullStart, fullEnd - fullStart, false);
+                    return new TypeScript.Syntax.FixedWidthTokenWithLeadingAndTrailingTrivia(fullText, kind, leadingTriviaInfo, trailingTriviaInfo);
+                }
+            } else {
+                var width = end - start;
+
+                var fullText = this.text.substr(fullStart, fullEnd - fullStart, false);
+
+                if (leadingTriviaInfo === 0) {
+                    if (trailingTriviaInfo === 0) {
+                        return new TypeScript.Syntax.VariableWidthTokenWithNoTrivia(fullText, kind);
+                    } else {
+                        return new TypeScript.Syntax.VariableWidthTokenWithTrailingTrivia(fullText, kind, trailingTriviaInfo);
+                    }
+                } else if (trailingTriviaInfo === 0) {
+                    return new TypeScript.Syntax.VariableWidthTokenWithLeadingTrivia(fullText, kind, leadingTriviaInfo);
+                } else {
+                    return new TypeScript.Syntax.VariableWidthTokenWithLeadingAndTrailingTrivia(fullText, kind, leadingTriviaInfo, trailingTriviaInfo);
+                }
+            }
+        };
+
+        Scanner.scanTrivia = function (text, start, length, isTrailing) {
+            var scanner = new Scanner(null, text.subText(new TypeScript.TextSpan(start, length)), 1 /* EcmaScript5 */, Scanner.triviaWindow);
+            return scanner.scanTrivia(text, start, isTrailing);
+        };
+
+        Scanner.prototype.scanTrivia = function (underlyingText, underlyingTextStart, isTrailing) {
+            var trivia = new Array();
+
+            while (true) {
+                if (!this.slidingWindow.isAtEndOfSource()) {
+                    var ch = this.currentCharCode();
+
+                    switch (ch) {
+                        case 32 /* space */:
+                        case 160 /* nonBreakingSpace */:
+                        case 8192 /* enQuad */:
+                        case 8193 /* emQuad */:
+                        case 8194 /* enSpace */:
+                        case 8195 /* emSpace */:
+                        case 8196 /* threePerEmSpace */:
+                        case 8197 /* fourPerEmSpace */:
+                        case 8198 /* sixPerEmSpace */:
+                        case 8199 /* figureSpace */:
+                        case 8200 /* punctuationSpace */:
+                        case 8201 /* thinSpace */:
+                        case 8202 /* hairSpace */:
+                        case 8203 /* zeroWidthSpace */:
+                        case 8239 /* narrowNoBreakSpace */:
+                        case 12288 /* ideographicSpace */:
+
+                        case 9 /* tab */:
+                        case 11 /* verticalTab */:
+                        case 12 /* formFeed */:
+                        case 65279 /* byteOrderMark */:
+                            trivia.push(this.scanWhitespaceTrivia(underlyingText, underlyingTextStart));
+                            continue;
+
+                        case 47 /* slash */:
+                            var ch2 = this.slidingWindow.peekItemN(1);
+                            if (ch2 === 47 /* slash */) {
+                                trivia.push(this.scanSingleLineCommentTrivia(underlyingText, underlyingTextStart));
+                                continue;
+                            }
+
+                            if (ch2 === 42 /* asterisk */) {
+                                trivia.push(this.scanMultiLineCommentTrivia(underlyingText, underlyingTextStart));
+                                continue;
+                            }
+
+                            throw TypeScript.Errors.invalidOperation();
+
+                        case 13 /* carriageReturn */:
+                        case 10 /* lineFeed */:
+                        case 8233 /* paragraphSeparator */:
+                        case 8232 /* lineSeparator */:
+                            trivia.push(this.scanLineTerminatorSequenceTrivia(ch));
+
+                            if (!isTrailing) {
+                                continue;
+                            }
+
+                            break;
+
+                        default:
+                            throw TypeScript.Errors.invalidOperation();
+                    }
+                }
+
+                return TypeScript.Syntax.triviaList(trivia);
+            }
+        };
+
+        Scanner.prototype.scanTriviaInfo = function (diagnostics, isTrailing) {
+            var width = 0;
+            var hasCommentOrNewLine = 0;
+
+            while (true) {
+                var ch = this.currentCharCode();
+
+                switch (ch) {
+                    case 32 /* space */:
+                    case 160 /* nonBreakingSpace */:
+                    case 8192 /* enQuad */:
+                    case 8193 /* emQuad */:
+                    case 8194 /* enSpace */:
+                    case 8195 /* emSpace */:
+                    case 8196 /* threePerEmSpace */:
+                    case 8197 /* fourPerEmSpace */:
+                    case 8198 /* sixPerEmSpace */:
+                    case 8199 /* figureSpace */:
+                    case 8200 /* punctuationSpace */:
+                    case 8201 /* thinSpace */:
+                    case 8202 /* hairSpace */:
+                    case 8203 /* zeroWidthSpace */:
+                    case 8239 /* narrowNoBreakSpace */:
+                    case 12288 /* ideographicSpace */:
+
+                    case 9 /* tab */:
+                    case 11 /* verticalTab */:
+                    case 12 /* formFeed */:
+                    case 65279 /* byteOrderMark */:
+                        this.slidingWindow.moveToNextItem();
+                        width++;
+                        continue;
+
+                    case 47 /* slash */:
+                        var ch2 = this.slidingWindow.peekItemN(1);
+                        if (ch2 === 47 /* slash */) {
+                            hasCommentOrNewLine |= 2 /* TriviaCommentMask */;
+                            width += this.scanSingleLineCommentTriviaLength();
+                            continue;
+                        }
+
+                        if (ch2 === 42 /* asterisk */) {
+                            hasCommentOrNewLine |= 2 /* TriviaCommentMask */;
+                            width += this.scanMultiLineCommentTriviaLength(diagnostics);
+                            continue;
+                        }
+
+                        break;
+
+                    case 13 /* carriageReturn */:
+                    case 10 /* lineFeed */:
+                    case 8233 /* paragraphSeparator */:
+                    case 8232 /* lineSeparator */:
+                        hasCommentOrNewLine |= 1 /* TriviaNewLineMask */;
+                        width += this.scanLineTerminatorSequenceLength(ch);
+
+                        if (!isTrailing) {
+                            continue;
+                        }
+
+                        break;
+                }
+
+                return (width << 2 /* TriviaFullWidthShift */) | hasCommentOrNewLine;
+            }
+        };
+
+        Scanner.prototype.isNewLineCharacter = function (ch) {
+            switch (ch) {
+                case 13 /* carriageReturn */:
+                case 10 /* lineFeed */:
+                case 8233 /* paragraphSeparator */:
+                case 8232 /* lineSeparator */:
+                    return true;
+                default:
+                    return false;
+            }
+        };
+
+        Scanner.prototype.scanWhitespaceTrivia = function (underlyingText, underlyingTextStart) {
+            var absoluteStartIndex = this.absoluteIndex();
+
+            var width = 0;
+            while (true) {
+                var ch = this.currentCharCode();
+
+                switch (ch) {
+                    case 32 /* space */:
+                    case 160 /* nonBreakingSpace */:
+                    case 8192 /* enQuad */:
+                    case 8193 /* emQuad */:
+                    case 8194 /* enSpace */:
+                    case 8195 /* emSpace */:
+                    case 8196 /* threePerEmSpace */:
+                    case 8197 /* fourPerEmSpace */:
+                    case 8198 /* sixPerEmSpace */:
+                    case 8199 /* figureSpace */:
+                    case 8200 /* punctuationSpace */:
+                    case 8201 /* thinSpace */:
+                    case 8202 /* hairSpace */:
+                    case 8203 /* zeroWidthSpace */:
+                    case 8239 /* narrowNoBreakSpace */:
+                    case 12288 /* ideographicSpace */:
+
+                    case 9 /* tab */:
+                    case 11 /* verticalTab */:
+                    case 12 /* formFeed */:
+                    case 65279 /* byteOrderMark */:
+                        this.slidingWindow.moveToNextItem();
+                        width++;
+                        continue;
+                }
+
+                break;
+            }
+
+            return TypeScript.Syntax.deferredTrivia(4 /* WhitespaceTrivia */, underlyingText, underlyingTextStart + absoluteStartIndex, width);
+        };
+
+        Scanner.prototype.scanSingleLineCommentTrivia = function (underlyingText, underlyingTextStart) {
+            var absoluteStartIndex = this.slidingWindow.absoluteIndex();
+            var width = this.scanSingleLineCommentTriviaLength();
+
+            return TypeScript.Syntax.deferredTrivia(7 /* SingleLineCommentTrivia */, underlyingText, underlyingTextStart + absoluteStartIndex, width);
+        };
+
+        Scanner.prototype.scanSingleLineCommentTriviaLength = function () {
+            this.slidingWindow.moveToNextItem();
+            this.slidingWindow.moveToNextItem();
+
+            var width = 2;
+            while (true) {
+                if (this.slidingWindow.isAtEndOfSource() || this.isNewLineCharacter(this.currentCharCode())) {
+                    return width;
+                }
+
+                this.slidingWindow.moveToNextItem();
+                width++;
+            }
+        };
+
+        Scanner.prototype.scanMultiLineCommentTrivia = function (underlyingText, underlyingTextStart) {
+            var absoluteStartIndex = this.absoluteIndex();
+            var width = this.scanMultiLineCommentTriviaLength(null);
+
+            return TypeScript.Syntax.deferredTrivia(6 /* MultiLineCommentTrivia */, underlyingText, underlyingTextStart + absoluteStartIndex, width);
+        };
+
+        Scanner.prototype.scanMultiLineCommentTriviaLength = function (diagnostics) {
+            this.slidingWindow.moveToNextItem();
+            this.slidingWindow.moveToNextItem();
+
+            var width = 2;
+            while (true) {
+                if (this.slidingWindow.isAtEndOfSource()) {
+                    if (diagnostics !== null) {
+                        diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), this.slidingWindow.absoluteIndex(), 0, TypeScript.DiagnosticCode.AsteriskSlash_expected, null));
+                    }
+
+                    return width;
+                }
+
+                var ch = this.currentCharCode();
+                if (ch === 42 /* asterisk */ && this.slidingWindow.peekItemN(1) === 47 /* slash */) {
+                    this.slidingWindow.moveToNextItem();
+                    this.slidingWindow.moveToNextItem();
+                    width += 2;
+                    return width;
+                }
+
+                this.slidingWindow.moveToNextItem();
+                width++;
+            }
+        };
+
+        Scanner.prototype.scanLineTerminatorSequenceTrivia = function (ch) {
+            var absoluteStartIndex = this.slidingWindow.getAndPinAbsoluteIndex();
+            var width = this.scanLineTerminatorSequenceLength(ch);
+
+            var text = this.substring(absoluteStartIndex, absoluteStartIndex + width, false);
+            this.slidingWindow.releaseAndUnpinAbsoluteIndex(absoluteStartIndex);
+
+            return TypeScript.Syntax.trivia(5 /* NewLineTrivia */, text);
+        };
+
+        Scanner.prototype.scanLineTerminatorSequenceLength = function (ch) {
+            this.slidingWindow.moveToNextItem();
+
+            if (ch === 13 /* carriageReturn */ && this.currentCharCode() === 10 /* lineFeed */) {
+                this.slidingWindow.moveToNextItem();
+                return 2;
+            } else {
+                return 1;
+            }
+        };
+
+        Scanner.prototype.scanSyntaxToken = function (diagnostics, allowRegularExpression) {
+            if (this.slidingWindow.isAtEndOfSource()) {
+                return 10 /* EndOfFileToken */;
+            }
+
+            var character = this.currentCharCode();
+
+            switch (character) {
+                case 34 /* doubleQuote */:
+                case 39 /* singleQuote */:
+                    return this.scanStringLiteral(diagnostics);
+
+                case 47 /* slash */:
+                    return this.scanSlashToken(allowRegularExpression);
+
+                case 46 /* dot */:
+                    return this.scanDotToken(diagnostics);
+
+                case 45 /* minus */:
+                    return this.scanMinusToken();
+
+                case 33 /* exclamation */:
+                    return this.scanExclamationToken();
+
+                case 61 /* equals */:
+                    return this.scanEqualsToken();
+
+                case 124 /* bar */:
+                    return this.scanBarToken();
+
+                case 42 /* asterisk */:
+                    return this.scanAsteriskToken();
+
+                case 43 /* plus */:
+                    return this.scanPlusToken();
+
+                case 37 /* percent */:
+                    return this.scanPercentToken();
+
+                case 38 /* ampersand */:
+                    return this.scanAmpersandToken();
+
+                case 94 /* caret */:
+                    return this.scanCaretToken();
+
+                case 60 /* lessThan */:
+                    return this.scanLessThanToken();
+
+                case 62 /* greaterThan */:
+                    return this.advanceAndSetTokenKind(81 /* GreaterThanToken */);
+
+                case 44 /* comma */:
+                    return this.advanceAndSetTokenKind(79 /* CommaToken */);
+
+                case 58 /* colon */:
+                    return this.advanceAndSetTokenKind(106 /* ColonToken */);
+
+                case 59 /* semicolon */:
+                    return this.advanceAndSetTokenKind(78 /* SemicolonToken */);
+
+                case 126 /* tilde */:
+                    return this.advanceAndSetTokenKind(102 /* TildeToken */);
+
+                case 40 /* openParen */:
+                    return this.advanceAndSetTokenKind(72 /* OpenParenToken */);
+
+                case 41 /* closeParen */:
+                    return this.advanceAndSetTokenKind(73 /* CloseParenToken */);
+
+                case 123 /* openBrace */:
+                    return this.advanceAndSetTokenKind(70 /* OpenBraceToken */);
+
+                case 125 /* closeBrace */:
+                    return this.advanceAndSetTokenKind(71 /* CloseBraceToken */);
+
+                case 91 /* openBracket */:
+                    return this.advanceAndSetTokenKind(74 /* OpenBracketToken */);
+
+                case 93 /* closeBracket */:
+                    return this.advanceAndSetTokenKind(75 /* CloseBracketToken */);
+
+                case 63 /* question */:
+                    return this.advanceAndSetTokenKind(105 /* QuestionToken */);
+            }
+
+            if (isNumericLiteralStart[character]) {
+                return this.scanNumericLiteral(diagnostics);
+            }
+
+            if (isIdentifierStartCharacter[character]) {
+                var result = this.tryFastScanIdentifierOrKeyword(character);
+                if (result !== 0 /* None */) {
+                    return result;
+                }
+            }
+
+            if (this.isIdentifierStart(this.peekCharOrUnicodeEscape())) {
+                return this.slowScanIdentifierOrKeyword(diagnostics);
+            }
+
+            return this.scanDefaultCharacter(character, diagnostics);
+        };
+
+        Scanner.prototype.isIdentifierStart = function (interpretedChar) {
+            if (isIdentifierStartCharacter[interpretedChar]) {
+                return true;
+            }
+
+            return interpretedChar > 127 /* maxAsciiCharacter */ && TypeScript.Unicode.isIdentifierStart(interpretedChar, this._languageVersion);
+        };
+
+        Scanner.prototype.isIdentifierPart = function (interpretedChar) {
+            if (isIdentifierPartCharacter[interpretedChar]) {
+                return true;
+            }
+
+            return interpretedChar > 127 /* maxAsciiCharacter */ && TypeScript.Unicode.isIdentifierPart(interpretedChar, this._languageVersion);
+        };
+
+        Scanner.prototype.tryFastScanIdentifierOrKeyword = function (firstCharacter) {
+            var slidingWindow = this.slidingWindow;
+            var window = slidingWindow.window;
+
+            var startIndex = slidingWindow.currentRelativeItemIndex;
+            var endIndex = slidingWindow.windowCount;
+            var currentIndex = startIndex;
+            var character = 0;
+
+            while (currentIndex < endIndex) {
+                character = window[currentIndex];
+                if (!isIdentifierPartCharacter[character]) {
+                    break;
+                }
+
+                currentIndex++;
+            }
+
+            if (currentIndex === endIndex) {
+                return 0 /* None */;
+            } else if (character === 92 /* backslash */ || character > 127 /* maxAsciiCharacter */) {
+                return 0 /* None */;
+            } else {
+                var kind;
+                var identifierLength = currentIndex - startIndex;
+                if (isKeywordStartCharacter[firstCharacter]) {
+                    kind = TypeScript.ScannerUtilities.identifierKind(window, startIndex, identifierLength);
+                } else {
+                    kind = 11 /* IdentifierName */;
+                }
+
+                slidingWindow.setAbsoluteIndex(slidingWindow.absoluteIndex() + identifierLength);
+
+                return kind;
+            }
+        };
+
+        Scanner.prototype.slowScanIdentifierOrKeyword = function (diagnostics) {
+            var startIndex = this.slidingWindow.absoluteIndex();
+            var sawUnicodeEscape = false;
+
+            do {
+                var unicodeEscape = this.scanCharOrUnicodeEscape(diagnostics);
+                sawUnicodeEscape = sawUnicodeEscape || unicodeEscape;
+            } while(this.isIdentifierPart(this.peekCharOrUnicodeEscape()));
+
+            var length = this.slidingWindow.absoluteIndex() - startIndex;
+            var text = this.text.substr(startIndex, length, false);
+            var valueText = TypeScript.Syntax.massageEscapes(text);
+
+            var keywordKind = TypeScript.SyntaxFacts.getTokenKind(valueText);
+            if (keywordKind >= 15 /* FirstKeyword */ && keywordKind <= 69 /* LastKeyword */) {
+                if (sawUnicodeEscape) {
+                    return keywordKind | -2147483648 /* IsVariableWidthKeyword */;
+                } else {
+                    return keywordKind;
+                }
+            }
+
+            return 11 /* IdentifierName */;
+        };
+
+        Scanner.prototype.scanNumericLiteral = function (diagnostics) {
+            if (this.isHexNumericLiteral()) {
+                this.scanHexNumericLiteral();
+            } else if (this.isOctalNumericLiteral()) {
+                this.scanOctalNumericLiteral(diagnostics);
+            } else {
+                this.scanDecimalNumericLiteral();
+            }
+
+            return 13 /* NumericLiteral */;
+        };
+
+        Scanner.prototype.isOctalNumericLiteral = function () {
+            return this.currentCharCode() === 48 /* _0 */ && TypeScript.CharacterInfo.isOctalDigit(this.slidingWindow.peekItemN(1));
+        };
+
+        Scanner.prototype.scanOctalNumericLiteral = function (diagnostics) {
+            var position = this.absoluteIndex();
+
+            while (TypeScript.CharacterInfo.isOctalDigit(this.currentCharCode())) {
+                this.slidingWindow.moveToNextItem();
+            }
+
+            if (this.languageVersion() >= 1 /* EcmaScript5 */) {
+                diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), position, this.absoluteIndex() - position, TypeScript.DiagnosticCode.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher, null));
+            }
+        };
+
+        Scanner.prototype.scanDecimalDigits = function () {
+            while (TypeScript.CharacterInfo.isDecimalDigit(this.currentCharCode())) {
+                this.slidingWindow.moveToNextItem();
+            }
+        };
+
+        Scanner.prototype.scanDecimalNumericLiteral = function () {
+            this.scanDecimalDigits();
+
+            if (this.currentCharCode() === 46 /* dot */) {
+                this.slidingWindow.moveToNextItem();
+            }
+
+            this.scanDecimalDigits();
+
+            var ch = this.currentCharCode();
+            if (ch === 101 /* e */ || ch === 69 /* E */) {
+                var nextChar1 = this.slidingWindow.peekItemN(1);
+
+                if (TypeScript.CharacterInfo.isDecimalDigit(nextChar1)) {
+                    this.slidingWindow.moveToNextItem();
+                    this.scanDecimalDigits();
+                } else if (nextChar1 === 45 /* minus */ || nextChar1 === 43 /* plus */) {
+                    var nextChar2 = this.slidingWindow.peekItemN(2);
+                    if (TypeScript.CharacterInfo.isDecimalDigit(nextChar2)) {
+                        this.slidingWindow.moveToNextItem();
+                        this.slidingWindow.moveToNextItem();
+                        this.scanDecimalDigits();
+                    }
+                }
+            }
+        };
+
+        Scanner.prototype.scanHexNumericLiteral = function () {
+            this.slidingWindow.moveToNextItem();
+            this.slidingWindow.moveToNextItem();
+
+            while (TypeScript.CharacterInfo.isHexDigit(this.currentCharCode())) {
+                this.slidingWindow.moveToNextItem();
+            }
+        };
+
+        Scanner.prototype.isHexNumericLiteral = function () {
+            if (this.currentCharCode() === 48 /* _0 */) {
+                var ch = this.slidingWindow.peekItemN(1);
+
+                if (ch === 120 /* x */ || ch === 88 /* X */) {
+                    ch = this.slidingWindow.peekItemN(2);
+
+                    return TypeScript.CharacterInfo.isHexDigit(ch);
+                }
+            }
+
+            return false;
+        };
+
+        Scanner.prototype.advanceAndSetTokenKind = function (kind) {
+            this.slidingWindow.moveToNextItem();
+            return kind;
+        };
+
+        Scanner.prototype.scanLessThanToken = function () {
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 82 /* LessThanEqualsToken */;
+            } else if (this.currentCharCode() === 60 /* lessThan */) {
+                this.slidingWindow.moveToNextItem();
+                if (this.currentCharCode() === 61 /* equals */) {
+                    this.slidingWindow.moveToNextItem();
+                    return 112 /* LessThanLessThanEqualsToken */;
+                } else {
+                    return 95 /* LessThanLessThanToken */;
+                }
+            } else {
+                return 80 /* LessThanToken */;
+            }
+        };
+
+        Scanner.prototype.scanBarToken = function () {
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 116 /* BarEqualsToken */;
+            } else if (this.currentCharCode() === 124 /* bar */) {
+                this.slidingWindow.moveToNextItem();
+                return 104 /* BarBarToken */;
+            } else {
+                return 99 /* BarToken */;
+            }
+        };
+
+        Scanner.prototype.scanCaretToken = function () {
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 117 /* CaretEqualsToken */;
+            } else {
+                return 100 /* CaretToken */;
+            }
+        };
+
+        Scanner.prototype.scanAmpersandToken = function () {
+            this.slidingWindow.moveToNextItem();
+            var character = this.currentCharCode();
+            if (character === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 115 /* AmpersandEqualsToken */;
+            } else if (this.currentCharCode() === 38 /* ampersand */) {
+                this.slidingWindow.moveToNextItem();
+                return 103 /* AmpersandAmpersandToken */;
+            } else {
+                return 98 /* AmpersandToken */;
+            }
+        };
+
+        Scanner.prototype.scanPercentToken = function () {
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 111 /* PercentEqualsToken */;
+            } else {
+                return 92 /* PercentToken */;
+            }
+        };
+
+        Scanner.prototype.scanMinusToken = function () {
+            this.slidingWindow.moveToNextItem();
+            var character = this.currentCharCode();
+
+            if (character === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 109 /* MinusEqualsToken */;
+            } else if (character === 45 /* minus */) {
+                this.slidingWindow.moveToNextItem();
+                return 94 /* MinusMinusToken */;
+            } else {
+                return 90 /* MinusToken */;
+            }
+        };
+
+        Scanner.prototype.scanPlusToken = function () {
+            this.slidingWindow.moveToNextItem();
+            var character = this.currentCharCode();
+            if (character === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 108 /* PlusEqualsToken */;
+            } else if (character === 43 /* plus */) {
+                this.slidingWindow.moveToNextItem();
+                return 93 /* PlusPlusToken */;
+            } else {
+                return 89 /* PlusToken */;
+            }
+        };
+
+        Scanner.prototype.scanAsteriskToken = function () {
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 110 /* AsteriskEqualsToken */;
+            } else {
+                return 91 /* AsteriskToken */;
+            }
+        };
+
+        Scanner.prototype.scanEqualsToken = function () {
+            this.slidingWindow.moveToNextItem();
+            var character = this.currentCharCode();
+            if (character === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+
+                if (this.currentCharCode() === 61 /* equals */) {
+                    this.slidingWindow.moveToNextItem();
+
+                    return 87 /* EqualsEqualsEqualsToken */;
+                } else {
+                    return 84 /* EqualsEqualsToken */;
+                }
+            } else if (character === 62 /* greaterThan */) {
+                this.slidingWindow.moveToNextItem();
+                return 85 /* EqualsGreaterThanToken */;
+            } else {
+                return 107 /* EqualsToken */;
+            }
+        };
+
+        Scanner.prototype.isDotPrefixedNumericLiteral = function () {
+            if (this.currentCharCode() === 46 /* dot */) {
+                var ch = this.slidingWindow.peekItemN(1);
+                return TypeScript.CharacterInfo.isDecimalDigit(ch);
+            }
+
+            return false;
+        };
+
+        Scanner.prototype.scanDotToken = function (diagnostics) {
+            if (this.isDotPrefixedNumericLiteral()) {
+                return this.scanNumericLiteral(diagnostics);
+            }
+
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 46 /* dot */ && this.slidingWindow.peekItemN(1) === 46 /* dot */) {
+                this.slidingWindow.moveToNextItem();
+                this.slidingWindow.moveToNextItem();
+                return 77 /* DotDotDotToken */;
+            } else {
+                return 76 /* DotToken */;
+            }
+        };
+
+        Scanner.prototype.scanSlashToken = function (allowRegularExpression) {
+            if (allowRegularExpression) {
+                var result = this.tryScanRegularExpressionToken();
+                if (result !== 0 /* None */) {
+                    return result;
+                }
+            }
+
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+                return 119 /* SlashEqualsToken */;
+            } else {
+                return 118 /* SlashToken */;
+            }
+        };
+
+        Scanner.prototype.tryScanRegularExpressionToken = function () {
+            var startIndex = this.slidingWindow.getAndPinAbsoluteIndex();
+
+            this.slidingWindow.moveToNextItem();
+
+            var inEscape = false;
+            var inCharacterClass = false;
+            while (true) {
+                var ch = this.currentCharCode();
+
+                if (this.isNewLineCharacter(ch) || this.slidingWindow.isAtEndOfSource()) {
+                    this.slidingWindow.rewindToPinnedIndex(startIndex);
+                    this.slidingWindow.releaseAndUnpinAbsoluteIndex(startIndex);
+                    return 0 /* None */;
+                }
+
+                this.slidingWindow.moveToNextItem();
+                if (inEscape) {
+                    inEscape = false;
+                    continue;
+                }
+
+                switch (ch) {
+                    case 92 /* backslash */:
+                        inEscape = true;
+                        continue;
+
+                    case 91 /* openBracket */:
+                        inCharacterClass = true;
+                        continue;
+
+                    case 93 /* closeBracket */:
+                        inCharacterClass = false;
+                        continue;
+
+                    case 47 /* slash */:
+                        if (inCharacterClass) {
+                            continue;
+                        }
+
+                        break;
+
+                    default:
+                        continue;
+                }
+
+                break;
+            }
+
+            while (isIdentifierPartCharacter[this.currentCharCode()]) {
+                this.slidingWindow.moveToNextItem();
+            }
+
+            this.slidingWindow.releaseAndUnpinAbsoluteIndex(startIndex);
+            return 12 /* RegularExpressionLiteral */;
+        };
+
+        Scanner.prototype.scanExclamationToken = function () {
+            this.slidingWindow.moveToNextItem();
+            if (this.currentCharCode() === 61 /* equals */) {
+                this.slidingWindow.moveToNextItem();
+
+                if (this.currentCharCode() === 61 /* equals */) {
+                    this.slidingWindow.moveToNextItem();
+
+                    return 88 /* ExclamationEqualsEqualsToken */;
+                } else {
+                    return 86 /* ExclamationEqualsToken */;
+                }
+            } else {
+                return 101 /* ExclamationToken */;
+            }
+        };
+
+        Scanner.prototype.scanDefaultCharacter = function (character, diagnostics) {
+            var position = this.slidingWindow.absoluteIndex();
+            this.slidingWindow.moveToNextItem();
+
+            var text = String.fromCharCode(character);
+            var messageText = this.getErrorMessageText(text);
+            diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), position, 1, TypeScript.DiagnosticCode.Unexpected_character_0, [messageText]));
+
+            return 9 /* ErrorToken */;
+        };
+
+        Scanner.prototype.getErrorMessageText = function (text) {
+            if (text === "\\") {
+                return '"\\"';
+            }
+
+            return JSON.stringify(text);
+        };
+
+        Scanner.prototype.skipEscapeSequence = function (diagnostics) {
+            var rewindPoint = this.slidingWindow.getAndPinAbsoluteIndex();
+
+            this.slidingWindow.moveToNextItem();
+
+            var ch = this.currentCharCode();
+            this.slidingWindow.moveToNextItem();
+            switch (ch) {
+                case 120 /* x */:
+                case 117 /* u */:
+                    this.slidingWindow.rewindToPinnedIndex(rewindPoint);
+                    var value = this.scanUnicodeOrHexEscape(diagnostics);
+                    break;
+
+                case 13 /* carriageReturn */:
+                    if (this.currentCharCode() === 10 /* lineFeed */) {
+                        this.slidingWindow.moveToNextItem();
+                    }
+                    break;
+
+                default:
+                    break;
+            }
+
+            this.slidingWindow.releaseAndUnpinAbsoluteIndex(rewindPoint);
+        };
+
+        Scanner.prototype.scanStringLiteral = function (diagnostics) {
+            var quoteCharacter = this.currentCharCode();
+
+            this.slidingWindow.moveToNextItem();
+
+            while (true) {
+                var ch = this.currentCharCode();
+                if (ch === 92 /* backslash */) {
+                    this.skipEscapeSequence(diagnostics);
+                } else if (ch === quoteCharacter) {
+                    this.slidingWindow.moveToNextItem();
+                    break;
+                } else if (this.isNewLineCharacter(ch) || this.slidingWindow.isAtEndOfSource()) {
+                    diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), TypeScript.MathPrototype.min(this.slidingWindow.absoluteIndex(), this.text.length()), 1, TypeScript.DiagnosticCode.Missing_close_quote_character, null));
+                    break;
+                } else {
+                    this.slidingWindow.moveToNextItem();
+                }
+            }
+
+            return 14 /* StringLiteral */;
+        };
+
+        Scanner.prototype.isUnicodeEscape = function (character) {
+            if (character === 92 /* backslash */) {
+                var ch2 = this.slidingWindow.peekItemN(1);
+                if (ch2 === 117 /* u */) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        Scanner.prototype.peekCharOrUnicodeEscape = function () {
+            var character = this.currentCharCode();
+            if (this.isUnicodeEscape(character)) {
+                return this.peekUnicodeOrHexEscape();
+            } else {
+                return character;
+            }
+        };
+
+        Scanner.prototype.peekUnicodeOrHexEscape = function () {
+            var startIndex = this.slidingWindow.getAndPinAbsoluteIndex();
+
+            var ch = this.scanUnicodeOrHexEscape(null);
+
+            this.slidingWindow.rewindToPinnedIndex(startIndex);
+            this.slidingWindow.releaseAndUnpinAbsoluteIndex(startIndex);
+
+            return ch;
+        };
+
+        Scanner.prototype.scanCharOrUnicodeEscape = function (errors) {
+            var ch = this.currentCharCode();
+            if (ch === 92 /* backslash */) {
+                var ch2 = this.slidingWindow.peekItemN(1);
+                if (ch2 === 117 /* u */) {
+                    this.scanUnicodeOrHexEscape(errors);
+                    return true;
+                }
+            }
+
+            this.slidingWindow.moveToNextItem();
+            return false;
+        };
+
+        Scanner.prototype.scanUnicodeOrHexEscape = function (errors) {
+            var start = this.slidingWindow.absoluteIndex();
+            var character = this.currentCharCode();
+
+            this.slidingWindow.moveToNextItem();
+
+            character = this.currentCharCode();
+
+            var intChar = 0;
+            this.slidingWindow.moveToNextItem();
+
+            var count = character === 117 /* u */ ? 4 : 2;
+
+            for (var i = 0; i < count; i++) {
+                var ch2 = this.currentCharCode();
+                if (!TypeScript.CharacterInfo.isHexDigit(ch2)) {
+                    if (errors !== null) {
+                        var end = this.slidingWindow.absoluteIndex();
+                        var info = this.createIllegalEscapeDiagnostic(start, end);
+                        errors.push(info);
+                    }
+
+                    break;
+                }
+
+                intChar = (intChar << 4) + TypeScript.CharacterInfo.hexValue(ch2);
+                this.slidingWindow.moveToNextItem();
+            }
+
+            return intChar;
+        };
+
+        Scanner.prototype.substring = function (start, end, intern) {
+            var length = end - start;
+            var offset = start - this.slidingWindow.windowAbsoluteStartIndex;
+
+            if (intern) {
+                return TypeScript.Collections.DefaultStringTable.addCharArray(this.slidingWindow.window, offset, length);
+            } else {
+                return TypeScript.StringUtilities.fromCharCodeArray(this.slidingWindow.window.slice(offset, offset + length));
+            }
+        };
+
+        Scanner.prototype.createIllegalEscapeDiagnostic = function (start, end) {
+            return new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), start, end - start, TypeScript.DiagnosticCode.Unrecognized_escape_sequence, null);
+        };
+
+        Scanner.isValidIdentifier = function (text, languageVersion) {
+            var scanner = new Scanner(null, text, languageVersion, Scanner.triviaWindow);
+            var errors = new Array();
+            var token = scanner.scan(errors, false);
+
+            return errors.length === 0 && TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token) && token.width() === text.length();
+        };
+        Scanner.triviaWindow = TypeScript.ArrayUtilities.createArray(2048, 0);
+        return Scanner;
+    })();
+    TypeScript.Scanner = Scanner;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var ScannerUtilities = (function () {
+        function ScannerUtilities() {
+        }
+        ScannerUtilities.identifierKind = function (array, startIndex, length) {
+            switch (length) {
+                case 2:
+                    switch (array[startIndex]) {
+                        case 100 /* d */:
+                            return (array[startIndex + 1] === 111 /* o */) ? 22 /* DoKeyword */ : 11 /* IdentifierName */;
+                        case 105 /* i */:
+                            switch (array[startIndex + 1]) {
+                                case 102 /* f */:
+                                    return 28 /* IfKeyword */;
+                                case 110 /* n */:
+                                    return 29 /* InKeyword */;
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 3:
+                    switch (array[startIndex]) {
+                        case 102 /* f */:
+                            return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 114 /* r */) ? 26 /* ForKeyword */ : 11 /* IdentifierName */;
+                        case 110 /* n */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 119 /* w */) ? 31 /* NewKeyword */ : 11 /* IdentifierName */;
+                        case 116 /* t */:
+                            return (array[startIndex + 1] === 114 /* r */ && array[startIndex + 2] === 121 /* y */) ? 38 /* TryKeyword */ : 11 /* IdentifierName */;
+                        case 118 /* v */:
+                            return (array[startIndex + 1] === 97 /* a */ && array[startIndex + 2] === 114 /* r */) ? 40 /* VarKeyword */ : 11 /* IdentifierName */;
+                        case 108 /* l */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */) ? 53 /* LetKeyword */ : 11 /* IdentifierName */;
+                        case 97 /* a */:
+                            return (array[startIndex + 1] === 110 /* n */ && array[startIndex + 2] === 121 /* y */) ? 60 /* AnyKeyword */ : 11 /* IdentifierName */;
+                        case 103 /* g */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */) ? 64 /* GetKeyword */ : 11 /* IdentifierName */;
+                        case 115 /* s */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */) ? 68 /* SetKeyword */ : 11 /* IdentifierName */;
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 4:
+                    switch (array[startIndex]) {
+                        case 99 /* c */:
+                            return (array[startIndex + 1] === 97 /* a */ && array[startIndex + 2] === 115 /* s */ && array[startIndex + 3] === 101 /* e */) ? 16 /* CaseKeyword */ : 11 /* IdentifierName */;
+                        case 101 /* e */:
+                            switch (array[startIndex + 1]) {
+                                case 108 /* l */:
+                                    return (array[startIndex + 2] === 115 /* s */ && array[startIndex + 3] === 101 /* e */) ? 23 /* ElseKeyword */ : 11 /* IdentifierName */;
+                                case 110 /* n */:
+                                    return (array[startIndex + 2] === 117 /* u */ && array[startIndex + 3] === 109 /* m */) ? 46 /* EnumKeyword */ : 11 /* IdentifierName */;
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        case 110 /* n */:
+                            return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 108 /* l */ && array[startIndex + 3] === 108 /* l */) ? 32 /* NullKeyword */ : 11 /* IdentifierName */;
+                        case 116 /* t */:
+                            switch (array[startIndex + 1]) {
+                                case 104 /* h */:
+                                    return (array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 115 /* s */) ? 35 /* ThisKeyword */ : 11 /* IdentifierName */;
+                                case 114 /* r */:
+                                    return (array[startIndex + 2] === 117 /* u */ && array[startIndex + 3] === 101 /* e */) ? 37 /* TrueKeyword */ : 11 /* IdentifierName */;
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        case 118 /* v */:
+                            return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 100 /* d */) ? 41 /* VoidKeyword */ : 11 /* IdentifierName */;
+                        case 119 /* w */:
+                            return (array[startIndex + 1] === 105 /* i */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 104 /* h */) ? 43 /* WithKeyword */ : 11 /* IdentifierName */;
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 5:
+                    switch (array[startIndex]) {
+                        case 98 /* b */:
+                            return (array[startIndex + 1] === 114 /* r */ && array[startIndex + 2] === 101 /* e */ && array[startIndex + 3] === 97 /* a */ && array[startIndex + 4] === 107 /* k */) ? 15 /* BreakKeyword */ : 11 /* IdentifierName */;
+                        case 99 /* c */:
+                            switch (array[startIndex + 1]) {
+                                case 97 /* a */:
+                                    return (array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 99 /* c */ && array[startIndex + 4] === 104 /* h */) ? 17 /* CatchKeyword */ : 11 /* IdentifierName */;
+                                case 108 /* l */:
+                                    return (array[startIndex + 2] === 97 /* a */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 115 /* s */) ? 44 /* ClassKeyword */ : 11 /* IdentifierName */;
+                                case 111 /* o */:
+                                    return (array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 116 /* t */) ? 45 /* ConstKeyword */ : 11 /* IdentifierName */;
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        case 102 /* f */:
+                            return (array[startIndex + 1] === 97 /* a */ && array[startIndex + 2] === 108 /* l */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 101 /* e */) ? 24 /* FalseKeyword */ : 11 /* IdentifierName */;
+                        case 116 /* t */:
+                            return (array[startIndex + 1] === 104 /* h */ && array[startIndex + 2] === 114 /* r */ && array[startIndex + 3] === 111 /* o */ && array[startIndex + 4] === 119 /* w */) ? 36 /* ThrowKeyword */ : 11 /* IdentifierName */;
+                        case 119 /* w */:
+                            return (array[startIndex + 1] === 104 /* h */ && array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 101 /* e */) ? 42 /* WhileKeyword */ : 11 /* IdentifierName */;
+                        case 115 /* s */:
+                            return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 114 /* r */) ? 50 /* SuperKeyword */ : 11 /* IdentifierName */;
+                        case 121 /* y */:
+                            return (array[startIndex + 1] === 105 /* i */ && array[startIndex + 2] === 101 /* e */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 100 /* d */) ? 59 /* YieldKeyword */ : 11 /* IdentifierName */;
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 6:
+                    switch (array[startIndex]) {
+                        case 100 /* d */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 108 /* l */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 116 /* t */ && array[startIndex + 5] === 101 /* e */) ? 21 /* DeleteKeyword */ : 11 /* IdentifierName */;
+                        case 114 /* r */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 110 /* n */) ? 33 /* ReturnKeyword */ : 11 /* IdentifierName */;
+                        case 115 /* s */:
+                            switch (array[startIndex + 1]) {
+                                case 119 /* w */:
+                                    return (array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 99 /* c */ && array[startIndex + 5] === 104 /* h */) ? 34 /* SwitchKeyword */ : 11 /* IdentifierName */;
+                                case 116 /* t */:
+                                    switch (array[startIndex + 2]) {
+                                        case 97 /* a */:
+                                            return (array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 99 /* c */) ? 58 /* StaticKeyword */ : 11 /* IdentifierName */;
+                                        case 114 /* r */:
+                                            return (array[startIndex + 3] === 105 /* i */ && array[startIndex + 4] === 110 /* n */ && array[startIndex + 5] === 103 /* g */) ? 69 /* StringKeyword */ : 11 /* IdentifierName */;
+                                        default:
+                                            return 11 /* IdentifierName */;
+                                    }
+
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        case 116 /* t */:
+                            return (array[startIndex + 1] === 121 /* y */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 111 /* o */ && array[startIndex + 5] === 102 /* f */) ? 39 /* TypeOfKeyword */ : 11 /* IdentifierName */;
+                        case 101 /* e */:
+                            return (array[startIndex + 1] === 120 /* x */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 111 /* o */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 116 /* t */) ? 47 /* ExportKeyword */ : 11 /* IdentifierName */;
+                        case 105 /* i */:
+                            return (array[startIndex + 1] === 109 /* m */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 111 /* o */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 116 /* t */) ? 49 /* ImportKeyword */ : 11 /* IdentifierName */;
+                        case 112 /* p */:
+                            return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 98 /* b */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 99 /* c */) ? 57 /* PublicKeyword */ : 11 /* IdentifierName */;
+                        case 109 /* m */:
+                            return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 100 /* d */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 108 /* l */ && array[startIndex + 5] === 101 /* e */) ? 65 /* ModuleKeyword */ : 11 /* IdentifierName */;
+                        case 110 /* n */:
+                            return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 109 /* m */ && array[startIndex + 3] === 98 /* b */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 114 /* r */) ? 67 /* NumberKeyword */ : 11 /* IdentifierName */;
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 7:
+                    switch (array[startIndex]) {
+                        case 100 /* d */:
+                            switch (array[startIndex + 1]) {
+                                case 101 /* e */:
+                                    switch (array[startIndex + 2]) {
+                                        case 102 /* f */:
+                                            return (array[startIndex + 3] === 97 /* a */ && array[startIndex + 4] === 117 /* u */ && array[startIndex + 5] === 108 /* l */ && array[startIndex + 6] === 116 /* t */) ? 20 /* DefaultKeyword */ : 11 /* IdentifierName */;
+                                        case 99 /* c */:
+                                            return (array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 114 /* r */ && array[startIndex + 6] === 101 /* e */) ? 63 /* DeclareKeyword */ : 11 /* IdentifierName */;
+                                        default:
+                                            return 11 /* IdentifierName */;
+                                    }
+
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        case 102 /* f */:
+                            return (array[startIndex + 1] === 105 /* i */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 97 /* a */ && array[startIndex + 4] === 108 /* l */ && array[startIndex + 5] === 108 /* l */ && array[startIndex + 6] === 121 /* y */) ? 25 /* FinallyKeyword */ : 11 /* IdentifierName */;
+                        case 101 /* e */:
+                            return (array[startIndex + 1] === 120 /* x */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 110 /* n */ && array[startIndex + 5] === 100 /* d */ && array[startIndex + 6] === 115 /* s */) ? 48 /* ExtendsKeyword */ : 11 /* IdentifierName */;
+                        case 112 /* p */:
+                            switch (array[startIndex + 1]) {
+                                case 97 /* a */:
+                                    return (array[startIndex + 2] === 99 /* c */ && array[startIndex + 3] === 107 /* k */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 103 /* g */ && array[startIndex + 6] === 101 /* e */) ? 54 /* PackageKeyword */ : 11 /* IdentifierName */;
+                                case 114 /* r */:
+                                    return (array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 118 /* v */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 116 /* t */ && array[startIndex + 6] === 101 /* e */) ? 55 /* PrivateKeyword */ : 11 /* IdentifierName */;
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        case 98 /* b */:
+                            return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 111 /* o */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 97 /* a */ && array[startIndex + 6] === 110 /* n */) ? 61 /* BooleanKeyword */ : 11 /* IdentifierName */;
+                        case 114 /* r */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 113 /* q */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 114 /* r */ && array[startIndex + 6] === 101 /* e */) ? 66 /* RequireKeyword */ : 11 /* IdentifierName */;
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 8:
+                    switch (array[startIndex]) {
+                        case 99 /* c */:
+                            return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 110 /* n */ && array[startIndex + 6] === 117 /* u */ && array[startIndex + 7] === 101 /* e */) ? 18 /* ContinueKeyword */ : 11 /* IdentifierName */;
+                        case 100 /* d */:
+                            return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 98 /* b */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 103 /* g */ && array[startIndex + 5] === 103 /* g */ && array[startIndex + 6] === 101 /* e */ && array[startIndex + 7] === 114 /* r */) ? 19 /* DebuggerKeyword */ : 11 /* IdentifierName */;
+                        case 102 /* f */:
+                            return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 99 /* c */ && array[startIndex + 4] === 116 /* t */ && array[startIndex + 5] === 105 /* i */ && array[startIndex + 6] === 111 /* o */ && array[startIndex + 7] === 110 /* n */) ? 27 /* FunctionKeyword */ : 11 /* IdentifierName */;
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 9:
+                    switch (array[startIndex]) {
+                        case 105 /* i */:
+                            return (array[startIndex + 1] === 110 /* n */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 102 /* f */ && array[startIndex + 6] === 97 /* a */ && array[startIndex + 7] === 99 /* c */ && array[startIndex + 8] === 101 /* e */) ? 52 /* InterfaceKeyword */ : 11 /* IdentifierName */;
+                        case 112 /* p */:
+                            return (array[startIndex + 1] === 114 /* r */ && array[startIndex + 2] === 111 /* o */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 99 /* c */ && array[startIndex + 6] === 116 /* t */ && array[startIndex + 7] === 101 /* e */ && array[startIndex + 8] === 100 /* d */) ? 56 /* ProtectedKeyword */ : 11 /* IdentifierName */;
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 10:
+                    switch (array[startIndex]) {
+                        case 105 /* i */:
+                            switch (array[startIndex + 1]) {
+                                case 110 /* n */:
+                                    return (array[startIndex + 2] === 115 /* s */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 110 /* n */ && array[startIndex + 6] === 99 /* c */ && array[startIndex + 7] === 101 /* e */ && array[startIndex + 8] === 111 /* o */ && array[startIndex + 9] === 102 /* f */) ? 30 /* InstanceOfKeyword */ : 11 /* IdentifierName */;
+                                case 109 /* m */:
+                                    return (array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 109 /* m */ && array[startIndex + 6] === 101 /* e */ && array[startIndex + 7] === 110 /* n */ && array[startIndex + 8] === 116 /* t */ && array[startIndex + 9] === 115 /* s */) ? 51 /* ImplementsKeyword */ : 11 /* IdentifierName */;
+                                default:
+                                    return 11 /* IdentifierName */;
+                            }
+
+                        default:
+                            return 11 /* IdentifierName */;
+                    }
+
+                case 11:
+                    return (array[startIndex] === 99 /* c */ && array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 116 /* t */ && array[startIndex + 5] === 114 /* r */ && array[startIndex + 6] === 117 /* u */ && array[startIndex + 7] === 99 /* c */ && array[startIndex + 8] === 116 /* t */ && array[startIndex + 9] === 111 /* o */ && array[startIndex + 10] === 114 /* r */) ? 62 /* ConstructorKeyword */ : 11 /* IdentifierName */;
+                default:
+                    return 11 /* IdentifierName */;
+            }
+        };
+        return ScannerUtilities;
+    })();
+    TypeScript.ScannerUtilities = ScannerUtilities;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        var EmptySeparatedSyntaxList = (function () {
+            function EmptySeparatedSyntaxList() {
+            }
+            EmptySeparatedSyntaxList.prototype.kind = function () {
+                return 2 /* SeparatedList */;
+            };
+
+            EmptySeparatedSyntaxList.prototype.isNode = function () {
+                return false;
+            };
+
+            EmptySeparatedSyntaxList.prototype.isToken = function () {
+                return false;
+            };
+
+            EmptySeparatedSyntaxList.prototype.isList = function () {
+                return false;
+            };
+
+            EmptySeparatedSyntaxList.prototype.isSeparatedList = function () {
+                return true;
+            };
+
+            EmptySeparatedSyntaxList.prototype.toJSON = function (key) {
+                return [];
+            };
+
+            EmptySeparatedSyntaxList.prototype.childCount = function () {
+                return 0;
+            };
+
+            EmptySeparatedSyntaxList.prototype.nonSeparatorCount = function () {
+                return 0;
+            };
+
+            EmptySeparatedSyntaxList.prototype.separatorCount = function () {
+                return 0;
+            };
+
+            EmptySeparatedSyntaxList.prototype.toArray = function () {
+                return [];
+            };
+
+            EmptySeparatedSyntaxList.prototype.toNonSeparatorArray = function () {
+                return [];
+            };
+
+            EmptySeparatedSyntaxList.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            };
+
+            EmptySeparatedSyntaxList.prototype.nonSeparatorAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            };
+
+            EmptySeparatedSyntaxList.prototype.separatorAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            };
+
+            EmptySeparatedSyntaxList.prototype.collectTextElements = function (elements) {
+            };
+
+            EmptySeparatedSyntaxList.prototype.firstToken = function () {
+                return null;
+            };
+
+            EmptySeparatedSyntaxList.prototype.lastToken = function () {
+                return null;
+            };
+
+            EmptySeparatedSyntaxList.prototype.fullWidth = function () {
+                return 0;
+            };
+
+            EmptySeparatedSyntaxList.prototype.fullText = function () {
+                return "";
+            };
+
+            EmptySeparatedSyntaxList.prototype.width = function () {
+                return 0;
+            };
+
+            EmptySeparatedSyntaxList.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+
+            EmptySeparatedSyntaxList.prototype.isIncrementallyUnusable = function () {
+                return false;
+            };
+
+            EmptySeparatedSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) {
+                throw TypeScript.Errors.invalidOperation();
+            };
+
+            EmptySeparatedSyntaxList.prototype.insertChildrenInto = function (array, index) {
+            };
+
+            EmptySeparatedSyntaxList.prototype.leadingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            EmptySeparatedSyntaxList.prototype.trailingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            EmptySeparatedSyntaxList.prototype.leadingTriviaWidth = function () {
+                return 0;
+            };
+
+            EmptySeparatedSyntaxList.prototype.trailingTriviaWidth = function () {
+                return 0;
+            };
+            return EmptySeparatedSyntaxList;
+        })();
+
+        Syntax.emptySeparatedList = new EmptySeparatedSyntaxList();
+
+        var SingletonSeparatedSyntaxList = (function () {
+            function SingletonSeparatedSyntaxList(item) {
+                this.item = item;
+            }
+            SingletonSeparatedSyntaxList.prototype.toJSON = function (key) {
+                return [this.item];
+            };
+
+            SingletonSeparatedSyntaxList.prototype.kind = function () {
+                return 2 /* SeparatedList */;
+            };
+
+            SingletonSeparatedSyntaxList.prototype.isNode = function () {
+                return false;
+            };
+            SingletonSeparatedSyntaxList.prototype.isToken = function () {
+                return false;
+            };
+            SingletonSeparatedSyntaxList.prototype.isList = function () {
+                return false;
+            };
+            SingletonSeparatedSyntaxList.prototype.isSeparatedList = function () {
+                return true;
+            };
+
+            SingletonSeparatedSyntaxList.prototype.childCount = function () {
+                return 1;
+            };
+            SingletonSeparatedSyntaxList.prototype.nonSeparatorCount = function () {
+                return 1;
+            };
+            SingletonSeparatedSyntaxList.prototype.separatorCount = function () {
+                return 0;
+            };
+
+            SingletonSeparatedSyntaxList.prototype.toArray = function () {
+                return [this.item];
+            };
+            SingletonSeparatedSyntaxList.prototype.toNonSeparatorArray = function () {
+                return [this.item];
+            };
+
+            SingletonSeparatedSyntaxList.prototype.childAt = function (index) {
+                if (index !== 0) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.item;
+            };
+
+            SingletonSeparatedSyntaxList.prototype.nonSeparatorAt = function (index) {
+                if (index !== 0) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.item;
+            };
+
+            SingletonSeparatedSyntaxList.prototype.separatorAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            };
+
+            SingletonSeparatedSyntaxList.prototype.collectTextElements = function (elements) {
+                this.item.collectTextElements(elements);
+            };
+
+            SingletonSeparatedSyntaxList.prototype.firstToken = function () {
+                return this.item.firstToken();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.lastToken = function () {
+                return this.item.lastToken();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.fullWidth = function () {
+                return this.item.fullWidth();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.width = function () {
+                return this.item.width();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.fullText = function () {
+                return this.item.fullText();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.leadingTrivia = function () {
+                return this.item.leadingTrivia();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.trailingTrivia = function () {
+                return this.item.trailingTrivia();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.leadingTriviaWidth = function () {
+                return this.item.leadingTriviaWidth();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.trailingTriviaWidth = function () {
+                return this.item.trailingTriviaWidth();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.isTypeScriptSpecific = function () {
+                return this.item.isTypeScriptSpecific();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.isIncrementallyUnusable = function () {
+                return this.item.isIncrementallyUnusable();
+            };
+
+            SingletonSeparatedSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return this.item.findTokenInternal(new TypeScript.PositionedSeparatedList(parent, this, fullStart), position, fullStart);
+            };
+
+            SingletonSeparatedSyntaxList.prototype.insertChildrenInto = function (array, index) {
+                array.splice(index, 0, this.item);
+            };
+            return SingletonSeparatedSyntaxList;
+        })();
+
+        var NormalSeparatedSyntaxList = (function () {
+            function NormalSeparatedSyntaxList(elements) {
+                this._data = 0;
+                this.elements = elements;
+            }
+            NormalSeparatedSyntaxList.prototype.kind = function () {
+                return 2 /* SeparatedList */;
+            };
+
+            NormalSeparatedSyntaxList.prototype.isToken = function () {
+                return false;
+            };
+            NormalSeparatedSyntaxList.prototype.isNode = function () {
+                return false;
+            };
+            NormalSeparatedSyntaxList.prototype.isList = function () {
+                return false;
+            };
+            NormalSeparatedSyntaxList.prototype.isSeparatedList = function () {
+                return true;
+            };
+            NormalSeparatedSyntaxList.prototype.toJSON = function (key) {
+                return this.elements;
+            };
+
+            NormalSeparatedSyntaxList.prototype.childCount = function () {
+                return this.elements.length;
+            };
+            NormalSeparatedSyntaxList.prototype.nonSeparatorCount = function () {
+                return TypeScript.IntegerUtilities.integerDivide(this.elements.length + 1, 2);
+            };
+            NormalSeparatedSyntaxList.prototype.separatorCount = function () {
+                return TypeScript.IntegerUtilities.integerDivide(this.elements.length, 2);
+            };
+
+            NormalSeparatedSyntaxList.prototype.toArray = function () {
+                return this.elements.slice(0);
+            };
+
+            NormalSeparatedSyntaxList.prototype.toNonSeparatorArray = function () {
+                var result = [];
+                for (var i = 0, n = this.nonSeparatorCount(); i < n; i++) {
+                    result.push(this.nonSeparatorAt(i));
+                }
+
+                return result;
+            };
+
+            NormalSeparatedSyntaxList.prototype.childAt = function (index) {
+                if (index < 0 || index >= this.elements.length) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.elements[index];
+            };
+
+            NormalSeparatedSyntaxList.prototype.nonSeparatorAt = function (index) {
+                var value = index * 2;
+                if (value < 0 || value >= this.elements.length) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.elements[value];
+            };
+
+            NormalSeparatedSyntaxList.prototype.separatorAt = function (index) {
+                var value = index * 2 + 1;
+                if (value < 0 || value >= this.elements.length) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.elements[value];
+            };
+
+            NormalSeparatedSyntaxList.prototype.firstToken = function () {
+                var token;
+                for (var i = 0, n = this.elements.length; i < n; i++) {
+                    if (i % 2 === 0) {
+                        var nodeOrToken = this.elements[i];
+                        token = nodeOrToken.firstToken();
+                        if (token !== null) {
+                            return token;
+                        }
+                    } else {
+                        token = this.elements[i];
+                        if (token.width() > 0) {
+                            return token;
+                        }
+                    }
+                }
+
+                return null;
+            };
+
+            NormalSeparatedSyntaxList.prototype.lastToken = function () {
+                var token;
+                for (var i = this.elements.length - 1; i >= 0; i--) {
+                    if (i % 2 === 0) {
+                        var nodeOrToken = this.elements[i];
+                        token = nodeOrToken.lastToken();
+                        if (token !== null) {
+                            return token;
+                        }
+                    } else {
+                        token = this.elements[i];
+                        if (token.width() > 0) {
+                            return token;
+                        }
+                    }
+                }
+
+                return null;
+            };
+
+            NormalSeparatedSyntaxList.prototype.fullText = function () {
+                var elements = [];
+                this.collectTextElements(elements);
+                return elements.join("");
+            };
+
+            NormalSeparatedSyntaxList.prototype.isTypeScriptSpecific = function () {
+                for (var i = 0, n = this.nonSeparatorCount(); i < n; i++) {
+                    if (this.nonSeparatorAt(i).isTypeScriptSpecific()) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            NormalSeparatedSyntaxList.prototype.isIncrementallyUnusable = function () {
+                return (this.data() & 2 /* NodeIncrementallyUnusableMask */) !== 0;
+            };
+
+            NormalSeparatedSyntaxList.prototype.fullWidth = function () {
+                return this.data() >>> 3 /* NodeFullWidthShift */;
+            };
+
+            NormalSeparatedSyntaxList.prototype.width = function () {
+                var fullWidth = this.fullWidth();
+                return fullWidth - this.leadingTriviaWidth() - this.trailingTriviaWidth();
+            };
+
+            NormalSeparatedSyntaxList.prototype.leadingTrivia = function () {
+                return this.firstToken().leadingTrivia();
+            };
+
+            NormalSeparatedSyntaxList.prototype.trailingTrivia = function () {
+                return this.lastToken().trailingTrivia();
+            };
+
+            NormalSeparatedSyntaxList.prototype.leadingTriviaWidth = function () {
+                return this.firstToken().leadingTriviaWidth();
+            };
+
+            NormalSeparatedSyntaxList.prototype.trailingTriviaWidth = function () {
+                return this.lastToken().trailingTriviaWidth();
+            };
+
+            NormalSeparatedSyntaxList.prototype.computeData = function () {
+                var fullWidth = 0;
+                var isIncrementallyUnusable = false;
+
+                for (var i = 0, n = this.elements.length; i < n; i++) {
+                    var element = this.elements[i];
+
+                    var childWidth = element.fullWidth();
+                    fullWidth += childWidth;
+
+                    isIncrementallyUnusable = isIncrementallyUnusable || element.isIncrementallyUnusable();
+                }
+
+                return (fullWidth << 3 /* NodeFullWidthShift */) | (isIncrementallyUnusable ? 2 /* NodeIncrementallyUnusableMask */ : 0) | 1 /* NodeDataComputed */;
+            };
+
+            NormalSeparatedSyntaxList.prototype.data = function () {
+                if ((this._data & 1 /* NodeDataComputed */) === 0) {
+                    this._data = this.computeData();
+                }
+
+                return this._data;
+            };
+
+            NormalSeparatedSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) {
+                parent = new TypeScript.PositionedSeparatedList(parent, this, fullStart);
+                for (var i = 0, n = this.elements.length; i < n; i++) {
+                    var element = this.elements[i];
+
+                    var childWidth = element.fullWidth();
+                    if (position < childWidth) {
+                        return element.findTokenInternal(parent, position, fullStart);
+                    }
+
+                    position -= childWidth;
+                    fullStart += childWidth;
+                }
+
+                throw TypeScript.Errors.invalidOperation();
+            };
+
+            NormalSeparatedSyntaxList.prototype.collectTextElements = function (elements) {
+                for (var i = 0, n = this.elements.length; i < n; i++) {
+                    var element = this.elements[i];
+                    element.collectTextElements(elements);
+                }
+            };
+
+            NormalSeparatedSyntaxList.prototype.insertChildrenInto = function (array, index) {
+                if (index === 0) {
+                    array.unshift.apply(array, this.elements);
+                } else {
+                    array.splice.apply(array, [index, 0].concat(this.elements));
+                }
+            };
+            return NormalSeparatedSyntaxList;
+        })();
+
+        function separatedList(nodes) {
+            return separatedListAndValidate(nodes, false);
+        }
+        Syntax.separatedList = separatedList;
+
+        function separatedListAndValidate(nodes, validate) {
+            if (nodes === undefined || nodes === null || nodes.length === 0) {
+                return Syntax.emptySeparatedList;
+            }
+
+            if (validate) {
+                for (var i = 0; i < nodes.length; i++) {
+                    var item = nodes[i];
+
+                    if (i % 2 === 1) {
+                    }
+                }
+            }
+
+            if (nodes.length === 1) {
+                return new SingletonSeparatedSyntaxList(nodes[0]);
+            }
+
+            return new NormalSeparatedSyntaxList(nodes);
+        }
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SlidingWindow = (function () {
+        function SlidingWindow(source, window, defaultValue, sourceLength) {
+            if (typeof sourceLength === "undefined") { sourceLength = -1; }
+            this.source = source;
+            this.window = window;
+            this.defaultValue = defaultValue;
+            this.sourceLength = sourceLength;
+            this.windowCount = 0;
+            this.windowAbsoluteStartIndex = 0;
+            this.currentRelativeItemIndex = 0;
+            this._pinCount = 0;
+            this.firstPinnedAbsoluteIndex = -1;
+        }
+        SlidingWindow.prototype.windowAbsoluteEndIndex = function () {
+            return this.windowAbsoluteStartIndex + this.windowCount;
+        };
+
+        SlidingWindow.prototype.addMoreItemsToWindow = function (argument) {
+            if (this.sourceLength >= 0 && this.absoluteIndex() >= this.sourceLength) {
+                return false;
+            }
+
+            if (this.windowCount >= this.window.length) {
+                this.tryShiftOrGrowWindow();
+            }
+
+            var spaceAvailable = this.window.length - this.windowCount;
+            var amountFetched = this.source.fetchMoreItems(argument, this.windowAbsoluteEndIndex(), this.window, this.windowCount, spaceAvailable);
+
+            this.windowCount += amountFetched;
+            return amountFetched > 0;
+        };
+
+        SlidingWindow.prototype.tryShiftOrGrowWindow = function () {
+            var currentIndexIsPastWindowHalfwayPoint = this.currentRelativeItemIndex > (this.window.length >>> 1);
+
+            var isAllowedToShift = this.firstPinnedAbsoluteIndex === -1 || this.firstPinnedAbsoluteIndex > this.windowAbsoluteStartIndex;
+
+            if (currentIndexIsPastWindowHalfwayPoint && isAllowedToShift) {
+                var shiftStartIndex = this.firstPinnedAbsoluteIndex === -1 ? this.currentRelativeItemIndex : this.firstPinnedAbsoluteIndex - this.windowAbsoluteStartIndex;
+
+                var shiftCount = this.windowCount - shiftStartIndex;
+
+                if (shiftCount > 0) {
+                    TypeScript.ArrayUtilities.copy(this.window, shiftStartIndex, this.window, 0, shiftCount);
+                }
+
+                this.windowAbsoluteStartIndex += shiftStartIndex;
+
+                this.windowCount -= shiftStartIndex;
+
+                this.currentRelativeItemIndex -= shiftStartIndex;
+            } else {
+                TypeScript.ArrayUtilities.grow(this.window, this.window.length * 2, this.defaultValue);
+            }
+        };
+
+        SlidingWindow.prototype.absoluteIndex = function () {
+            return this.windowAbsoluteStartIndex + this.currentRelativeItemIndex;
+        };
+
+        SlidingWindow.prototype.isAtEndOfSource = function () {
+            return this.absoluteIndex() >= this.sourceLength;
+        };
+
+        SlidingWindow.prototype.getAndPinAbsoluteIndex = function () {
+            var absoluteIndex = this.absoluteIndex();
+            var pinCount = this._pinCount++;
+            if (pinCount === 0) {
+                this.firstPinnedAbsoluteIndex = absoluteIndex;
+            }
+
+            return absoluteIndex;
+        };
+
+        SlidingWindow.prototype.releaseAndUnpinAbsoluteIndex = function (absoluteIndex) {
+            this._pinCount--;
+            if (this._pinCount === 0) {
+                this.firstPinnedAbsoluteIndex = -1;
+            }
+        };
+
+        SlidingWindow.prototype.rewindToPinnedIndex = function (absoluteIndex) {
+            var relativeIndex = absoluteIndex - this.windowAbsoluteStartIndex;
+
+            this.currentRelativeItemIndex = relativeIndex;
+        };
+
+        SlidingWindow.prototype.currentItem = function (argument) {
+            if (this.currentRelativeItemIndex >= this.windowCount) {
+                if (!this.addMoreItemsToWindow(argument)) {
+                    return this.defaultValue;
+                }
+            }
+
+            return this.window[this.currentRelativeItemIndex];
+        };
+
+        SlidingWindow.prototype.peekItemN = function (n) {
+            while (this.currentRelativeItemIndex + n >= this.windowCount) {
+                if (!this.addMoreItemsToWindow(null)) {
+                    return this.defaultValue;
+                }
+            }
+
+            return this.window[this.currentRelativeItemIndex + n];
+        };
+
+        SlidingWindow.prototype.moveToNextItem = function () {
+            this.currentRelativeItemIndex++;
+        };
+
+        SlidingWindow.prototype.disgardAllItemsFromCurrentIndexOnwards = function () {
+            this.windowCount = this.currentRelativeItemIndex;
+        };
+
+        SlidingWindow.prototype.setAbsoluteIndex = function (absoluteIndex) {
+            if (this.absoluteIndex() === absoluteIndex) {
+                return;
+            }
+
+            if (this._pinCount > 0) {
+            }
+
+            if (absoluteIndex >= this.windowAbsoluteStartIndex && absoluteIndex < this.windowAbsoluteEndIndex()) {
+                this.currentRelativeItemIndex = (absoluteIndex - this.windowAbsoluteStartIndex);
+            } else {
+                this.windowAbsoluteStartIndex = absoluteIndex;
+
+                this.windowCount = 0;
+
+                this.currentRelativeItemIndex = 0;
+            }
+        };
+
+        SlidingWindow.prototype.pinCount = function () {
+            return this._pinCount;
+        };
+        return SlidingWindow;
+    })();
+    TypeScript.SlidingWindow = SlidingWindow;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        function emptySourceUnit() {
+            return Syntax.normalModeFactory.sourceUnit(Syntax.emptyList, Syntax.token(10 /* EndOfFileToken */, { text: "" }));
+        }
+        Syntax.emptySourceUnit = emptySourceUnit;
+
+        function getStandaloneExpression(positionedToken) {
+            var token = positionedToken.token();
+            if (positionedToken !== null && positionedToken.kind() === 11 /* IdentifierName */) {
+                var parentPositionedNode = positionedToken.containingNode();
+                var parentNode = parentPositionedNode.node();
+
+                if (parentNode.kind() === 121 /* QualifiedName */ && parentNode.right === token) {
+                    return parentPositionedNode;
+                } else if (parentNode.kind() === 212 /* MemberAccessExpression */ && parentNode.name === token) {
+                    return parentPositionedNode;
+                }
+            }
+
+            return positionedToken;
+        }
+        Syntax.getStandaloneExpression = getStandaloneExpression;
+
+        function isInModuleOrTypeContext(positionedToken) {
+            if (positionedToken !== null) {
+                var positionedNodeOrToken = Syntax.getStandaloneExpression(positionedToken);
+                var parent = positionedNodeOrToken.containingNode();
+
+                if (parent !== null) {
+                    switch (parent.kind()) {
+                        case 246 /* ModuleNameModuleReference */:
+                            return true;
+                        case 121 /* QualifiedName */:
+                            return true;
+                        default:
+                            return isInTypeOnlyContext(positionedToken);
+                    }
+                }
+            }
+
+            return false;
+        }
+        Syntax.isInModuleOrTypeContext = isInModuleOrTypeContext;
+
+        function isInTypeOnlyContext(positionedToken) {
+            var positionedNodeOrToken = Syntax.getStandaloneExpression(positionedToken);
+            var positionedParent = positionedNodeOrToken.containingNode();
+
+            var parent = positionedParent.node();
+            var nodeOrToken = positionedNodeOrToken.nodeOrToken();
+
+            if (parent !== null) {
+                switch (parent.kind()) {
+                    case 124 /* ArrayType */:
+                        return parent.type === nodeOrToken;
+                    case 220 /* CastExpression */:
+                        return parent.type === nodeOrToken;
+                    case 244 /* TypeAnnotation */:
+                    case 230 /* ExtendsHeritageClause */:
+                    case 231 /* ImplementsHeritageClause */:
+                    case 228 /* TypeArgumentList */:
+                        return true;
+                }
+            }
+
+            return false;
+        }
+        Syntax.isInTypeOnlyContext = isInTypeOnlyContext;
+
+        function childOffset(parent, child) {
+            var offset = 0;
+            for (var i = 0, n = parent.childCount(); i < n; i++) {
+                var current = parent.childAt(i);
+                if (current === child) {
+                    return offset;
+                }
+
+                if (current !== null) {
+                    offset += current.fullWidth();
+                }
+            }
+
+            throw TypeScript.Errors.invalidOperation();
+        }
+        Syntax.childOffset = childOffset;
+
+        function childOffsetAt(parent, index) {
+            var offset = 0;
+            for (var i = 0; i < index; i++) {
+                var current = parent.childAt(i);
+                if (current !== null) {
+                    offset += current.fullWidth();
+                }
+            }
+
+            return offset;
+        }
+        Syntax.childOffsetAt = childOffsetAt;
+
+        function childIndex(parent, child) {
+            for (var i = 0, n = parent.childCount(); i < n; i++) {
+                var current = parent.childAt(i);
+                if (current === child) {
+                    return i;
+                }
+            }
+
+            throw TypeScript.Errors.invalidOperation();
+        }
+        Syntax.childIndex = childIndex;
+
+        function nodeStructuralEquals(node1, node2) {
+            if (node1 === null) {
+                return node2 === null;
+            }
+
+            return node1.structuralEquals(node2);
+        }
+        Syntax.nodeStructuralEquals = nodeStructuralEquals;
+
+        function nodeOrTokenStructuralEquals(node1, node2) {
+            if (node1 === node2) {
+                return true;
+            }
+
+            if (node1 === null || node2 === null) {
+                return false;
+            }
+
+            if (node1.isToken()) {
+                return node2.isToken() ? tokenStructuralEquals(node1, node2) : false;
+            }
+
+            return node2.isNode() ? nodeStructuralEquals(node1, node2) : false;
+        }
+        Syntax.nodeOrTokenStructuralEquals = nodeOrTokenStructuralEquals;
+
+        function tokenStructuralEquals(token1, token2) {
+            if (token1 === token2) {
+                return true;
+            }
+
+            if (token1 === null || token2 === null) {
+                return false;
+            }
+
+            return token1.kind() === token2.kind() && token1.width() === token2.width() && token1.fullWidth() === token2.fullWidth() && token1.text() === token2.text() && Syntax.triviaListStructuralEquals(token1.leadingTrivia(), token2.leadingTrivia()) && Syntax.triviaListStructuralEquals(token1.trailingTrivia(), token2.trailingTrivia());
+        }
+        Syntax.tokenStructuralEquals = tokenStructuralEquals;
+
+        function triviaListStructuralEquals(triviaList1, triviaList2) {
+            if (triviaList1.count() !== triviaList2.count()) {
+                return false;
+            }
+
+            for (var i = 0, n = triviaList1.count(); i < n; i++) {
+                if (!Syntax.triviaStructuralEquals(triviaList1.syntaxTriviaAt(i), triviaList2.syntaxTriviaAt(i))) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+        Syntax.triviaListStructuralEquals = triviaListStructuralEquals;
+
+        function triviaStructuralEquals(trivia1, trivia2) {
+            return trivia1.kind() === trivia2.kind() && trivia1.fullWidth() === trivia2.fullWidth() && trivia1.fullText() === trivia2.fullText();
+        }
+        Syntax.triviaStructuralEquals = triviaStructuralEquals;
+
+        function listStructuralEquals(list1, list2) {
+            if (list1.childCount() !== list2.childCount()) {
+                return false;
+            }
+
+            for (var i = 0, n = list1.childCount(); i < n; i++) {
+                var child1 = list1.childAt(i);
+                var child2 = list2.childAt(i);
+
+                if (!Syntax.nodeOrTokenStructuralEquals(child1, child2)) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+        Syntax.listStructuralEquals = listStructuralEquals;
+
+        function separatedListStructuralEquals(list1, list2) {
+            if (list1.childCount() !== list2.childCount()) {
+                return false;
+            }
+
+            for (var i = 0, n = list1.childCount(); i < n; i++) {
+                var element1 = list1.childAt(i);
+                var element2 = list2.childAt(i);
+                if (!Syntax.nodeOrTokenStructuralEquals(element1, element2)) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+        Syntax.separatedListStructuralEquals = separatedListStructuralEquals;
+
+        function elementStructuralEquals(element1, element2) {
+            if (element1 === element2) {
+                return true;
+            }
+
+            if (element1 === null || element2 === null) {
+                return false;
+            }
+
+            if (element2.kind() !== element2.kind()) {
+                return false;
+            }
+
+            if (element1.isToken()) {
+                return tokenStructuralEquals(element1, element2);
+            } else if (element1.isNode()) {
+                return nodeStructuralEquals(element1, element2);
+            } else if (element1.isList()) {
+                return listStructuralEquals(element1, element2);
+            } else if (element1.isSeparatedList()) {
+                return separatedListStructuralEquals(element1, element2);
+            }
+
+            throw TypeScript.Errors.invalidOperation();
+        }
+        Syntax.elementStructuralEquals = elementStructuralEquals;
+
+        function identifierName(text, info) {
+            if (typeof info === "undefined") { info = null; }
+            return Syntax.identifier(text);
+        }
+        Syntax.identifierName = identifierName;
+
+        function trueExpression() {
+            return Syntax.token(37 /* TrueKeyword */);
+        }
+        Syntax.trueExpression = trueExpression;
+
+        function falseExpression() {
+            return Syntax.token(24 /* FalseKeyword */);
+        }
+        Syntax.falseExpression = falseExpression;
+
+        function numericLiteralExpression(text) {
+            return Syntax.token(13 /* NumericLiteral */, { text: text });
+        }
+        Syntax.numericLiteralExpression = numericLiteralExpression;
+
+        function stringLiteralExpression(text) {
+            return Syntax.token(14 /* StringLiteral */, { text: text });
+        }
+        Syntax.stringLiteralExpression = stringLiteralExpression;
+
+        function isSuperInvocationExpression(node) {
+            return node.kind() === 213 /* InvocationExpression */ && node.expression.kind() === 50 /* SuperKeyword */;
+        }
+        Syntax.isSuperInvocationExpression = isSuperInvocationExpression;
+
+        function isSuperInvocationExpressionStatement(node) {
+            return node.kind() === 149 /* ExpressionStatement */ && isSuperInvocationExpression(node.expression);
+        }
+        Syntax.isSuperInvocationExpressionStatement = isSuperInvocationExpressionStatement;
+
+        function isSuperMemberAccessExpression(node) {
+            return node.kind() === 212 /* MemberAccessExpression */ && node.expression.kind() === 50 /* SuperKeyword */;
+        }
+        Syntax.isSuperMemberAccessExpression = isSuperMemberAccessExpression;
+
+        function isSuperMemberAccessInvocationExpression(node) {
+            return node.kind() === 213 /* InvocationExpression */ && isSuperMemberAccessExpression(node.expression);
+        }
+        Syntax.isSuperMemberAccessInvocationExpression = isSuperMemberAccessInvocationExpression;
+
+        function assignmentExpression(left, token, right) {
+            return Syntax.normalModeFactory.binaryExpression(174 /* AssignmentExpression */, left, token, right);
+        }
+        Syntax.assignmentExpression = assignmentExpression;
+
+        function nodeHasSkippedOrMissingTokens(node) {
+            for (var i = 0; i < node.childCount(); i++) {
+                var child = node.childAt(i);
+                if (child !== null && child.isToken()) {
+                    var token = child;
+
+                    if (token.hasSkippedToken() || (token.width() === 0 && token.kind() !== 10 /* EndOfFileToken */)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        Syntax.nodeHasSkippedOrMissingTokens = nodeHasSkippedOrMissingTokens;
+
+        function isUnterminatedStringLiteral(token) {
+            if (token && token.kind() === 14 /* StringLiteral */) {
+                var text = token.text();
+                return text.length < 2 || text.charCodeAt(text.length - 1) !== text.charCodeAt(0);
+            }
+
+            return false;
+        }
+        Syntax.isUnterminatedStringLiteral = isUnterminatedStringLiteral;
+
+        function isUnterminatedMultilineCommentTrivia(trivia) {
+            if (trivia && trivia.kind() === 6 /* MultiLineCommentTrivia */) {
+                var text = trivia.fullText();
+                return text.length < 4 || text.substring(text.length - 2) !== "*/";
+            }
+            return false;
+        }
+        Syntax.isUnterminatedMultilineCommentTrivia = isUnterminatedMultilineCommentTrivia;
+
+        function isEntirelyInsideCommentTrivia(trivia, fullStart, position) {
+            if (trivia && trivia.isComment() && position > fullStart) {
+                var end = fullStart + trivia.fullWidth();
+                if (position < end) {
+                    return true;
+                } else if (position === end) {
+                    return trivia.kind() === 7 /* SingleLineCommentTrivia */ || isUnterminatedMultilineCommentTrivia(trivia);
+                }
+            }
+
+            return false;
+        }
+        Syntax.isEntirelyInsideCommentTrivia = isEntirelyInsideCommentTrivia;
+
+        function isEntirelyInsideComment(sourceUnit, position) {
+            var positionedToken = sourceUnit.findToken(position);
+            var fullStart = positionedToken.fullStart();
+            var triviaList = null;
+            var lastTriviaBeforeToken = null;
+
+            if (positionedToken.kind() === 10 /* EndOfFileToken */) {
+                if (positionedToken.token().hasLeadingTrivia()) {
+                    triviaList = positionedToken.token().leadingTrivia();
+                } else {
+                    positionedToken = positionedToken.previousToken();
+                    if (positionedToken) {
+                        if (positionedToken && positionedToken.token().hasTrailingTrivia()) {
+                            triviaList = positionedToken.token().trailingTrivia();
+                            fullStart = positionedToken.end();
+                        }
+                    }
+                }
+            } else {
+                if (position <= (fullStart + positionedToken.token().leadingTriviaWidth())) {
+                    triviaList = positionedToken.token().leadingTrivia();
+                } else if (position >= (fullStart + positionedToken.token().width())) {
+                    triviaList = positionedToken.token().trailingTrivia();
+                    fullStart = positionedToken.end();
+                }
+            }
+
+            if (triviaList) {
+                for (var i = 0, n = triviaList.count(); i < n; i++) {
+                    var trivia = triviaList.syntaxTriviaAt(i);
+                    if (position <= fullStart) {
+                        break;
+                    } else if (position <= fullStart + trivia.fullWidth() && trivia.isComment()) {
+                        lastTriviaBeforeToken = trivia;
+                        break;
+                    }
+
+                    fullStart += trivia.fullWidth();
+                }
+            }
+
+            return lastTriviaBeforeToken && isEntirelyInsideCommentTrivia(lastTriviaBeforeToken, fullStart, position);
+        }
+        Syntax.isEntirelyInsideComment = isEntirelyInsideComment;
+
+        function isEntirelyInStringOrRegularExpressionLiteral(sourceUnit, position) {
+            var positionedToken = sourceUnit.findToken(position);
+
+            if (positionedToken) {
+                if (positionedToken.kind() === 10 /* EndOfFileToken */) {
+                    positionedToken = positionedToken.previousToken();
+                    return positionedToken && positionedToken.token().trailingTriviaWidth() === 0 && isUnterminatedStringLiteral(positionedToken.token());
+                } else if (position > positionedToken.start()) {
+                    return (position < positionedToken.end() && (positionedToken.kind() === 14 /* StringLiteral */ || positionedToken.kind() === 12 /* RegularExpressionLiteral */)) || (position <= positionedToken.end() && isUnterminatedStringLiteral(positionedToken.token()));
+                }
+            }
+
+            return false;
+        }
+        Syntax.isEntirelyInStringOrRegularExpressionLiteral = isEntirelyInStringOrRegularExpressionLiteral;
+
+        function findSkippedTokenInTriviaList(positionedToken, position, lookInLeadingTriviaList) {
+            var triviaList = null;
+            var fullStart;
+
+            if (lookInLeadingTriviaList) {
+                triviaList = positionedToken.token().leadingTrivia();
+                fullStart = positionedToken.fullStart();
+            } else {
+                triviaList = positionedToken.token().trailingTrivia();
+                fullStart = positionedToken.end();
+            }
+
+            if (triviaList && triviaList.hasSkippedToken()) {
+                for (var i = 0, n = triviaList.count(); i < n; i++) {
+                    var trivia = triviaList.syntaxTriviaAt(i);
+                    var triviaWidth = trivia.fullWidth();
+
+                    if (trivia.isSkippedToken() && position >= fullStart && position <= fullStart + triviaWidth) {
+                        return new TypeScript.PositionedSkippedToken(positionedToken, trivia.skippedToken(), fullStart);
+                    }
+
+                    fullStart += triviaWidth;
+                }
+            }
+
+            return null;
+        }
+
+        function findSkippedTokenOnLeftInTriviaList(positionedToken, position, lookInLeadingTriviaList) {
+            var triviaList = null;
+            var fullEnd;
+
+            if (lookInLeadingTriviaList) {
+                triviaList = positionedToken.token().leadingTrivia();
+                fullEnd = positionedToken.fullStart() + triviaList.fullWidth();
+            } else {
+                triviaList = positionedToken.token().trailingTrivia();
+                fullEnd = positionedToken.fullEnd();
+            }
+
+            if (triviaList && triviaList.hasSkippedToken()) {
+                for (var i = triviaList.count() - 1; i >= 0; i--) {
+                    var trivia = triviaList.syntaxTriviaAt(i);
+                    var triviaWidth = trivia.fullWidth();
+
+                    if (trivia.isSkippedToken() && position >= fullEnd) {
+                        return new TypeScript.PositionedSkippedToken(positionedToken, trivia.skippedToken(), fullEnd - triviaWidth);
+                    }
+
+                    fullEnd -= triviaWidth;
+                }
+            }
+
+            return null;
+        }
+
+        function findSkippedTokenInLeadingTriviaList(positionedToken, position) {
+            return findSkippedTokenInTriviaList(positionedToken, position, true);
+        }
+        Syntax.findSkippedTokenInLeadingTriviaList = findSkippedTokenInLeadingTriviaList;
+
+        function findSkippedTokenInTrailingTriviaList(positionedToken, position) {
+            return findSkippedTokenInTriviaList(positionedToken, position, false);
+        }
+        Syntax.findSkippedTokenInTrailingTriviaList = findSkippedTokenInTrailingTriviaList;
+
+        function findSkippedTokenInPositionedToken(positionedToken, position) {
+            var positionInLeadingTriviaList = (position < positionedToken.start());
+            return findSkippedTokenInTriviaList(positionedToken, position, positionInLeadingTriviaList);
+        }
+        Syntax.findSkippedTokenInPositionedToken = findSkippedTokenInPositionedToken;
+
+        function findSkippedTokenOnLeft(positionedToken, position) {
+            var positionInLeadingTriviaList = (position < positionedToken.start());
+            return findSkippedTokenOnLeftInTriviaList(positionedToken, position, positionInLeadingTriviaList);
+        }
+        Syntax.findSkippedTokenOnLeft = findSkippedTokenOnLeft;
+
+        function getAncestorOfKind(positionedToken, kind) {
+            while (positionedToken && positionedToken.parent()) {
+                if (positionedToken.parent().kind() === kind) {
+                    return positionedToken.parent();
+                }
+
+                positionedToken = positionedToken.parent();
+            }
+
+            return null;
+        }
+        Syntax.getAncestorOfKind = getAncestorOfKind;
+
+        function hasAncestorOfKind(positionedToken, kind) {
+            return Syntax.getAncestorOfKind(positionedToken, kind) !== null;
+        }
+        Syntax.hasAncestorOfKind = hasAncestorOfKind;
+
+        function isIntegerLiteral(expression) {
+            if (expression) {
+                switch (expression.kind()) {
+                    case 164 /* PlusExpression */:
+                    case 165 /* NegateExpression */:
+                        expression = expression.operand;
+                        return expression.isToken() && TypeScript.IntegerUtilities.isInteger(expression.text());
+
+                    case 13 /* NumericLiteral */:
+                        var text = expression.text();
+                        return TypeScript.IntegerUtilities.isInteger(text) || TypeScript.IntegerUtilities.isHexInteger(text);
+                }
+            }
+
+            return false;
+        }
+        Syntax.isIntegerLiteral = isIntegerLiteral;
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        var NormalModeFactory = (function () {
+            function NormalModeFactory() {
+            }
+            NormalModeFactory.prototype.sourceUnit = function (moduleElements, endOfFileToken) {
+                return new TypeScript.SourceUnitSyntax(moduleElements, endOfFileToken, false);
+            };
+            NormalModeFactory.prototype.externalModuleReference = function (requireKeyword, openParenToken, stringLiteral, closeParenToken) {
+                return new TypeScript.ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, false);
+            };
+            NormalModeFactory.prototype.moduleNameModuleReference = function (moduleName) {
+                return new TypeScript.ModuleNameModuleReferenceSyntax(moduleName, false);
+            };
+            NormalModeFactory.prototype.importDeclaration = function (modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken) {
+                return new TypeScript.ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.exportAssignment = function (exportKeyword, equalsToken, identifier, semicolonToken) {
+                return new TypeScript.ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.classDeclaration = function (modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken) {
+                return new TypeScript.ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, false);
+            };
+            NormalModeFactory.prototype.interfaceDeclaration = function (modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body) {
+                return new TypeScript.InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, false);
+            };
+            NormalModeFactory.prototype.heritageClause = function (kind, extendsOrImplementsKeyword, typeNames) {
+                return new TypeScript.HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, false);
+            };
+            NormalModeFactory.prototype.moduleDeclaration = function (modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken) {
+                return new TypeScript.ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, false);
+            };
+            NormalModeFactory.prototype.functionDeclaration = function (modifiers, functionKeyword, identifier, callSignature, block, semicolonToken) {
+                return new TypeScript.FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.variableStatement = function (modifiers, variableDeclaration, semicolonToken) {
+                return new TypeScript.VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.variableDeclaration = function (varKeyword, variableDeclarators) {
+                return new TypeScript.VariableDeclarationSyntax(varKeyword, variableDeclarators, false);
+            };
+            NormalModeFactory.prototype.variableDeclarator = function (propertyName, typeAnnotation, equalsValueClause) {
+                return new TypeScript.VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, false);
+            };
+            NormalModeFactory.prototype.equalsValueClause = function (equalsToken, value) {
+                return new TypeScript.EqualsValueClauseSyntax(equalsToken, value, false);
+            };
+            NormalModeFactory.prototype.prefixUnaryExpression = function (kind, operatorToken, operand) {
+                return new TypeScript.PrefixUnaryExpressionSyntax(kind, operatorToken, operand, false);
+            };
+            NormalModeFactory.prototype.arrayLiteralExpression = function (openBracketToken, expressions, closeBracketToken) {
+                return new TypeScript.ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, false);
+            };
+            NormalModeFactory.prototype.omittedExpression = function () {
+                return new TypeScript.OmittedExpressionSyntax(false);
+            };
+            NormalModeFactory.prototype.parenthesizedExpression = function (openParenToken, expression, closeParenToken) {
+                return new TypeScript.ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, false);
+            };
+            NormalModeFactory.prototype.simpleArrowFunctionExpression = function (identifier, equalsGreaterThanToken, block, expression) {
+                return new TypeScript.SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, false);
+            };
+            NormalModeFactory.prototype.parenthesizedArrowFunctionExpression = function (callSignature, equalsGreaterThanToken, block, expression) {
+                return new TypeScript.ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, false);
+            };
+            NormalModeFactory.prototype.qualifiedName = function (left, dotToken, right) {
+                return new TypeScript.QualifiedNameSyntax(left, dotToken, right, false);
+            };
+            NormalModeFactory.prototype.typeArgumentList = function (lessThanToken, typeArguments, greaterThanToken) {
+                return new TypeScript.TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, false);
+            };
+            NormalModeFactory.prototype.constructorType = function (newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type) {
+                return new TypeScript.ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, false);
+            };
+            NormalModeFactory.prototype.functionType = function (typeParameterList, parameterList, equalsGreaterThanToken, type) {
+                return new TypeScript.FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, false);
+            };
+            NormalModeFactory.prototype.objectType = function (openBraceToken, typeMembers, closeBraceToken) {
+                return new TypeScript.ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, false);
+            };
+            NormalModeFactory.prototype.arrayType = function (type, openBracketToken, closeBracketToken) {
+                return new TypeScript.ArrayTypeSyntax(type, openBracketToken, closeBracketToken, false);
+            };
+            NormalModeFactory.prototype.genericType = function (name, typeArgumentList) {
+                return new TypeScript.GenericTypeSyntax(name, typeArgumentList, false);
+            };
+            NormalModeFactory.prototype.typeQuery = function (typeOfKeyword, name) {
+                return new TypeScript.TypeQuerySyntax(typeOfKeyword, name, false);
+            };
+            NormalModeFactory.prototype.typeAnnotation = function (colonToken, type) {
+                return new TypeScript.TypeAnnotationSyntax(colonToken, type, false);
+            };
+            NormalModeFactory.prototype.block = function (openBraceToken, statements, closeBraceToken) {
+                return new TypeScript.BlockSyntax(openBraceToken, statements, closeBraceToken, false);
+            };
+            NormalModeFactory.prototype.parameter = function (dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) {
+                return new TypeScript.ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, false);
+            };
+            NormalModeFactory.prototype.memberAccessExpression = function (expression, dotToken, name) {
+                return new TypeScript.MemberAccessExpressionSyntax(expression, dotToken, name, false);
+            };
+            NormalModeFactory.prototype.postfixUnaryExpression = function (kind, operand, operatorToken) {
+                return new TypeScript.PostfixUnaryExpressionSyntax(kind, operand, operatorToken, false);
+            };
+            NormalModeFactory.prototype.elementAccessExpression = function (expression, openBracketToken, argumentExpression, closeBracketToken) {
+                return new TypeScript.ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, false);
+            };
+            NormalModeFactory.prototype.invocationExpression = function (expression, argumentList) {
+                return new TypeScript.InvocationExpressionSyntax(expression, argumentList, false);
+            };
+            NormalModeFactory.prototype.argumentList = function (typeArgumentList, openParenToken, _arguments, closeParenToken) {
+                return new TypeScript.ArgumentListSyntax(typeArgumentList, openParenToken, _arguments, closeParenToken, false);
+            };
+            NormalModeFactory.prototype.binaryExpression = function (kind, left, operatorToken, right) {
+                return new TypeScript.BinaryExpressionSyntax(kind, left, operatorToken, right, false);
+            };
+            NormalModeFactory.prototype.conditionalExpression = function (condition, questionToken, whenTrue, colonToken, whenFalse) {
+                return new TypeScript.ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, false);
+            };
+            NormalModeFactory.prototype.constructSignature = function (newKeyword, callSignature) {
+                return new TypeScript.ConstructSignatureSyntax(newKeyword, callSignature, false);
+            };
+            NormalModeFactory.prototype.methodSignature = function (propertyName, questionToken, callSignature) {
+                return new TypeScript.MethodSignatureSyntax(propertyName, questionToken, callSignature, false);
+            };
+            NormalModeFactory.prototype.indexSignature = function (openBracketToken, parameter, closeBracketToken, typeAnnotation) {
+                return new TypeScript.IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, false);
+            };
+            NormalModeFactory.prototype.propertySignature = function (propertyName, questionToken, typeAnnotation) {
+                return new TypeScript.PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, false);
+            };
+            NormalModeFactory.prototype.callSignature = function (typeParameterList, parameterList, typeAnnotation) {
+                return new TypeScript.CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, false);
+            };
+            NormalModeFactory.prototype.parameterList = function (openParenToken, parameters, closeParenToken) {
+                return new TypeScript.ParameterListSyntax(openParenToken, parameters, closeParenToken, false);
+            };
+            NormalModeFactory.prototype.typeParameterList = function (lessThanToken, typeParameters, greaterThanToken) {
+                return new TypeScript.TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, false);
+            };
+            NormalModeFactory.prototype.typeParameter = function (identifier, constraint) {
+                return new TypeScript.TypeParameterSyntax(identifier, constraint, false);
+            };
+            NormalModeFactory.prototype.constraint = function (extendsKeyword, type) {
+                return new TypeScript.ConstraintSyntax(extendsKeyword, type, false);
+            };
+            NormalModeFactory.prototype.elseClause = function (elseKeyword, statement) {
+                return new TypeScript.ElseClauseSyntax(elseKeyword, statement, false);
+            };
+            NormalModeFactory.prototype.ifStatement = function (ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause) {
+                return new TypeScript.IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, false);
+            };
+            NormalModeFactory.prototype.expressionStatement = function (expression, semicolonToken) {
+                return new TypeScript.ExpressionStatementSyntax(expression, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.constructorDeclaration = function (modifiers, constructorKeyword, callSignature, block, semicolonToken) {
+                return new TypeScript.ConstructorDeclarationSyntax(modifiers, constructorKeyword, callSignature, block, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.memberFunctionDeclaration = function (modifiers, propertyName, callSignature, block, semicolonToken) {
+                return new TypeScript.MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.getAccessor = function (modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block) {
+                return new TypeScript.GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, false);
+            };
+            NormalModeFactory.prototype.setAccessor = function (modifiers, setKeyword, propertyName, parameterList, block) {
+                return new TypeScript.SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, false);
+            };
+            NormalModeFactory.prototype.memberVariableDeclaration = function (modifiers, variableDeclarator, semicolonToken) {
+                return new TypeScript.MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.indexMemberDeclaration = function (modifiers, indexSignature, semicolonToken) {
+                return new TypeScript.IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.throwStatement = function (throwKeyword, expression, semicolonToken) {
+                return new TypeScript.ThrowStatementSyntax(throwKeyword, expression, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.returnStatement = function (returnKeyword, expression, semicolonToken) {
+                return new TypeScript.ReturnStatementSyntax(returnKeyword, expression, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.objectCreationExpression = function (newKeyword, expression, argumentList) {
+                return new TypeScript.ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, false);
+            };
+            NormalModeFactory.prototype.switchStatement = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken) {
+                return new TypeScript.SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, false);
+            };
+            NormalModeFactory.prototype.caseSwitchClause = function (caseKeyword, expression, colonToken, statements) {
+                return new TypeScript.CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, false);
+            };
+            NormalModeFactory.prototype.defaultSwitchClause = function (defaultKeyword, colonToken, statements) {
+                return new TypeScript.DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, false);
+            };
+            NormalModeFactory.prototype.breakStatement = function (breakKeyword, identifier, semicolonToken) {
+                return new TypeScript.BreakStatementSyntax(breakKeyword, identifier, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.continueStatement = function (continueKeyword, identifier, semicolonToken) {
+                return new TypeScript.ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.forStatement = function (forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement) {
+                return new TypeScript.ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, false);
+            };
+            NormalModeFactory.prototype.forInStatement = function (forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement) {
+                return new TypeScript.ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, false);
+            };
+            NormalModeFactory.prototype.whileStatement = function (whileKeyword, openParenToken, condition, closeParenToken, statement) {
+                return new TypeScript.WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, false);
+            };
+            NormalModeFactory.prototype.withStatement = function (withKeyword, openParenToken, condition, closeParenToken, statement) {
+                return new TypeScript.WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, false);
+            };
+            NormalModeFactory.prototype.enumDeclaration = function (modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken) {
+                return new TypeScript.EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, false);
+            };
+            NormalModeFactory.prototype.enumElement = function (propertyName, equalsValueClause) {
+                return new TypeScript.EnumElementSyntax(propertyName, equalsValueClause, false);
+            };
+            NormalModeFactory.prototype.castExpression = function (lessThanToken, type, greaterThanToken, expression) {
+                return new TypeScript.CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, false);
+            };
+            NormalModeFactory.prototype.objectLiteralExpression = function (openBraceToken, propertyAssignments, closeBraceToken) {
+                return new TypeScript.ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, false);
+            };
+            NormalModeFactory.prototype.simplePropertyAssignment = function (propertyName, colonToken, expression) {
+                return new TypeScript.SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, false);
+            };
+            NormalModeFactory.prototype.functionPropertyAssignment = function (propertyName, callSignature, block) {
+                return new TypeScript.FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, false);
+            };
+            NormalModeFactory.prototype.functionExpression = function (functionKeyword, identifier, callSignature, block) {
+                return new TypeScript.FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, false);
+            };
+            NormalModeFactory.prototype.emptyStatement = function (semicolonToken) {
+                return new TypeScript.EmptyStatementSyntax(semicolonToken, false);
+            };
+            NormalModeFactory.prototype.tryStatement = function (tryKeyword, block, catchClause, finallyClause) {
+                return new TypeScript.TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, false);
+            };
+            NormalModeFactory.prototype.catchClause = function (catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block) {
+                return new TypeScript.CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, false);
+            };
+            NormalModeFactory.prototype.finallyClause = function (finallyKeyword, block) {
+                return new TypeScript.FinallyClauseSyntax(finallyKeyword, block, false);
+            };
+            NormalModeFactory.prototype.labeledStatement = function (identifier, colonToken, statement) {
+                return new TypeScript.LabeledStatementSyntax(identifier, colonToken, statement, false);
+            };
+            NormalModeFactory.prototype.doStatement = function (doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken) {
+                return new TypeScript.DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, false);
+            };
+            NormalModeFactory.prototype.typeOfExpression = function (typeOfKeyword, expression) {
+                return new TypeScript.TypeOfExpressionSyntax(typeOfKeyword, expression, false);
+            };
+            NormalModeFactory.prototype.deleteExpression = function (deleteKeyword, expression) {
+                return new TypeScript.DeleteExpressionSyntax(deleteKeyword, expression, false);
+            };
+            NormalModeFactory.prototype.voidExpression = function (voidKeyword, expression) {
+                return new TypeScript.VoidExpressionSyntax(voidKeyword, expression, false);
+            };
+            NormalModeFactory.prototype.debuggerStatement = function (debuggerKeyword, semicolonToken) {
+                return new TypeScript.DebuggerStatementSyntax(debuggerKeyword, semicolonToken, false);
+            };
+            return NormalModeFactory;
+        })();
+        Syntax.NormalModeFactory = NormalModeFactory;
+
+        var StrictModeFactory = (function () {
+            function StrictModeFactory() {
+            }
+            StrictModeFactory.prototype.sourceUnit = function (moduleElements, endOfFileToken) {
+                return new TypeScript.SourceUnitSyntax(moduleElements, endOfFileToken, true);
+            };
+            StrictModeFactory.prototype.externalModuleReference = function (requireKeyword, openParenToken, stringLiteral, closeParenToken) {
+                return new TypeScript.ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, true);
+            };
+            StrictModeFactory.prototype.moduleNameModuleReference = function (moduleName) {
+                return new TypeScript.ModuleNameModuleReferenceSyntax(moduleName, true);
+            };
+            StrictModeFactory.prototype.importDeclaration = function (modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken) {
+                return new TypeScript.ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.exportAssignment = function (exportKeyword, equalsToken, identifier, semicolonToken) {
+                return new TypeScript.ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.classDeclaration = function (modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken) {
+                return new TypeScript.ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, true);
+            };
+            StrictModeFactory.prototype.interfaceDeclaration = function (modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body) {
+                return new TypeScript.InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, true);
+            };
+            StrictModeFactory.prototype.heritageClause = function (kind, extendsOrImplementsKeyword, typeNames) {
+                return new TypeScript.HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, true);
+            };
+            StrictModeFactory.prototype.moduleDeclaration = function (modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken) {
+                return new TypeScript.ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, true);
+            };
+            StrictModeFactory.prototype.functionDeclaration = function (modifiers, functionKeyword, identifier, callSignature, block, semicolonToken) {
+                return new TypeScript.FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.variableStatement = function (modifiers, variableDeclaration, semicolonToken) {
+                return new TypeScript.VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.variableDeclaration = function (varKeyword, variableDeclarators) {
+                return new TypeScript.VariableDeclarationSyntax(varKeyword, variableDeclarators, true);
+            };
+            StrictModeFactory.prototype.variableDeclarator = function (propertyName, typeAnnotation, equalsValueClause) {
+                return new TypeScript.VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, true);
+            };
+            StrictModeFactory.prototype.equalsValueClause = function (equalsToken, value) {
+                return new TypeScript.EqualsValueClauseSyntax(equalsToken, value, true);
+            };
+            StrictModeFactory.prototype.prefixUnaryExpression = function (kind, operatorToken, operand) {
+                return new TypeScript.PrefixUnaryExpressionSyntax(kind, operatorToken, operand, true);
+            };
+            StrictModeFactory.prototype.arrayLiteralExpression = function (openBracketToken, expressions, closeBracketToken) {
+                return new TypeScript.ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, true);
+            };
+            StrictModeFactory.prototype.omittedExpression = function () {
+                return new TypeScript.OmittedExpressionSyntax(true);
+            };
+            StrictModeFactory.prototype.parenthesizedExpression = function (openParenToken, expression, closeParenToken) {
+                return new TypeScript.ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, true);
+            };
+            StrictModeFactory.prototype.simpleArrowFunctionExpression = function (identifier, equalsGreaterThanToken, block, expression) {
+                return new TypeScript.SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, true);
+            };
+            StrictModeFactory.prototype.parenthesizedArrowFunctionExpression = function (callSignature, equalsGreaterThanToken, block, expression) {
+                return new TypeScript.ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, true);
+            };
+            StrictModeFactory.prototype.qualifiedName = function (left, dotToken, right) {
+                return new TypeScript.QualifiedNameSyntax(left, dotToken, right, true);
+            };
+            StrictModeFactory.prototype.typeArgumentList = function (lessThanToken, typeArguments, greaterThanToken) {
+                return new TypeScript.TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, true);
+            };
+            StrictModeFactory.prototype.constructorType = function (newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type) {
+                return new TypeScript.ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, true);
+            };
+            StrictModeFactory.prototype.functionType = function (typeParameterList, parameterList, equalsGreaterThanToken, type) {
+                return new TypeScript.FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, true);
+            };
+            StrictModeFactory.prototype.objectType = function (openBraceToken, typeMembers, closeBraceToken) {
+                return new TypeScript.ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, true);
+            };
+            StrictModeFactory.prototype.arrayType = function (type, openBracketToken, closeBracketToken) {
+                return new TypeScript.ArrayTypeSyntax(type, openBracketToken, closeBracketToken, true);
+            };
+            StrictModeFactory.prototype.genericType = function (name, typeArgumentList) {
+                return new TypeScript.GenericTypeSyntax(name, typeArgumentList, true);
+            };
+            StrictModeFactory.prototype.typeQuery = function (typeOfKeyword, name) {
+                return new TypeScript.TypeQuerySyntax(typeOfKeyword, name, true);
+            };
+            StrictModeFactory.prototype.typeAnnotation = function (colonToken, type) {
+                return new TypeScript.TypeAnnotationSyntax(colonToken, type, true);
+            };
+            StrictModeFactory.prototype.block = function (openBraceToken, statements, closeBraceToken) {
+                return new TypeScript.BlockSyntax(openBraceToken, statements, closeBraceToken, true);
+            };
+            StrictModeFactory.prototype.parameter = function (dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) {
+                return new TypeScript.ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, true);
+            };
+            StrictModeFactory.prototype.memberAccessExpression = function (expression, dotToken, name) {
+                return new TypeScript.MemberAccessExpressionSyntax(expression, dotToken, name, true);
+            };
+            StrictModeFactory.prototype.postfixUnaryExpression = function (kind, operand, operatorToken) {
+                return new TypeScript.PostfixUnaryExpressionSyntax(kind, operand, operatorToken, true);
+            };
+            StrictModeFactory.prototype.elementAccessExpression = function (expression, openBracketToken, argumentExpression, closeBracketToken) {
+                return new TypeScript.ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, true);
+            };
+            StrictModeFactory.prototype.invocationExpression = function (expression, argumentList) {
+                return new TypeScript.InvocationExpressionSyntax(expression, argumentList, true);
+            };
+            StrictModeFactory.prototype.argumentList = function (typeArgumentList, openParenToken, _arguments, closeParenToken) {
+                return new TypeScript.ArgumentListSyntax(typeArgumentList, openParenToken, _arguments, closeParenToken, true);
+            };
+            StrictModeFactory.prototype.binaryExpression = function (kind, left, operatorToken, right) {
+                return new TypeScript.BinaryExpressionSyntax(kind, left, operatorToken, right, true);
+            };
+            StrictModeFactory.prototype.conditionalExpression = function (condition, questionToken, whenTrue, colonToken, whenFalse) {
+                return new TypeScript.ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, true);
+            };
+            StrictModeFactory.prototype.constructSignature = function (newKeyword, callSignature) {
+                return new TypeScript.ConstructSignatureSyntax(newKeyword, callSignature, true);
+            };
+            StrictModeFactory.prototype.methodSignature = function (propertyName, questionToken, callSignature) {
+                return new TypeScript.MethodSignatureSyntax(propertyName, questionToken, callSignature, true);
+            };
+            StrictModeFactory.prototype.indexSignature = function (openBracketToken, parameter, closeBracketToken, typeAnnotation) {
+                return new TypeScript.IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, true);
+            };
+            StrictModeFactory.prototype.propertySignature = function (propertyName, questionToken, typeAnnotation) {
+                return new TypeScript.PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, true);
+            };
+            StrictModeFactory.prototype.callSignature = function (typeParameterList, parameterList, typeAnnotation) {
+                return new TypeScript.CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, true);
+            };
+            StrictModeFactory.prototype.parameterList = function (openParenToken, parameters, closeParenToken) {
+                return new TypeScript.ParameterListSyntax(openParenToken, parameters, closeParenToken, true);
+            };
+            StrictModeFactory.prototype.typeParameterList = function (lessThanToken, typeParameters, greaterThanToken) {
+                return new TypeScript.TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, true);
+            };
+            StrictModeFactory.prototype.typeParameter = function (identifier, constraint) {
+                return new TypeScript.TypeParameterSyntax(identifier, constraint, true);
+            };
+            StrictModeFactory.prototype.constraint = function (extendsKeyword, type) {
+                return new TypeScript.ConstraintSyntax(extendsKeyword, type, true);
+            };
+            StrictModeFactory.prototype.elseClause = function (elseKeyword, statement) {
+                return new TypeScript.ElseClauseSyntax(elseKeyword, statement, true);
+            };
+            StrictModeFactory.prototype.ifStatement = function (ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause) {
+                return new TypeScript.IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, true);
+            };
+            StrictModeFactory.prototype.expressionStatement = function (expression, semicolonToken) {
+                return new TypeScript.ExpressionStatementSyntax(expression, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.constructorDeclaration = function (modifiers, constructorKeyword, callSignature, block, semicolonToken) {
+                return new TypeScript.ConstructorDeclarationSyntax(modifiers, constructorKeyword, callSignature, block, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.memberFunctionDeclaration = function (modifiers, propertyName, callSignature, block, semicolonToken) {
+                return new TypeScript.MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.getAccessor = function (modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block) {
+                return new TypeScript.GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, true);
+            };
+            StrictModeFactory.prototype.setAccessor = function (modifiers, setKeyword, propertyName, parameterList, block) {
+                return new TypeScript.SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, true);
+            };
+            StrictModeFactory.prototype.memberVariableDeclaration = function (modifiers, variableDeclarator, semicolonToken) {
+                return new TypeScript.MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.indexMemberDeclaration = function (modifiers, indexSignature, semicolonToken) {
+                return new TypeScript.IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.throwStatement = function (throwKeyword, expression, semicolonToken) {
+                return new TypeScript.ThrowStatementSyntax(throwKeyword, expression, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.returnStatement = function (returnKeyword, expression, semicolonToken) {
+                return new TypeScript.ReturnStatementSyntax(returnKeyword, expression, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.objectCreationExpression = function (newKeyword, expression, argumentList) {
+                return new TypeScript.ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, true);
+            };
+            StrictModeFactory.prototype.switchStatement = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken) {
+                return new TypeScript.SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, true);
+            };
+            StrictModeFactory.prototype.caseSwitchClause = function (caseKeyword, expression, colonToken, statements) {
+                return new TypeScript.CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, true);
+            };
+            StrictModeFactory.prototype.defaultSwitchClause = function (defaultKeyword, colonToken, statements) {
+                return new TypeScript.DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, true);
+            };
+            StrictModeFactory.prototype.breakStatement = function (breakKeyword, identifier, semicolonToken) {
+                return new TypeScript.BreakStatementSyntax(breakKeyword, identifier, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.continueStatement = function (continueKeyword, identifier, semicolonToken) {
+                return new TypeScript.ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.forStatement = function (forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement) {
+                return new TypeScript.ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, true);
+            };
+            StrictModeFactory.prototype.forInStatement = function (forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement) {
+                return new TypeScript.ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, true);
+            };
+            StrictModeFactory.prototype.whileStatement = function (whileKeyword, openParenToken, condition, closeParenToken, statement) {
+                return new TypeScript.WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, true);
+            };
+            StrictModeFactory.prototype.withStatement = function (withKeyword, openParenToken, condition, closeParenToken, statement) {
+                return new TypeScript.WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, true);
+            };
+            StrictModeFactory.prototype.enumDeclaration = function (modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken) {
+                return new TypeScript.EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, true);
+            };
+            StrictModeFactory.prototype.enumElement = function (propertyName, equalsValueClause) {
+                return new TypeScript.EnumElementSyntax(propertyName, equalsValueClause, true);
+            };
+            StrictModeFactory.prototype.castExpression = function (lessThanToken, type, greaterThanToken, expression) {
+                return new TypeScript.CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, true);
+            };
+            StrictModeFactory.prototype.objectLiteralExpression = function (openBraceToken, propertyAssignments, closeBraceToken) {
+                return new TypeScript.ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, true);
+            };
+            StrictModeFactory.prototype.simplePropertyAssignment = function (propertyName, colonToken, expression) {
+                return new TypeScript.SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, true);
+            };
+            StrictModeFactory.prototype.functionPropertyAssignment = function (propertyName, callSignature, block) {
+                return new TypeScript.FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, true);
+            };
+            StrictModeFactory.prototype.functionExpression = function (functionKeyword, identifier, callSignature, block) {
+                return new TypeScript.FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, true);
+            };
+            StrictModeFactory.prototype.emptyStatement = function (semicolonToken) {
+                return new TypeScript.EmptyStatementSyntax(semicolonToken, true);
+            };
+            StrictModeFactory.prototype.tryStatement = function (tryKeyword, block, catchClause, finallyClause) {
+                return new TypeScript.TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, true);
+            };
+            StrictModeFactory.prototype.catchClause = function (catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block) {
+                return new TypeScript.CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, true);
+            };
+            StrictModeFactory.prototype.finallyClause = function (finallyKeyword, block) {
+                return new TypeScript.FinallyClauseSyntax(finallyKeyword, block, true);
+            };
+            StrictModeFactory.prototype.labeledStatement = function (identifier, colonToken, statement) {
+                return new TypeScript.LabeledStatementSyntax(identifier, colonToken, statement, true);
+            };
+            StrictModeFactory.prototype.doStatement = function (doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken) {
+                return new TypeScript.DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, true);
+            };
+            StrictModeFactory.prototype.typeOfExpression = function (typeOfKeyword, expression) {
+                return new TypeScript.TypeOfExpressionSyntax(typeOfKeyword, expression, true);
+            };
+            StrictModeFactory.prototype.deleteExpression = function (deleteKeyword, expression) {
+                return new TypeScript.DeleteExpressionSyntax(deleteKeyword, expression, true);
+            };
+            StrictModeFactory.prototype.voidExpression = function (voidKeyword, expression) {
+                return new TypeScript.VoidExpressionSyntax(voidKeyword, expression, true);
+            };
+            StrictModeFactory.prototype.debuggerStatement = function (debuggerKeyword, semicolonToken) {
+                return new TypeScript.DebuggerStatementSyntax(debuggerKeyword, semicolonToken, true);
+            };
+            return StrictModeFactory;
+        })();
+        Syntax.StrictModeFactory = StrictModeFactory;
+
+        Syntax.normalModeFactory = new NormalModeFactory();
+        Syntax.strictModeFactory = new StrictModeFactory();
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (SyntaxFacts) {
+        function isDirectivePrologueElement(node) {
+            if (node.kind() === 149 /* ExpressionStatement */) {
+                var expressionStatement = node;
+                var expression = expressionStatement.expression;
+
+                if (expression.kind() === 14 /* StringLiteral */) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+        SyntaxFacts.isDirectivePrologueElement = isDirectivePrologueElement;
+
+        function isUseStrictDirective(node) {
+            var expressionStatement = node;
+            var stringLiteral = expressionStatement.expression;
+
+            var text = stringLiteral.text();
+            return text === '"use strict"' || text === "'use strict'";
+        }
+        SyntaxFacts.isUseStrictDirective = isUseStrictDirective;
+
+        function isIdentifierNameOrAnyKeyword(token) {
+            var tokenKind = token.tokenKind;
+            return tokenKind === 11 /* IdentifierName */ || SyntaxFacts.isAnyKeyword(tokenKind);
+        }
+        SyntaxFacts.isIdentifierNameOrAnyKeyword = isIdentifierNameOrAnyKeyword;
+    })(TypeScript.SyntaxFacts || (TypeScript.SyntaxFacts = {}));
+    var SyntaxFacts = TypeScript.SyntaxFacts;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        var EmptySyntaxList = (function () {
+            function EmptySyntaxList() {
+            }
+            EmptySyntaxList.prototype.kind = function () {
+                return 1 /* List */;
+            };
+
+            EmptySyntaxList.prototype.isNode = function () {
+                return false;
+            };
+            EmptySyntaxList.prototype.isToken = function () {
+                return false;
+            };
+            EmptySyntaxList.prototype.isList = function () {
+                return true;
+            };
+            EmptySyntaxList.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            EmptySyntaxList.prototype.toJSON = function (key) {
+                return [];
+            };
+
+            EmptySyntaxList.prototype.childCount = function () {
+                return 0;
+            };
+
+            EmptySyntaxList.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            };
+
+            EmptySyntaxList.prototype.toArray = function () {
+                return [];
+            };
+
+            EmptySyntaxList.prototype.collectTextElements = function (elements) {
+            };
+
+            EmptySyntaxList.prototype.firstToken = function () {
+                return null;
+            };
+
+            EmptySyntaxList.prototype.lastToken = function () {
+                return null;
+            };
+
+            EmptySyntaxList.prototype.fullWidth = function () {
+                return 0;
+            };
+
+            EmptySyntaxList.prototype.width = function () {
+                return 0;
+            };
+
+            EmptySyntaxList.prototype.leadingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            EmptySyntaxList.prototype.trailingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            EmptySyntaxList.prototype.leadingTriviaWidth = function () {
+                return 0;
+            };
+
+            EmptySyntaxList.prototype.trailingTriviaWidth = function () {
+                return 0;
+            };
+
+            EmptySyntaxList.prototype.fullText = function () {
+                return "";
+            };
+
+            EmptySyntaxList.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+
+            EmptySyntaxList.prototype.isIncrementallyUnusable = function () {
+                return false;
+            };
+
+            EmptySyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) {
+                throw TypeScript.Errors.invalidOperation();
+            };
+
+            EmptySyntaxList.prototype.insertChildrenInto = function (array, index) {
+            };
+            return EmptySyntaxList;
+        })();
+        Syntax.EmptySyntaxList = EmptySyntaxList;
+
+        Syntax.emptyList = new EmptySyntaxList();
+
+        var SingletonSyntaxList = (function () {
+            function SingletonSyntaxList(item) {
+                this.item = item;
+            }
+            SingletonSyntaxList.prototype.kind = function () {
+                return 1 /* List */;
+            };
+
+            SingletonSyntaxList.prototype.isToken = function () {
+                return false;
+            };
+            SingletonSyntaxList.prototype.isNode = function () {
+                return false;
+            };
+            SingletonSyntaxList.prototype.isList = function () {
+                return true;
+            };
+            SingletonSyntaxList.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            SingletonSyntaxList.prototype.toJSON = function (key) {
+                return [this.item];
+            };
+
+            SingletonSyntaxList.prototype.childCount = function () {
+                return 1;
+            };
+
+            SingletonSyntaxList.prototype.childAt = function (index) {
+                if (index !== 0) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.item;
+            };
+
+            SingletonSyntaxList.prototype.toArray = function () {
+                return [this.item];
+            };
+
+            SingletonSyntaxList.prototype.collectTextElements = function (elements) {
+                this.item.collectTextElements(elements);
+            };
+
+            SingletonSyntaxList.prototype.firstToken = function () {
+                return this.item.firstToken();
+            };
+
+            SingletonSyntaxList.prototype.lastToken = function () {
+                return this.item.lastToken();
+            };
+
+            SingletonSyntaxList.prototype.fullWidth = function () {
+                return this.item.fullWidth();
+            };
+
+            SingletonSyntaxList.prototype.width = function () {
+                return this.item.width();
+            };
+
+            SingletonSyntaxList.prototype.leadingTrivia = function () {
+                return this.item.leadingTrivia();
+            };
+
+            SingletonSyntaxList.prototype.trailingTrivia = function () {
+                return this.item.trailingTrivia();
+            };
+
+            SingletonSyntaxList.prototype.leadingTriviaWidth = function () {
+                return this.item.leadingTriviaWidth();
+            };
+
+            SingletonSyntaxList.prototype.trailingTriviaWidth = function () {
+                return this.item.trailingTriviaWidth();
+            };
+
+            SingletonSyntaxList.prototype.fullText = function () {
+                return this.item.fullText();
+            };
+
+            SingletonSyntaxList.prototype.isTypeScriptSpecific = function () {
+                return this.item.isTypeScriptSpecific();
+            };
+
+            SingletonSyntaxList.prototype.isIncrementallyUnusable = function () {
+                return this.item.isIncrementallyUnusable();
+            };
+
+            SingletonSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return this.item.findTokenInternal(new TypeScript.PositionedList(parent, this, fullStart), position, fullStart);
+            };
+
+            SingletonSyntaxList.prototype.insertChildrenInto = function (array, index) {
+                array.splice(index, 0, this.item);
+            };
+            return SingletonSyntaxList;
+        })();
+
+        var NormalSyntaxList = (function () {
+            function NormalSyntaxList(nodeOrTokens) {
+                this._data = 0;
+                this.nodeOrTokens = nodeOrTokens;
+            }
+            NormalSyntaxList.prototype.kind = function () {
+                return 1 /* List */;
+            };
+
+            NormalSyntaxList.prototype.isNode = function () {
+                return false;
+            };
+            NormalSyntaxList.prototype.isToken = function () {
+                return false;
+            };
+            NormalSyntaxList.prototype.isList = function () {
+                return true;
+            };
+            NormalSyntaxList.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            NormalSyntaxList.prototype.toJSON = function (key) {
+                return this.nodeOrTokens;
+            };
+
+            NormalSyntaxList.prototype.childCount = function () {
+                return this.nodeOrTokens.length;
+            };
+
+            NormalSyntaxList.prototype.childAt = function (index) {
+                if (index < 0 || index >= this.nodeOrTokens.length) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.nodeOrTokens[index];
+            };
+
+            NormalSyntaxList.prototype.toArray = function () {
+                return this.nodeOrTokens.slice(0);
+            };
+
+            NormalSyntaxList.prototype.collectTextElements = function (elements) {
+                for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) {
+                    var element = this.nodeOrTokens[i];
+                    element.collectTextElements(elements);
+                }
+            };
+
+            NormalSyntaxList.prototype.firstToken = function () {
+                for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) {
+                    var token = this.nodeOrTokens[i].firstToken();
+                    if (token !== null) {
+                        return token;
+                    }
+                }
+
+                return null;
+            };
+
+            NormalSyntaxList.prototype.lastToken = function () {
+                for (var i = this.nodeOrTokens.length - 1; i >= 0; i--) {
+                    var token = this.nodeOrTokens[i].lastToken();
+                    if (token !== null) {
+                        return token;
+                    }
+                }
+
+                return null;
+            };
+
+            NormalSyntaxList.prototype.fullText = function () {
+                var elements = new Array();
+                this.collectTextElements(elements);
+                return elements.join("");
+            };
+
+            NormalSyntaxList.prototype.isTypeScriptSpecific = function () {
+                for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) {
+                    if (this.nodeOrTokens[i].isTypeScriptSpecific()) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            NormalSyntaxList.prototype.isIncrementallyUnusable = function () {
+                return (this.data() & 2 /* NodeIncrementallyUnusableMask */) !== 0;
+            };
+
+            NormalSyntaxList.prototype.fullWidth = function () {
+                return this.data() >>> 3 /* NodeFullWidthShift */;
+            };
+
+            NormalSyntaxList.prototype.width = function () {
+                var fullWidth = this.fullWidth();
+                return fullWidth - this.leadingTriviaWidth() - this.trailingTriviaWidth();
+            };
+
+            NormalSyntaxList.prototype.leadingTrivia = function () {
+                return this.firstToken().leadingTrivia();
+            };
+
+            NormalSyntaxList.prototype.trailingTrivia = function () {
+                return this.lastToken().trailingTrivia();
+            };
+
+            NormalSyntaxList.prototype.leadingTriviaWidth = function () {
+                return this.firstToken().leadingTriviaWidth();
+            };
+
+            NormalSyntaxList.prototype.trailingTriviaWidth = function () {
+                return this.lastToken().trailingTriviaWidth();
+            };
+
+            NormalSyntaxList.prototype.computeData = function () {
+                var fullWidth = 0;
+                var isIncrementallyUnusable = false;
+
+                for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) {
+                    var node = this.nodeOrTokens[i];
+                    fullWidth += node.fullWidth();
+                    isIncrementallyUnusable = isIncrementallyUnusable || node.isIncrementallyUnusable();
+                }
+
+                return (fullWidth << 3 /* NodeFullWidthShift */) | (isIncrementallyUnusable ? 2 /* NodeIncrementallyUnusableMask */ : 0) | 1 /* NodeDataComputed */;
+            };
+
+            NormalSyntaxList.prototype.data = function () {
+                if ((this._data & 1 /* NodeDataComputed */) === 0) {
+                    this._data = this.computeData();
+                }
+
+                return this._data;
+            };
+
+            NormalSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) {
+                parent = new TypeScript.PositionedList(parent, this, fullStart);
+                for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) {
+                    var nodeOrToken = this.nodeOrTokens[i];
+
+                    var childWidth = nodeOrToken.fullWidth();
+                    if (position < childWidth) {
+                        return nodeOrToken.findTokenInternal(parent, position, fullStart);
+                    }
+
+                    position -= childWidth;
+                    fullStart += childWidth;
+                }
+
+                throw TypeScript.Errors.invalidOperation();
+            };
+
+            NormalSyntaxList.prototype.insertChildrenInto = function (array, index) {
+                if (index === 0) {
+                    array.unshift.apply(array, this.nodeOrTokens);
+                } else {
+                    array.splice.apply(array, [index, 0].concat(this.nodeOrTokens));
+                }
+            };
+            return NormalSyntaxList;
+        })();
+
+        function list(nodes) {
+            if (nodes === undefined || nodes === null || nodes.length === 0) {
+                return Syntax.emptyList;
+            }
+
+            if (nodes.length === 1) {
+                var item = nodes[0];
+                return new SingletonSyntaxList(item);
+            }
+
+            return new NormalSyntaxList(nodes);
+        }
+        Syntax.list = list;
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxNode = (function () {
+        function SyntaxNode(parsedInStrictMode) {
+            this._data = parsedInStrictMode ? 4 /* NodeParsedInStrictModeMask */ : 0;
+        }
+        SyntaxNode.prototype.isNode = function () {
+            return true;
+        };
+        SyntaxNode.prototype.isToken = function () {
+            return false;
+        };
+        SyntaxNode.prototype.isList = function () {
+            return false;
+        };
+        SyntaxNode.prototype.isSeparatedList = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.kind = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        SyntaxNode.prototype.childCount = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        SyntaxNode.prototype.childAt = function (slot) {
+            throw TypeScript.Errors.abstract();
+        };
+
+        SyntaxNode.prototype.firstToken = function () {
+            for (var i = 0, n = this.childCount(); i < n; i++) {
+                var element = this.childAt(i);
+
+                if (element !== null) {
+                    if (element.fullWidth() > 0 || element.kind() === 10 /* EndOfFileToken */) {
+                        return element.firstToken();
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        SyntaxNode.prototype.lastToken = function () {
+            for (var i = this.childCount() - 1; i >= 0; i--) {
+                var element = this.childAt(i);
+
+                if (element !== null) {
+                    if (element.fullWidth() > 0 || element.kind() === 10 /* EndOfFileToken */) {
+                        return element.lastToken();
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        SyntaxNode.prototype.insertChildrenInto = function (array, index) {
+            for (var i = this.childCount() - 1; i >= 0; i--) {
+                var element = this.childAt(i);
+
+                if (element !== null) {
+                    if (element.isNode() || element.isToken()) {
+                        array.splice(index, 0, element);
+                    } else if (element.isList()) {
+                        element.insertChildrenInto(array, index);
+                    } else if (element.isSeparatedList()) {
+                        element.insertChildrenInto(array, index);
+                    } else {
+                        throw TypeScript.Errors.invalidOperation();
+                    }
+                }
+            }
+        };
+
+        SyntaxNode.prototype.leadingTrivia = function () {
+            var firstToken = this.firstToken();
+            return firstToken ? firstToken.leadingTrivia() : TypeScript.Syntax.emptyTriviaList;
+        };
+
+        SyntaxNode.prototype.trailingTrivia = function () {
+            var lastToken = this.lastToken();
+            return lastToken ? lastToken.trailingTrivia() : TypeScript.Syntax.emptyTriviaList;
+        };
+
+        SyntaxNode.prototype.toJSON = function (key) {
+            var result = {
+                kind: TypeScript.SyntaxKind[this.kind()],
+                fullWidth: this.fullWidth()
+            };
+
+            if (this.isIncrementallyUnusable()) {
+                result.isIncrementallyUnusable = true;
+            }
+
+            if (this.parsedInStrictMode()) {
+                result.parsedInStrictMode = true;
+            }
+
+            var thisAsIndexable = this;
+            for (var i = 0, n = this.childCount(); i < n; i++) {
+                var value = this.childAt(i);
+
+                if (value) {
+                    for (var name in this) {
+                        if (value === thisAsIndexable[name]) {
+                            result[name] = value;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            return result;
+        };
+
+        SyntaxNode.prototype.accept = function (visitor) {
+            throw TypeScript.Errors.abstract();
+        };
+
+        SyntaxNode.prototype.fullText = function () {
+            var elements = [];
+            this.collectTextElements(elements);
+            return elements.join("");
+        };
+
+        SyntaxNode.prototype.collectTextElements = function (elements) {
+            for (var i = 0, n = this.childCount(); i < n; i++) {
+                var element = this.childAt(i);
+
+                if (element !== null) {
+                    element.collectTextElements(elements);
+                }
+            }
+        };
+
+        SyntaxNode.prototype.replaceToken = function (token1, token2) {
+            if (token1 === token2) {
+                return this;
+            }
+
+            return this.accept(new TypeScript.SyntaxTokenReplacer(token1, token2));
+        };
+
+        SyntaxNode.prototype.withLeadingTrivia = function (trivia) {
+            return this.replaceToken(this.firstToken(), this.firstToken().withLeadingTrivia(trivia));
+        };
+
+        SyntaxNode.prototype.withTrailingTrivia = function (trivia) {
+            return this.replaceToken(this.lastToken(), this.lastToken().withTrailingTrivia(trivia));
+        };
+
+        SyntaxNode.prototype.hasLeadingTrivia = function () {
+            return this.lastToken().hasLeadingTrivia();
+        };
+
+        SyntaxNode.prototype.hasTrailingTrivia = function () {
+            return this.lastToken().hasTrailingTrivia();
+        };
+
+        SyntaxNode.prototype.isTypeScriptSpecific = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.isIncrementallyUnusable = function () {
+            return (this.data() & 2 /* NodeIncrementallyUnusableMask */) !== 0;
+        };
+
+        SyntaxNode.prototype.parsedInStrictMode = function () {
+            return (this.data() & 4 /* NodeParsedInStrictModeMask */) !== 0;
+        };
+
+        SyntaxNode.prototype.fullWidth = function () {
+            return this.data() >>> 3 /* NodeFullWidthShift */;
+        };
+
+        SyntaxNode.prototype.computeData = function () {
+            var slotCount = this.childCount();
+
+            var fullWidth = 0;
+            var childWidth = 0;
+
+            var isIncrementallyUnusable = ((this._data & 2 /* NodeIncrementallyUnusableMask */) !== 0) || slotCount === 0;
+
+            for (var i = 0, n = slotCount; i < n; i++) {
+                var element = this.childAt(i);
+
+                if (element !== null) {
+                    childWidth = element.fullWidth();
+                    fullWidth += childWidth;
+
+                    if (!isIncrementallyUnusable) {
+                        isIncrementallyUnusable = element.isIncrementallyUnusable();
+                    }
+                }
+            }
+
+            return (fullWidth << 3 /* NodeFullWidthShift */) | (isIncrementallyUnusable ? 2 /* NodeIncrementallyUnusableMask */ : 0) | 1 /* NodeDataComputed */;
+        };
+
+        SyntaxNode.prototype.data = function () {
+            if ((this._data & 1 /* NodeDataComputed */) === 0) {
+                this._data |= this.computeData();
+            }
+
+            return this._data;
+        };
+
+        SyntaxNode.prototype.findToken = function (position, includeSkippedTokens) {
+            if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; }
+            var endOfFileToken = this.tryGetEndOfFileAt(position);
+            if (endOfFileToken !== null) {
+                return endOfFileToken;
+            }
+
+            if (position < 0 || position >= this.fullWidth()) {
+                throw TypeScript.Errors.argumentOutOfRange("position");
+            }
+
+            var positionedToken = this.findTokenInternal(null, position, 0);
+
+            if (includeSkippedTokens) {
+                return TypeScript.Syntax.findSkippedTokenInPositionedToken(positionedToken, position) || positionedToken;
+            }
+
+            return positionedToken;
+        };
+
+        SyntaxNode.prototype.tryGetEndOfFileAt = function (position) {
+            if (this.kind() === 120 /* SourceUnit */ && position === this.fullWidth()) {
+                var sourceUnit = this;
+                return new TypeScript.PositionedToken(new TypeScript.PositionedNode(null, sourceUnit, 0), sourceUnit.endOfFileToken, sourceUnit.moduleElements.fullWidth());
+            }
+
+            return null;
+        };
+
+        SyntaxNode.prototype.findTokenInternal = function (parent, position, fullStart) {
+            parent = new TypeScript.PositionedNode(parent, this, fullStart);
+            for (var i = 0, n = this.childCount(); i < n; i++) {
+                var element = this.childAt(i);
+
+                if (element !== null) {
+                    var childWidth = element.fullWidth();
+
+                    if (position < childWidth) {
+                        return element.findTokenInternal(parent, position, fullStart);
+                    }
+
+                    position -= childWidth;
+                    fullStart += childWidth;
+                }
+            }
+
+            throw TypeScript.Errors.invalidOperation();
+        };
+
+        SyntaxNode.prototype.findTokenOnLeft = function (position, includeSkippedTokens) {
+            if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; }
+            var positionedToken = this.findToken(position, false);
+            var start = positionedToken.start();
+
+            if (includeSkippedTokens) {
+                positionedToken = TypeScript.Syntax.findSkippedTokenOnLeft(positionedToken, position) || positionedToken;
+            }
+
+            if (position > start) {
+                return positionedToken;
+            }
+
+            if (positionedToken.fullStart() === 0) {
+                return null;
+            }
+
+            return positionedToken.previousToken(includeSkippedTokens);
+        };
+
+        SyntaxNode.prototype.findCompleteTokenOnLeft = function (position, includeSkippedTokens) {
+            if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; }
+            var positionedToken = this.findToken(position, false);
+
+            if (includeSkippedTokens) {
+                positionedToken = TypeScript.Syntax.findSkippedTokenOnLeft(positionedToken, position) || positionedToken;
+            }
+
+            if (positionedToken.token().width() > 0 && position >= positionedToken.end()) {
+                return positionedToken;
+            }
+
+            return positionedToken.previousToken(includeSkippedTokens);
+        };
+
+        SyntaxNode.prototype.isModuleElement = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.isClassElement = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.isTypeMember = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.isStatement = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.isExpression = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.isSwitchClause = function () {
+            return false;
+        };
+
+        SyntaxNode.prototype.structuralEquals = function (node) {
+            if (this === node) {
+                return true;
+            }
+            if (node === null) {
+                return false;
+            }
+            if (this.kind() !== node.kind()) {
+                return false;
+            }
+
+            for (var i = 0, n = this.childCount(); i < n; i++) {
+                var element1 = this.childAt(i);
+                var element2 = node.childAt(i);
+
+                if (!TypeScript.Syntax.elementStructuralEquals(element1, element2)) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        SyntaxNode.prototype.width = function () {
+            return this.fullWidth() - this.leadingTriviaWidth() - this.trailingTriviaWidth();
+        };
+
+        SyntaxNode.prototype.leadingTriviaWidth = function () {
+            var firstToken = this.firstToken();
+            return firstToken === null ? 0 : firstToken.leadingTriviaWidth();
+        };
+
+        SyntaxNode.prototype.trailingTriviaWidth = function () {
+            var lastToken = this.lastToken();
+            return lastToken === null ? 0 : lastToken.trailingTriviaWidth();
+        };
+        return SyntaxNode;
+    })();
+    TypeScript.SyntaxNode = SyntaxNode;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SourceUnitSyntax = (function (_super) {
+        __extends(SourceUnitSyntax, _super);
+        function SourceUnitSyntax(moduleElements, endOfFileToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.moduleElements = moduleElements;
+            this.endOfFileToken = endOfFileToken;
+        }
+        SourceUnitSyntax.prototype.accept = function (visitor) {
+            return visitor.visitSourceUnit(this);
+        };
+
+        SourceUnitSyntax.prototype.kind = function () {
+            return 120 /* SourceUnit */;
+        };
+
+        SourceUnitSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        SourceUnitSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.moduleElements;
+                case 1:
+                    return this.endOfFileToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        SourceUnitSyntax.prototype.update = function (moduleElements, endOfFileToken) {
+            if (this.moduleElements === moduleElements && this.endOfFileToken === endOfFileToken) {
+                return this;
+            }
+
+            return new SourceUnitSyntax(moduleElements, endOfFileToken, this.parsedInStrictMode());
+        };
+
+        SourceUnitSyntax.create = function (endOfFileToken) {
+            return new SourceUnitSyntax(TypeScript.Syntax.emptyList, endOfFileToken, false);
+        };
+
+        SourceUnitSyntax.create1 = function (endOfFileToken) {
+            return new SourceUnitSyntax(TypeScript.Syntax.emptyList, endOfFileToken, false);
+        };
+
+        SourceUnitSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        SourceUnitSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        SourceUnitSyntax.prototype.withModuleElements = function (moduleElements) {
+            return this.update(moduleElements, this.endOfFileToken);
+        };
+
+        SourceUnitSyntax.prototype.withModuleElement = function (moduleElement) {
+            return this.withModuleElements(TypeScript.Syntax.list([moduleElement]));
+        };
+
+        SourceUnitSyntax.prototype.withEndOfFileToken = function (endOfFileToken) {
+            return this.update(this.moduleElements, endOfFileToken);
+        };
+
+        SourceUnitSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.moduleElements.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return SourceUnitSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.SourceUnitSyntax = SourceUnitSyntax;
+
+    var ExternalModuleReferenceSyntax = (function (_super) {
+        __extends(ExternalModuleReferenceSyntax, _super);
+        function ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.requireKeyword = requireKeyword;
+            this.openParenToken = openParenToken;
+            this.stringLiteral = stringLiteral;
+            this.closeParenToken = closeParenToken;
+        }
+        ExternalModuleReferenceSyntax.prototype.accept = function (visitor) {
+            return visitor.visitExternalModuleReference(this);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.kind = function () {
+            return 245 /* ExternalModuleReference */;
+        };
+
+        ExternalModuleReferenceSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        ExternalModuleReferenceSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.requireKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.stringLiteral;
+                case 3:
+                    return this.closeParenToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ExternalModuleReferenceSyntax.prototype.isModuleReference = function () {
+            return true;
+        };
+
+        ExternalModuleReferenceSyntax.prototype.update = function (requireKeyword, openParenToken, stringLiteral, closeParenToken) {
+            if (this.requireKeyword === requireKeyword && this.openParenToken === openParenToken && this.stringLiteral === stringLiteral && this.closeParenToken === closeParenToken) {
+                return this;
+            }
+
+            return new ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, this.parsedInStrictMode());
+        };
+
+        ExternalModuleReferenceSyntax.create1 = function (stringLiteral) {
+            return new ExternalModuleReferenceSyntax(TypeScript.Syntax.token(66 /* RequireKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), stringLiteral, TypeScript.Syntax.token(73 /* CloseParenToken */), false);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.withRequireKeyword = function (requireKeyword) {
+            return this.update(requireKeyword, this.openParenToken, this.stringLiteral, this.closeParenToken);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.requireKeyword, openParenToken, this.stringLiteral, this.closeParenToken);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.withStringLiteral = function (stringLiteral) {
+            return this.update(this.requireKeyword, this.openParenToken, stringLiteral, this.closeParenToken);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.requireKeyword, this.openParenToken, this.stringLiteral, closeParenToken);
+        };
+
+        ExternalModuleReferenceSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ExternalModuleReferenceSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ExternalModuleReferenceSyntax = ExternalModuleReferenceSyntax;
+
+    var ModuleNameModuleReferenceSyntax = (function (_super) {
+        __extends(ModuleNameModuleReferenceSyntax, _super);
+        function ModuleNameModuleReferenceSyntax(moduleName, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.moduleName = moduleName;
+        }
+        ModuleNameModuleReferenceSyntax.prototype.accept = function (visitor) {
+            return visitor.visitModuleNameModuleReference(this);
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.kind = function () {
+            return 246 /* ModuleNameModuleReference */;
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.childCount = function () {
+            return 1;
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.moduleName;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.isModuleReference = function () {
+            return true;
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.update = function (moduleName) {
+            if (this.moduleName === moduleName) {
+                return this;
+            }
+
+            return new ModuleNameModuleReferenceSyntax(moduleName, this.parsedInStrictMode());
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.withModuleName = function (moduleName) {
+            return this.update(moduleName);
+        };
+
+        ModuleNameModuleReferenceSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ModuleNameModuleReferenceSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ModuleNameModuleReferenceSyntax = ModuleNameModuleReferenceSyntax;
+
+    var ImportDeclarationSyntax = (function (_super) {
+        __extends(ImportDeclarationSyntax, _super);
+        function ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.importKeyword = importKeyword;
+            this.identifier = identifier;
+            this.equalsToken = equalsToken;
+            this.moduleReference = moduleReference;
+            this.semicolonToken = semicolonToken;
+        }
+        ImportDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitImportDeclaration(this);
+        };
+
+        ImportDeclarationSyntax.prototype.kind = function () {
+            return 133 /* ImportDeclaration */;
+        };
+
+        ImportDeclarationSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        ImportDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.importKeyword;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.equalsToken;
+                case 4:
+                    return this.moduleReference;
+                case 5:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ImportDeclarationSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ImportDeclarationSyntax.prototype.update = function (modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken) {
+            if (this.modifiers === modifiers && this.importKeyword === importKeyword && this.identifier === identifier && this.equalsToken === equalsToken && this.moduleReference === moduleReference && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, this.parsedInStrictMode());
+        };
+
+        ImportDeclarationSyntax.create = function (importKeyword, identifier, equalsToken, moduleReference, semicolonToken) {
+            return new ImportDeclarationSyntax(TypeScript.Syntax.emptyList, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, false);
+        };
+
+        ImportDeclarationSyntax.create1 = function (identifier, moduleReference) {
+            return new ImportDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(49 /* ImportKeyword */), identifier, TypeScript.Syntax.token(107 /* EqualsToken */), moduleReference, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        ImportDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ImportDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ImportDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.importKeyword, this.identifier, this.equalsToken, this.moduleReference, this.semicolonToken);
+        };
+
+        ImportDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        ImportDeclarationSyntax.prototype.withImportKeyword = function (importKeyword) {
+            return this.update(this.modifiers, importKeyword, this.identifier, this.equalsToken, this.moduleReference, this.semicolonToken);
+        };
+
+        ImportDeclarationSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.modifiers, this.importKeyword, identifier, this.equalsToken, this.moduleReference, this.semicolonToken);
+        };
+
+        ImportDeclarationSyntax.prototype.withEqualsToken = function (equalsToken) {
+            return this.update(this.modifiers, this.importKeyword, this.identifier, equalsToken, this.moduleReference, this.semicolonToken);
+        };
+
+        ImportDeclarationSyntax.prototype.withModuleReference = function (moduleReference) {
+            return this.update(this.modifiers, this.importKeyword, this.identifier, this.equalsToken, moduleReference, this.semicolonToken);
+        };
+
+        ImportDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.modifiers, this.importKeyword, this.identifier, this.equalsToken, this.moduleReference, semicolonToken);
+        };
+
+        ImportDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ImportDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ImportDeclarationSyntax = ImportDeclarationSyntax;
+
+    var ExportAssignmentSyntax = (function (_super) {
+        __extends(ExportAssignmentSyntax, _super);
+        function ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.exportKeyword = exportKeyword;
+            this.equalsToken = equalsToken;
+            this.identifier = identifier;
+            this.semicolonToken = semicolonToken;
+        }
+        ExportAssignmentSyntax.prototype.accept = function (visitor) {
+            return visitor.visitExportAssignment(this);
+        };
+
+        ExportAssignmentSyntax.prototype.kind = function () {
+            return 134 /* ExportAssignment */;
+        };
+
+        ExportAssignmentSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        ExportAssignmentSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.exportKeyword;
+                case 1:
+                    return this.equalsToken;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ExportAssignmentSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ExportAssignmentSyntax.prototype.update = function (exportKeyword, equalsToken, identifier, semicolonToken) {
+            if (this.exportKeyword === exportKeyword && this.equalsToken === equalsToken && this.identifier === identifier && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, this.parsedInStrictMode());
+        };
+
+        ExportAssignmentSyntax.create1 = function (identifier) {
+            return new ExportAssignmentSyntax(TypeScript.Syntax.token(47 /* ExportKeyword */), TypeScript.Syntax.token(107 /* EqualsToken */), identifier, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        ExportAssignmentSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ExportAssignmentSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ExportAssignmentSyntax.prototype.withExportKeyword = function (exportKeyword) {
+            return this.update(exportKeyword, this.equalsToken, this.identifier, this.semicolonToken);
+        };
+
+        ExportAssignmentSyntax.prototype.withEqualsToken = function (equalsToken) {
+            return this.update(this.exportKeyword, equalsToken, this.identifier, this.semicolonToken);
+        };
+
+        ExportAssignmentSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.exportKeyword, this.equalsToken, identifier, this.semicolonToken);
+        };
+
+        ExportAssignmentSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.exportKeyword, this.equalsToken, this.identifier, semicolonToken);
+        };
+
+        ExportAssignmentSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ExportAssignmentSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ExportAssignmentSyntax = ExportAssignmentSyntax;
+
+    var ClassDeclarationSyntax = (function (_super) {
+        __extends(ClassDeclarationSyntax, _super);
+        function ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.classKeyword = classKeyword;
+            this.identifier = identifier;
+            this.typeParameterList = typeParameterList;
+            this.heritageClauses = heritageClauses;
+            this.openBraceToken = openBraceToken;
+            this.classElements = classElements;
+            this.closeBraceToken = closeBraceToken;
+        }
+        ClassDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitClassDeclaration(this);
+        };
+
+        ClassDeclarationSyntax.prototype.kind = function () {
+            return 131 /* ClassDeclaration */;
+        };
+
+        ClassDeclarationSyntax.prototype.childCount = function () {
+            return 8;
+        };
+
+        ClassDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.classKeyword;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.typeParameterList;
+                case 4:
+                    return this.heritageClauses;
+                case 5:
+                    return this.openBraceToken;
+                case 6:
+                    return this.classElements;
+                case 7:
+                    return this.closeBraceToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ClassDeclarationSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ClassDeclarationSyntax.prototype.update = function (modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken) {
+            if (this.modifiers === modifiers && this.classKeyword === classKeyword && this.identifier === identifier && this.typeParameterList === typeParameterList && this.heritageClauses === heritageClauses && this.openBraceToken === openBraceToken && this.classElements === classElements && this.closeBraceToken === closeBraceToken) {
+                return this;
+            }
+
+            return new ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, this.parsedInStrictMode());
+        };
+
+        ClassDeclarationSyntax.create = function (classKeyword, identifier, openBraceToken, closeBraceToken) {
+            return new ClassDeclarationSyntax(TypeScript.Syntax.emptyList, classKeyword, identifier, null, TypeScript.Syntax.emptyList, openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false);
+        };
+
+        ClassDeclarationSyntax.create1 = function (identifier) {
+            return new ClassDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(44 /* ClassKeyword */), identifier, null, TypeScript.Syntax.emptyList, TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false);
+        };
+
+        ClassDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ClassDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ClassDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        ClassDeclarationSyntax.prototype.withClassKeyword = function (classKeyword) {
+            return this.update(this.modifiers, classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.modifiers, this.classKeyword, identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.withTypeParameterList = function (typeParameterList) {
+            return this.update(this.modifiers, this.classKeyword, this.identifier, typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.withHeritageClauses = function (heritageClauses) {
+            return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.withHeritageClause = function (heritageClause) {
+            return this.withHeritageClauses(TypeScript.Syntax.list([heritageClause]));
+        };
+
+        ClassDeclarationSyntax.prototype.withOpenBraceToken = function (openBraceToken) {
+            return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, openBraceToken, this.classElements, this.closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.withClassElements = function (classElements) {
+            return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, classElements, this.closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.withClassElement = function (classElement) {
+            return this.withClassElements(TypeScript.Syntax.list([classElement]));
+        };
+
+        ClassDeclarationSyntax.prototype.withCloseBraceToken = function (closeBraceToken) {
+            return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, closeBraceToken);
+        };
+
+        ClassDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ClassDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ClassDeclarationSyntax = ClassDeclarationSyntax;
+
+    var InterfaceDeclarationSyntax = (function (_super) {
+        __extends(InterfaceDeclarationSyntax, _super);
+        function InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.interfaceKeyword = interfaceKeyword;
+            this.identifier = identifier;
+            this.typeParameterList = typeParameterList;
+            this.heritageClauses = heritageClauses;
+            this.body = body;
+        }
+        InterfaceDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitInterfaceDeclaration(this);
+        };
+
+        InterfaceDeclarationSyntax.prototype.kind = function () {
+            return 128 /* InterfaceDeclaration */;
+        };
+
+        InterfaceDeclarationSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        InterfaceDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.interfaceKeyword;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.typeParameterList;
+                case 4:
+                    return this.heritageClauses;
+                case 5:
+                    return this.body;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        InterfaceDeclarationSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        InterfaceDeclarationSyntax.prototype.update = function (modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body) {
+            if (this.modifiers === modifiers && this.interfaceKeyword === interfaceKeyword && this.identifier === identifier && this.typeParameterList === typeParameterList && this.heritageClauses === heritageClauses && this.body === body) {
+                return this;
+            }
+
+            return new InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, this.parsedInStrictMode());
+        };
+
+        InterfaceDeclarationSyntax.create = function (interfaceKeyword, identifier, body) {
+            return new InterfaceDeclarationSyntax(TypeScript.Syntax.emptyList, interfaceKeyword, identifier, null, TypeScript.Syntax.emptyList, body, false);
+        };
+
+        InterfaceDeclarationSyntax.create1 = function (identifier) {
+            return new InterfaceDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(52 /* InterfaceKeyword */), identifier, null, TypeScript.Syntax.emptyList, ObjectTypeSyntax.create1(), false);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.interfaceKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.body);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        InterfaceDeclarationSyntax.prototype.withInterfaceKeyword = function (interfaceKeyword) {
+            return this.update(this.modifiers, interfaceKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.body);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.modifiers, this.interfaceKeyword, identifier, this.typeParameterList, this.heritageClauses, this.body);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withTypeParameterList = function (typeParameterList) {
+            return this.update(this.modifiers, this.interfaceKeyword, this.identifier, typeParameterList, this.heritageClauses, this.body);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withHeritageClauses = function (heritageClauses) {
+            return this.update(this.modifiers, this.interfaceKeyword, this.identifier, this.typeParameterList, heritageClauses, this.body);
+        };
+
+        InterfaceDeclarationSyntax.prototype.withHeritageClause = function (heritageClause) {
+            return this.withHeritageClauses(TypeScript.Syntax.list([heritageClause]));
+        };
+
+        InterfaceDeclarationSyntax.prototype.withBody = function (body) {
+            return this.update(this.modifiers, this.interfaceKeyword, this.identifier, this.typeParameterList, this.heritageClauses, body);
+        };
+
+        InterfaceDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return InterfaceDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.InterfaceDeclarationSyntax = InterfaceDeclarationSyntax;
+
+    var HeritageClauseSyntax = (function (_super) {
+        __extends(HeritageClauseSyntax, _super);
+        function HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.extendsOrImplementsKeyword = extendsOrImplementsKeyword;
+            this.typeNames = typeNames;
+
+            this._kind = kind;
+        }
+        HeritageClauseSyntax.prototype.accept = function (visitor) {
+            return visitor.visitHeritageClause(this);
+        };
+
+        HeritageClauseSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        HeritageClauseSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.extendsOrImplementsKeyword;
+                case 1:
+                    return this.typeNames;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        HeritageClauseSyntax.prototype.kind = function () {
+            return this._kind;
+        };
+
+        HeritageClauseSyntax.prototype.update = function (kind, extendsOrImplementsKeyword, typeNames) {
+            if (this._kind === kind && this.extendsOrImplementsKeyword === extendsOrImplementsKeyword && this.typeNames === typeNames) {
+                return this;
+            }
+
+            return new HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, this.parsedInStrictMode());
+        };
+
+        HeritageClauseSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        HeritageClauseSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        HeritageClauseSyntax.prototype.withKind = function (kind) {
+            return this.update(kind, this.extendsOrImplementsKeyword, this.typeNames);
+        };
+
+        HeritageClauseSyntax.prototype.withExtendsOrImplementsKeyword = function (extendsOrImplementsKeyword) {
+            return this.update(this._kind, extendsOrImplementsKeyword, this.typeNames);
+        };
+
+        HeritageClauseSyntax.prototype.withTypeNames = function (typeNames) {
+            return this.update(this._kind, this.extendsOrImplementsKeyword, typeNames);
+        };
+
+        HeritageClauseSyntax.prototype.withTypeName = function (typeName) {
+            return this.withTypeNames(TypeScript.Syntax.separatedList([typeName]));
+        };
+
+        HeritageClauseSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return HeritageClauseSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.HeritageClauseSyntax = HeritageClauseSyntax;
+
+    var ModuleDeclarationSyntax = (function (_super) {
+        __extends(ModuleDeclarationSyntax, _super);
+        function ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.moduleKeyword = moduleKeyword;
+            this.name = name;
+            this.stringLiteral = stringLiteral;
+            this.openBraceToken = openBraceToken;
+            this.moduleElements = moduleElements;
+            this.closeBraceToken = closeBraceToken;
+        }
+        ModuleDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitModuleDeclaration(this);
+        };
+
+        ModuleDeclarationSyntax.prototype.kind = function () {
+            return 130 /* ModuleDeclaration */;
+        };
+
+        ModuleDeclarationSyntax.prototype.childCount = function () {
+            return 7;
+        };
+
+        ModuleDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.moduleKeyword;
+                case 2:
+                    return this.name;
+                case 3:
+                    return this.stringLiteral;
+                case 4:
+                    return this.openBraceToken;
+                case 5:
+                    return this.moduleElements;
+                case 6:
+                    return this.closeBraceToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ModuleDeclarationSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ModuleDeclarationSyntax.prototype.update = function (modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken) {
+            if (this.modifiers === modifiers && this.moduleKeyword === moduleKeyword && this.name === name && this.stringLiteral === stringLiteral && this.openBraceToken === openBraceToken && this.moduleElements === moduleElements && this.closeBraceToken === closeBraceToken) {
+                return this;
+            }
+
+            return new ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, this.parsedInStrictMode());
+        };
+
+        ModuleDeclarationSyntax.create = function (moduleKeyword, openBraceToken, closeBraceToken) {
+            return new ModuleDeclarationSyntax(TypeScript.Syntax.emptyList, moduleKeyword, null, null, openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false);
+        };
+
+        ModuleDeclarationSyntax.create1 = function () {
+            return new ModuleDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(65 /* ModuleKeyword */), null, null, TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false);
+        };
+
+        ModuleDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ModuleDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ModuleDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken);
+        };
+
+        ModuleDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        ModuleDeclarationSyntax.prototype.withModuleKeyword = function (moduleKeyword) {
+            return this.update(this.modifiers, moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken);
+        };
+
+        ModuleDeclarationSyntax.prototype.withName = function (name) {
+            return this.update(this.modifiers, this.moduleKeyword, name, this.stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken);
+        };
+
+        ModuleDeclarationSyntax.prototype.withStringLiteral = function (stringLiteral) {
+            return this.update(this.modifiers, this.moduleKeyword, this.name, stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken);
+        };
+
+        ModuleDeclarationSyntax.prototype.withOpenBraceToken = function (openBraceToken) {
+            return this.update(this.modifiers, this.moduleKeyword, this.name, this.stringLiteral, openBraceToken, this.moduleElements, this.closeBraceToken);
+        };
+
+        ModuleDeclarationSyntax.prototype.withModuleElements = function (moduleElements) {
+            return this.update(this.modifiers, this.moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, moduleElements, this.closeBraceToken);
+        };
+
+        ModuleDeclarationSyntax.prototype.withModuleElement = function (moduleElement) {
+            return this.withModuleElements(TypeScript.Syntax.list([moduleElement]));
+        };
+
+        ModuleDeclarationSyntax.prototype.withCloseBraceToken = function (closeBraceToken) {
+            return this.update(this.modifiers, this.moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, this.moduleElements, closeBraceToken);
+        };
+
+        ModuleDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ModuleDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ModuleDeclarationSyntax = ModuleDeclarationSyntax;
+
+    var FunctionDeclarationSyntax = (function (_super) {
+        __extends(FunctionDeclarationSyntax, _super);
+        function FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.functionKeyword = functionKeyword;
+            this.identifier = identifier;
+            this.callSignature = callSignature;
+            this.block = block;
+            this.semicolonToken = semicolonToken;
+        }
+        FunctionDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitFunctionDeclaration(this);
+        };
+
+        FunctionDeclarationSyntax.prototype.kind = function () {
+            return 129 /* FunctionDeclaration */;
+        };
+
+        FunctionDeclarationSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        FunctionDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.functionKeyword;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.callSignature;
+                case 4:
+                    return this.block;
+                case 5:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        FunctionDeclarationSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        FunctionDeclarationSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        FunctionDeclarationSyntax.prototype.update = function (modifiers, functionKeyword, identifier, callSignature, block, semicolonToken) {
+            if (this.modifiers === modifiers && this.functionKeyword === functionKeyword && this.identifier === identifier && this.callSignature === callSignature && this.block === block && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, this.parsedInStrictMode());
+        };
+
+        FunctionDeclarationSyntax.create = function (functionKeyword, identifier, callSignature) {
+            return new FunctionDeclarationSyntax(TypeScript.Syntax.emptyList, functionKeyword, identifier, callSignature, null, null, false);
+        };
+
+        FunctionDeclarationSyntax.create1 = function (identifier) {
+            return new FunctionDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(27 /* FunctionKeyword */), identifier, CallSignatureSyntax.create1(), null, null, false);
+        };
+
+        FunctionDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        FunctionDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        FunctionDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.functionKeyword, this.identifier, this.callSignature, this.block, this.semicolonToken);
+        };
+
+        FunctionDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        FunctionDeclarationSyntax.prototype.withFunctionKeyword = function (functionKeyword) {
+            return this.update(this.modifiers, functionKeyword, this.identifier, this.callSignature, this.block, this.semicolonToken);
+        };
+
+        FunctionDeclarationSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.modifiers, this.functionKeyword, identifier, this.callSignature, this.block, this.semicolonToken);
+        };
+
+        FunctionDeclarationSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(this.modifiers, this.functionKeyword, this.identifier, callSignature, this.block, this.semicolonToken);
+        };
+
+        FunctionDeclarationSyntax.prototype.withBlock = function (block) {
+            return this.update(this.modifiers, this.functionKeyword, this.identifier, this.callSignature, block, this.semicolonToken);
+        };
+
+        FunctionDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.modifiers, this.functionKeyword, this.identifier, this.callSignature, this.block, semicolonToken);
+        };
+
+        FunctionDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.modifiers.childCount() > 0) {
+                return true;
+            }
+            if (this.callSignature.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.block !== null && this.block.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return FunctionDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.FunctionDeclarationSyntax = FunctionDeclarationSyntax;
+
+    var VariableStatementSyntax = (function (_super) {
+        __extends(VariableStatementSyntax, _super);
+        function VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.variableDeclaration = variableDeclaration;
+            this.semicolonToken = semicolonToken;
+        }
+        VariableStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitVariableStatement(this);
+        };
+
+        VariableStatementSyntax.prototype.kind = function () {
+            return 148 /* VariableStatement */;
+        };
+
+        VariableStatementSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        VariableStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.variableDeclaration;
+                case 2:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        VariableStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        VariableStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        VariableStatementSyntax.prototype.update = function (modifiers, variableDeclaration, semicolonToken) {
+            if (this.modifiers === modifiers && this.variableDeclaration === variableDeclaration && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, this.parsedInStrictMode());
+        };
+
+        VariableStatementSyntax.create = function (variableDeclaration, semicolonToken) {
+            return new VariableStatementSyntax(TypeScript.Syntax.emptyList, variableDeclaration, semicolonToken, false);
+        };
+
+        VariableStatementSyntax.create1 = function (variableDeclaration) {
+            return new VariableStatementSyntax(TypeScript.Syntax.emptyList, variableDeclaration, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        VariableStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        VariableStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        VariableStatementSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.variableDeclaration, this.semicolonToken);
+        };
+
+        VariableStatementSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        VariableStatementSyntax.prototype.withVariableDeclaration = function (variableDeclaration) {
+            return this.update(this.modifiers, variableDeclaration, this.semicolonToken);
+        };
+
+        VariableStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.modifiers, this.variableDeclaration, semicolonToken);
+        };
+
+        VariableStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.modifiers.childCount() > 0) {
+                return true;
+            }
+            if (this.variableDeclaration.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return VariableStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.VariableStatementSyntax = VariableStatementSyntax;
+
+    var VariableDeclarationSyntax = (function (_super) {
+        __extends(VariableDeclarationSyntax, _super);
+        function VariableDeclarationSyntax(varKeyword, variableDeclarators, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.varKeyword = varKeyword;
+            this.variableDeclarators = variableDeclarators;
+        }
+        VariableDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitVariableDeclaration(this);
+        };
+
+        VariableDeclarationSyntax.prototype.kind = function () {
+            return 224 /* VariableDeclaration */;
+        };
+
+        VariableDeclarationSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        VariableDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.varKeyword;
+                case 1:
+                    return this.variableDeclarators;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        VariableDeclarationSyntax.prototype.update = function (varKeyword, variableDeclarators) {
+            if (this.varKeyword === varKeyword && this.variableDeclarators === variableDeclarators) {
+                return this;
+            }
+
+            return new VariableDeclarationSyntax(varKeyword, variableDeclarators, this.parsedInStrictMode());
+        };
+
+        VariableDeclarationSyntax.create1 = function (variableDeclarators) {
+            return new VariableDeclarationSyntax(TypeScript.Syntax.token(40 /* VarKeyword */), variableDeclarators, false);
+        };
+
+        VariableDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        VariableDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        VariableDeclarationSyntax.prototype.withVarKeyword = function (varKeyword) {
+            return this.update(varKeyword, this.variableDeclarators);
+        };
+
+        VariableDeclarationSyntax.prototype.withVariableDeclarators = function (variableDeclarators) {
+            return this.update(this.varKeyword, variableDeclarators);
+        };
+
+        VariableDeclarationSyntax.prototype.withVariableDeclarator = function (variableDeclarator) {
+            return this.withVariableDeclarators(TypeScript.Syntax.separatedList([variableDeclarator]));
+        };
+
+        VariableDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.variableDeclarators.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return VariableDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.VariableDeclarationSyntax = VariableDeclarationSyntax;
+
+    var VariableDeclaratorSyntax = (function (_super) {
+        __extends(VariableDeclaratorSyntax, _super);
+        function VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.propertyName = propertyName;
+            this.typeAnnotation = typeAnnotation;
+            this.equalsValueClause = equalsValueClause;
+        }
+        VariableDeclaratorSyntax.prototype.accept = function (visitor) {
+            return visitor.visitVariableDeclarator(this);
+        };
+
+        VariableDeclaratorSyntax.prototype.kind = function () {
+            return 225 /* VariableDeclarator */;
+        };
+
+        VariableDeclaratorSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        VariableDeclaratorSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.propertyName;
+                case 1:
+                    return this.typeAnnotation;
+                case 2:
+                    return this.equalsValueClause;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        VariableDeclaratorSyntax.prototype.update = function (propertyName, typeAnnotation, equalsValueClause) {
+            if (this.propertyName === propertyName && this.typeAnnotation === typeAnnotation && this.equalsValueClause === equalsValueClause) {
+                return this;
+            }
+
+            return new VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, this.parsedInStrictMode());
+        };
+
+        VariableDeclaratorSyntax.create = function (propertyName) {
+            return new VariableDeclaratorSyntax(propertyName, null, null, false);
+        };
+
+        VariableDeclaratorSyntax.create1 = function (propertyName) {
+            return new VariableDeclaratorSyntax(propertyName, null, null, false);
+        };
+
+        VariableDeclaratorSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        VariableDeclaratorSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        VariableDeclaratorSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(propertyName, this.typeAnnotation, this.equalsValueClause);
+        };
+
+        VariableDeclaratorSyntax.prototype.withTypeAnnotation = function (typeAnnotation) {
+            return this.update(this.propertyName, typeAnnotation, this.equalsValueClause);
+        };
+
+        VariableDeclaratorSyntax.prototype.withEqualsValueClause = function (equalsValueClause) {
+            return this.update(this.propertyName, this.typeAnnotation, equalsValueClause);
+        };
+
+        VariableDeclaratorSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.typeAnnotation !== null) {
+                return true;
+            }
+            if (this.equalsValueClause !== null && this.equalsValueClause.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return VariableDeclaratorSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.VariableDeclaratorSyntax = VariableDeclaratorSyntax;
+
+    var EqualsValueClauseSyntax = (function (_super) {
+        __extends(EqualsValueClauseSyntax, _super);
+        function EqualsValueClauseSyntax(equalsToken, value, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.equalsToken = equalsToken;
+            this.value = value;
+        }
+        EqualsValueClauseSyntax.prototype.accept = function (visitor) {
+            return visitor.visitEqualsValueClause(this);
+        };
+
+        EqualsValueClauseSyntax.prototype.kind = function () {
+            return 232 /* EqualsValueClause */;
+        };
+
+        EqualsValueClauseSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        EqualsValueClauseSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.equalsToken;
+                case 1:
+                    return this.value;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        EqualsValueClauseSyntax.prototype.update = function (equalsToken, value) {
+            if (this.equalsToken === equalsToken && this.value === value) {
+                return this;
+            }
+
+            return new EqualsValueClauseSyntax(equalsToken, value, this.parsedInStrictMode());
+        };
+
+        EqualsValueClauseSyntax.create1 = function (value) {
+            return new EqualsValueClauseSyntax(TypeScript.Syntax.token(107 /* EqualsToken */), value, false);
+        };
+
+        EqualsValueClauseSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        EqualsValueClauseSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        EqualsValueClauseSyntax.prototype.withEqualsToken = function (equalsToken) {
+            return this.update(equalsToken, this.value);
+        };
+
+        EqualsValueClauseSyntax.prototype.withValue = function (value) {
+            return this.update(this.equalsToken, value);
+        };
+
+        EqualsValueClauseSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.value.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return EqualsValueClauseSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.EqualsValueClauseSyntax = EqualsValueClauseSyntax;
+
+    var PrefixUnaryExpressionSyntax = (function (_super) {
+        __extends(PrefixUnaryExpressionSyntax, _super);
+        function PrefixUnaryExpressionSyntax(kind, operatorToken, operand, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.operatorToken = operatorToken;
+            this.operand = operand;
+
+            this._kind = kind;
+        }
+        PrefixUnaryExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitPrefixUnaryExpression(this);
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.operatorToken;
+                case 1:
+                    return this.operand;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.kind = function () {
+            return this._kind;
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.update = function (kind, operatorToken, operand) {
+            if (this._kind === kind && this.operatorToken === operatorToken && this.operand === operand) {
+                return this;
+            }
+
+            return new PrefixUnaryExpressionSyntax(kind, operatorToken, operand, this.parsedInStrictMode());
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.withKind = function (kind) {
+            return this.update(kind, this.operatorToken, this.operand);
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.withOperatorToken = function (operatorToken) {
+            return this.update(this._kind, operatorToken, this.operand);
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.withOperand = function (operand) {
+            return this.update(this._kind, this.operatorToken, operand);
+        };
+
+        PrefixUnaryExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.operand.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return PrefixUnaryExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.PrefixUnaryExpressionSyntax = PrefixUnaryExpressionSyntax;
+
+    var ArrayLiteralExpressionSyntax = (function (_super) {
+        __extends(ArrayLiteralExpressionSyntax, _super);
+        function ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.openBracketToken = openBracketToken;
+            this.expressions = expressions;
+            this.closeBracketToken = closeBracketToken;
+        }
+        ArrayLiteralExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitArrayLiteralExpression(this);
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.kind = function () {
+            return 214 /* ArrayLiteralExpression */;
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.openBracketToken;
+                case 1:
+                    return this.expressions;
+                case 2:
+                    return this.closeBracketToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.isPrimaryExpression = function () {
+            return true;
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.update = function (openBracketToken, expressions, closeBracketToken) {
+            if (this.openBracketToken === openBracketToken && this.expressions === expressions && this.closeBracketToken === closeBracketToken) {
+                return this;
+            }
+
+            return new ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, this.parsedInStrictMode());
+        };
+
+        ArrayLiteralExpressionSyntax.create = function (openBracketToken, closeBracketToken) {
+            return new ArrayLiteralExpressionSyntax(openBracketToken, TypeScript.Syntax.emptySeparatedList, closeBracketToken, false);
+        };
+
+        ArrayLiteralExpressionSyntax.create1 = function () {
+            return new ArrayLiteralExpressionSyntax(TypeScript.Syntax.token(74 /* OpenBracketToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(75 /* CloseBracketToken */), false);
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.withOpenBracketToken = function (openBracketToken) {
+            return this.update(openBracketToken, this.expressions, this.closeBracketToken);
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.withExpressions = function (expressions) {
+            return this.update(this.openBracketToken, expressions, this.closeBracketToken);
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.withExpressions(TypeScript.Syntax.separatedList([expression]));
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.withCloseBracketToken = function (closeBracketToken) {
+            return this.update(this.openBracketToken, this.expressions, closeBracketToken);
+        };
+
+        ArrayLiteralExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expressions.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ArrayLiteralExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ArrayLiteralExpressionSyntax = ArrayLiteralExpressionSyntax;
+
+    var OmittedExpressionSyntax = (function (_super) {
+        __extends(OmittedExpressionSyntax, _super);
+        function OmittedExpressionSyntax(parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+        }
+        OmittedExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitOmittedExpression(this);
+        };
+
+        OmittedExpressionSyntax.prototype.kind = function () {
+            return 223 /* OmittedExpression */;
+        };
+
+        OmittedExpressionSyntax.prototype.childCount = function () {
+            return 0;
+        };
+
+        OmittedExpressionSyntax.prototype.childAt = function (slot) {
+            throw TypeScript.Errors.invalidOperation();
+        };
+
+        OmittedExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        OmittedExpressionSyntax.prototype.update = function () {
+            return this;
+        };
+
+        OmittedExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        OmittedExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        OmittedExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            return false;
+        };
+        return OmittedExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.OmittedExpressionSyntax = OmittedExpressionSyntax;
+
+    var ParenthesizedExpressionSyntax = (function (_super) {
+        __extends(ParenthesizedExpressionSyntax, _super);
+        function ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.openParenToken = openParenToken;
+            this.expression = expression;
+            this.closeParenToken = closeParenToken;
+        }
+        ParenthesizedExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitParenthesizedExpression(this);
+        };
+
+        ParenthesizedExpressionSyntax.prototype.kind = function () {
+            return 217 /* ParenthesizedExpression */;
+        };
+
+        ParenthesizedExpressionSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ParenthesizedExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.openParenToken;
+                case 1:
+                    return this.expression;
+                case 2:
+                    return this.closeParenToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ParenthesizedExpressionSyntax.prototype.isPrimaryExpression = function () {
+            return true;
+        };
+
+        ParenthesizedExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        ParenthesizedExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        ParenthesizedExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        ParenthesizedExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        ParenthesizedExpressionSyntax.prototype.update = function (openParenToken, expression, closeParenToken) {
+            if (this.openParenToken === openParenToken && this.expression === expression && this.closeParenToken === closeParenToken) {
+                return this;
+            }
+
+            return new ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, this.parsedInStrictMode());
+        };
+
+        ParenthesizedExpressionSyntax.create1 = function (expression) {
+            return new ParenthesizedExpressionSyntax(TypeScript.Syntax.token(72 /* OpenParenToken */), expression, TypeScript.Syntax.token(73 /* CloseParenToken */), false);
+        };
+
+        ParenthesizedExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ParenthesizedExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ParenthesizedExpressionSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(openParenToken, this.expression, this.closeParenToken);
+        };
+
+        ParenthesizedExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.openParenToken, expression, this.closeParenToken);
+        };
+
+        ParenthesizedExpressionSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.openParenToken, this.expression, closeParenToken);
+        };
+
+        ParenthesizedExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ParenthesizedExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ParenthesizedExpressionSyntax = ParenthesizedExpressionSyntax;
+
+    var SimpleArrowFunctionExpressionSyntax = (function (_super) {
+        __extends(SimpleArrowFunctionExpressionSyntax, _super);
+        function SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.identifier = identifier;
+            this.equalsGreaterThanToken = equalsGreaterThanToken;
+            this.block = block;
+            this.expression = expression;
+        }
+        SimpleArrowFunctionExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitSimpleArrowFunctionExpression(this);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.kind = function () {
+            return 219 /* SimpleArrowFunctionExpression */;
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.identifier;
+                case 1:
+                    return this.equalsGreaterThanToken;
+                case 2:
+                    return this.block;
+                case 3:
+                    return this.expression;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.isArrowFunctionExpression = function () {
+            return true;
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.update = function (identifier, equalsGreaterThanToken, block, expression) {
+            if (this.identifier === identifier && this.equalsGreaterThanToken === equalsGreaterThanToken && this.block === block && this.expression === expression) {
+                return this;
+            }
+
+            return new SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, this.parsedInStrictMode());
+        };
+
+        SimpleArrowFunctionExpressionSyntax.create = function (identifier, equalsGreaterThanToken) {
+            return new SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, null, null, false);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.create1 = function (identifier) {
+            return new SimpleArrowFunctionExpressionSyntax(identifier, TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), null, null, false);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(identifier, this.equalsGreaterThanToken, this.block, this.expression);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) {
+            return this.update(this.identifier, equalsGreaterThanToken, this.block, this.expression);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.withBlock = function (block) {
+            return this.update(this.identifier, this.equalsGreaterThanToken, block, this.expression);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.identifier, this.equalsGreaterThanToken, this.block, expression);
+        };
+
+        SimpleArrowFunctionExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return SimpleArrowFunctionExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.SimpleArrowFunctionExpressionSyntax = SimpleArrowFunctionExpressionSyntax;
+
+    var ParenthesizedArrowFunctionExpressionSyntax = (function (_super) {
+        __extends(ParenthesizedArrowFunctionExpressionSyntax, _super);
+        function ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.callSignature = callSignature;
+            this.equalsGreaterThanToken = equalsGreaterThanToken;
+            this.block = block;
+            this.expression = expression;
+        }
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitParenthesizedArrowFunctionExpression(this);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.kind = function () {
+            return 218 /* ParenthesizedArrowFunctionExpression */;
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.callSignature;
+                case 1:
+                    return this.equalsGreaterThanToken;
+                case 2:
+                    return this.block;
+                case 3:
+                    return this.expression;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.isArrowFunctionExpression = function () {
+            return true;
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.update = function (callSignature, equalsGreaterThanToken, block, expression) {
+            if (this.callSignature === callSignature && this.equalsGreaterThanToken === equalsGreaterThanToken && this.block === block && this.expression === expression) {
+                return this;
+            }
+
+            return new ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, this.parsedInStrictMode());
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.create = function (callSignature, equalsGreaterThanToken) {
+            return new ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, null, null, false);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.create1 = function () {
+            return new ParenthesizedArrowFunctionExpressionSyntax(CallSignatureSyntax.create1(), TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), null, null, false);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(callSignature, this.equalsGreaterThanToken, this.block, this.expression);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) {
+            return this.update(this.callSignature, equalsGreaterThanToken, this.block, this.expression);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.withBlock = function (block) {
+            return this.update(this.callSignature, this.equalsGreaterThanToken, block, this.expression);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.callSignature, this.equalsGreaterThanToken, this.block, expression);
+        };
+
+        ParenthesizedArrowFunctionExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ParenthesizedArrowFunctionExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ParenthesizedArrowFunctionExpressionSyntax = ParenthesizedArrowFunctionExpressionSyntax;
+
+    var QualifiedNameSyntax = (function (_super) {
+        __extends(QualifiedNameSyntax, _super);
+        function QualifiedNameSyntax(left, dotToken, right, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.left = left;
+            this.dotToken = dotToken;
+            this.right = right;
+        }
+        QualifiedNameSyntax.prototype.accept = function (visitor) {
+            return visitor.visitQualifiedName(this);
+        };
+
+        QualifiedNameSyntax.prototype.kind = function () {
+            return 121 /* QualifiedName */;
+        };
+
+        QualifiedNameSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        QualifiedNameSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.left;
+                case 1:
+                    return this.dotToken;
+                case 2:
+                    return this.right;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        QualifiedNameSyntax.prototype.isName = function () {
+            return true;
+        };
+
+        QualifiedNameSyntax.prototype.isType = function () {
+            return true;
+        };
+
+        QualifiedNameSyntax.prototype.update = function (left, dotToken, right) {
+            if (this.left === left && this.dotToken === dotToken && this.right === right) {
+                return this;
+            }
+
+            return new QualifiedNameSyntax(left, dotToken, right, this.parsedInStrictMode());
+        };
+
+        QualifiedNameSyntax.create1 = function (left, right) {
+            return new QualifiedNameSyntax(left, TypeScript.Syntax.token(76 /* DotToken */), right, false);
+        };
+
+        QualifiedNameSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        QualifiedNameSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        QualifiedNameSyntax.prototype.withLeft = function (left) {
+            return this.update(left, this.dotToken, this.right);
+        };
+
+        QualifiedNameSyntax.prototype.withDotToken = function (dotToken) {
+            return this.update(this.left, dotToken, this.right);
+        };
+
+        QualifiedNameSyntax.prototype.withRight = function (right) {
+            return this.update(this.left, this.dotToken, right);
+        };
+
+        QualifiedNameSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return QualifiedNameSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.QualifiedNameSyntax = QualifiedNameSyntax;
+
+    var TypeArgumentListSyntax = (function (_super) {
+        __extends(TypeArgumentListSyntax, _super);
+        function TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.lessThanToken = lessThanToken;
+            this.typeArguments = typeArguments;
+            this.greaterThanToken = greaterThanToken;
+        }
+        TypeArgumentListSyntax.prototype.accept = function (visitor) {
+            return visitor.visitTypeArgumentList(this);
+        };
+
+        TypeArgumentListSyntax.prototype.kind = function () {
+            return 228 /* TypeArgumentList */;
+        };
+
+        TypeArgumentListSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        TypeArgumentListSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.lessThanToken;
+                case 1:
+                    return this.typeArguments;
+                case 2:
+                    return this.greaterThanToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        TypeArgumentListSyntax.prototype.update = function (lessThanToken, typeArguments, greaterThanToken) {
+            if (this.lessThanToken === lessThanToken && this.typeArguments === typeArguments && this.greaterThanToken === greaterThanToken) {
+                return this;
+            }
+
+            return new TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, this.parsedInStrictMode());
+        };
+
+        TypeArgumentListSyntax.create = function (lessThanToken, greaterThanToken) {
+            return new TypeArgumentListSyntax(lessThanToken, TypeScript.Syntax.emptySeparatedList, greaterThanToken, false);
+        };
+
+        TypeArgumentListSyntax.create1 = function () {
+            return new TypeArgumentListSyntax(TypeScript.Syntax.token(80 /* LessThanToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(81 /* GreaterThanToken */), false);
+        };
+
+        TypeArgumentListSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        TypeArgumentListSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        TypeArgumentListSyntax.prototype.withLessThanToken = function (lessThanToken) {
+            return this.update(lessThanToken, this.typeArguments, this.greaterThanToken);
+        };
+
+        TypeArgumentListSyntax.prototype.withTypeArguments = function (typeArguments) {
+            return this.update(this.lessThanToken, typeArguments, this.greaterThanToken);
+        };
+
+        TypeArgumentListSyntax.prototype.withTypeArgument = function (typeArgument) {
+            return this.withTypeArguments(TypeScript.Syntax.separatedList([typeArgument]));
+        };
+
+        TypeArgumentListSyntax.prototype.withGreaterThanToken = function (greaterThanToken) {
+            return this.update(this.lessThanToken, this.typeArguments, greaterThanToken);
+        };
+
+        TypeArgumentListSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return TypeArgumentListSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.TypeArgumentListSyntax = TypeArgumentListSyntax;
+
+    var ConstructorTypeSyntax = (function (_super) {
+        __extends(ConstructorTypeSyntax, _super);
+        function ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.newKeyword = newKeyword;
+            this.typeParameterList = typeParameterList;
+            this.parameterList = parameterList;
+            this.equalsGreaterThanToken = equalsGreaterThanToken;
+            this.type = type;
+        }
+        ConstructorTypeSyntax.prototype.accept = function (visitor) {
+            return visitor.visitConstructorType(this);
+        };
+
+        ConstructorTypeSyntax.prototype.kind = function () {
+            return 125 /* ConstructorType */;
+        };
+
+        ConstructorTypeSyntax.prototype.childCount = function () {
+            return 5;
+        };
+
+        ConstructorTypeSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.newKeyword;
+                case 1:
+                    return this.typeParameterList;
+                case 2:
+                    return this.parameterList;
+                case 3:
+                    return this.equalsGreaterThanToken;
+                case 4:
+                    return this.type;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ConstructorTypeSyntax.prototype.isType = function () {
+            return true;
+        };
+
+        ConstructorTypeSyntax.prototype.update = function (newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type) {
+            if (this.newKeyword === newKeyword && this.typeParameterList === typeParameterList && this.parameterList === parameterList && this.equalsGreaterThanToken === equalsGreaterThanToken && this.type === type) {
+                return this;
+            }
+
+            return new ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, this.parsedInStrictMode());
+        };
+
+        ConstructorTypeSyntax.create = function (newKeyword, parameterList, equalsGreaterThanToken, type) {
+            return new ConstructorTypeSyntax(newKeyword, null, parameterList, equalsGreaterThanToken, type, false);
+        };
+
+        ConstructorTypeSyntax.create1 = function (type) {
+            return new ConstructorTypeSyntax(TypeScript.Syntax.token(31 /* NewKeyword */), null, ParameterListSyntax.create1(), TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), type, false);
+        };
+
+        ConstructorTypeSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ConstructorTypeSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ConstructorTypeSyntax.prototype.withNewKeyword = function (newKeyword) {
+            return this.update(newKeyword, this.typeParameterList, this.parameterList, this.equalsGreaterThanToken, this.type);
+        };
+
+        ConstructorTypeSyntax.prototype.withTypeParameterList = function (typeParameterList) {
+            return this.update(this.newKeyword, typeParameterList, this.parameterList, this.equalsGreaterThanToken, this.type);
+        };
+
+        ConstructorTypeSyntax.prototype.withParameterList = function (parameterList) {
+            return this.update(this.newKeyword, this.typeParameterList, parameterList, this.equalsGreaterThanToken, this.type);
+        };
+
+        ConstructorTypeSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) {
+            return this.update(this.newKeyword, this.typeParameterList, this.parameterList, equalsGreaterThanToken, this.type);
+        };
+
+        ConstructorTypeSyntax.prototype.withType = function (type) {
+            return this.update(this.newKeyword, this.typeParameterList, this.parameterList, this.equalsGreaterThanToken, type);
+        };
+
+        ConstructorTypeSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ConstructorTypeSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ConstructorTypeSyntax = ConstructorTypeSyntax;
+
+    var FunctionTypeSyntax = (function (_super) {
+        __extends(FunctionTypeSyntax, _super);
+        function FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.typeParameterList = typeParameterList;
+            this.parameterList = parameterList;
+            this.equalsGreaterThanToken = equalsGreaterThanToken;
+            this.type = type;
+        }
+        FunctionTypeSyntax.prototype.accept = function (visitor) {
+            return visitor.visitFunctionType(this);
+        };
+
+        FunctionTypeSyntax.prototype.kind = function () {
+            return 123 /* FunctionType */;
+        };
+
+        FunctionTypeSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        FunctionTypeSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.typeParameterList;
+                case 1:
+                    return this.parameterList;
+                case 2:
+                    return this.equalsGreaterThanToken;
+                case 3:
+                    return this.type;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        FunctionTypeSyntax.prototype.isType = function () {
+            return true;
+        };
+
+        FunctionTypeSyntax.prototype.update = function (typeParameterList, parameterList, equalsGreaterThanToken, type) {
+            if (this.typeParameterList === typeParameterList && this.parameterList === parameterList && this.equalsGreaterThanToken === equalsGreaterThanToken && this.type === type) {
+                return this;
+            }
+
+            return new FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, this.parsedInStrictMode());
+        };
+
+        FunctionTypeSyntax.create = function (parameterList, equalsGreaterThanToken, type) {
+            return new FunctionTypeSyntax(null, parameterList, equalsGreaterThanToken, type, false);
+        };
+
+        FunctionTypeSyntax.create1 = function (type) {
+            return new FunctionTypeSyntax(null, ParameterListSyntax.create1(), TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), type, false);
+        };
+
+        FunctionTypeSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        FunctionTypeSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        FunctionTypeSyntax.prototype.withTypeParameterList = function (typeParameterList) {
+            return this.update(typeParameterList, this.parameterList, this.equalsGreaterThanToken, this.type);
+        };
+
+        FunctionTypeSyntax.prototype.withParameterList = function (parameterList) {
+            return this.update(this.typeParameterList, parameterList, this.equalsGreaterThanToken, this.type);
+        };
+
+        FunctionTypeSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) {
+            return this.update(this.typeParameterList, this.parameterList, equalsGreaterThanToken, this.type);
+        };
+
+        FunctionTypeSyntax.prototype.withType = function (type) {
+            return this.update(this.typeParameterList, this.parameterList, this.equalsGreaterThanToken, type);
+        };
+
+        FunctionTypeSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return FunctionTypeSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.FunctionTypeSyntax = FunctionTypeSyntax;
+
+    var ObjectTypeSyntax = (function (_super) {
+        __extends(ObjectTypeSyntax, _super);
+        function ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.openBraceToken = openBraceToken;
+            this.typeMembers = typeMembers;
+            this.closeBraceToken = closeBraceToken;
+        }
+        ObjectTypeSyntax.prototype.accept = function (visitor) {
+            return visitor.visitObjectType(this);
+        };
+
+        ObjectTypeSyntax.prototype.kind = function () {
+            return 122 /* ObjectType */;
+        };
+
+        ObjectTypeSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ObjectTypeSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.openBraceToken;
+                case 1:
+                    return this.typeMembers;
+                case 2:
+                    return this.closeBraceToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ObjectTypeSyntax.prototype.isType = function () {
+            return true;
+        };
+
+        ObjectTypeSyntax.prototype.update = function (openBraceToken, typeMembers, closeBraceToken) {
+            if (this.openBraceToken === openBraceToken && this.typeMembers === typeMembers && this.closeBraceToken === closeBraceToken) {
+                return this;
+            }
+
+            return new ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, this.parsedInStrictMode());
+        };
+
+        ObjectTypeSyntax.create = function (openBraceToken, closeBraceToken) {
+            return new ObjectTypeSyntax(openBraceToken, TypeScript.Syntax.emptySeparatedList, closeBraceToken, false);
+        };
+
+        ObjectTypeSyntax.create1 = function () {
+            return new ObjectTypeSyntax(TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false);
+        };
+
+        ObjectTypeSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ObjectTypeSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ObjectTypeSyntax.prototype.withOpenBraceToken = function (openBraceToken) {
+            return this.update(openBraceToken, this.typeMembers, this.closeBraceToken);
+        };
+
+        ObjectTypeSyntax.prototype.withTypeMembers = function (typeMembers) {
+            return this.update(this.openBraceToken, typeMembers, this.closeBraceToken);
+        };
+
+        ObjectTypeSyntax.prototype.withTypeMember = function (typeMember) {
+            return this.withTypeMembers(TypeScript.Syntax.separatedList([typeMember]));
+        };
+
+        ObjectTypeSyntax.prototype.withCloseBraceToken = function (closeBraceToken) {
+            return this.update(this.openBraceToken, this.typeMembers, closeBraceToken);
+        };
+
+        ObjectTypeSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ObjectTypeSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ObjectTypeSyntax = ObjectTypeSyntax;
+
+    var ArrayTypeSyntax = (function (_super) {
+        __extends(ArrayTypeSyntax, _super);
+        function ArrayTypeSyntax(type, openBracketToken, closeBracketToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.type = type;
+            this.openBracketToken = openBracketToken;
+            this.closeBracketToken = closeBracketToken;
+        }
+        ArrayTypeSyntax.prototype.accept = function (visitor) {
+            return visitor.visitArrayType(this);
+        };
+
+        ArrayTypeSyntax.prototype.kind = function () {
+            return 124 /* ArrayType */;
+        };
+
+        ArrayTypeSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ArrayTypeSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.type;
+                case 1:
+                    return this.openBracketToken;
+                case 2:
+                    return this.closeBracketToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ArrayTypeSyntax.prototype.isType = function () {
+            return true;
+        };
+
+        ArrayTypeSyntax.prototype.update = function (type, openBracketToken, closeBracketToken) {
+            if (this.type === type && this.openBracketToken === openBracketToken && this.closeBracketToken === closeBracketToken) {
+                return this;
+            }
+
+            return new ArrayTypeSyntax(type, openBracketToken, closeBracketToken, this.parsedInStrictMode());
+        };
+
+        ArrayTypeSyntax.create1 = function (type) {
+            return new ArrayTypeSyntax(type, TypeScript.Syntax.token(74 /* OpenBracketToken */), TypeScript.Syntax.token(75 /* CloseBracketToken */), false);
+        };
+
+        ArrayTypeSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ArrayTypeSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ArrayTypeSyntax.prototype.withType = function (type) {
+            return this.update(type, this.openBracketToken, this.closeBracketToken);
+        };
+
+        ArrayTypeSyntax.prototype.withOpenBracketToken = function (openBracketToken) {
+            return this.update(this.type, openBracketToken, this.closeBracketToken);
+        };
+
+        ArrayTypeSyntax.prototype.withCloseBracketToken = function (closeBracketToken) {
+            return this.update(this.type, this.openBracketToken, closeBracketToken);
+        };
+
+        ArrayTypeSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ArrayTypeSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ArrayTypeSyntax = ArrayTypeSyntax;
+
+    var GenericTypeSyntax = (function (_super) {
+        __extends(GenericTypeSyntax, _super);
+        function GenericTypeSyntax(name, typeArgumentList, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.name = name;
+            this.typeArgumentList = typeArgumentList;
+        }
+        GenericTypeSyntax.prototype.accept = function (visitor) {
+            return visitor.visitGenericType(this);
+        };
+
+        GenericTypeSyntax.prototype.kind = function () {
+            return 126 /* GenericType */;
+        };
+
+        GenericTypeSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        GenericTypeSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.name;
+                case 1:
+                    return this.typeArgumentList;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        GenericTypeSyntax.prototype.isType = function () {
+            return true;
+        };
+
+        GenericTypeSyntax.prototype.update = function (name, typeArgumentList) {
+            if (this.name === name && this.typeArgumentList === typeArgumentList) {
+                return this;
+            }
+
+            return new GenericTypeSyntax(name, typeArgumentList, this.parsedInStrictMode());
+        };
+
+        GenericTypeSyntax.create1 = function (name) {
+            return new GenericTypeSyntax(name, TypeArgumentListSyntax.create1(), false);
+        };
+
+        GenericTypeSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        GenericTypeSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        GenericTypeSyntax.prototype.withName = function (name) {
+            return this.update(name, this.typeArgumentList);
+        };
+
+        GenericTypeSyntax.prototype.withTypeArgumentList = function (typeArgumentList) {
+            return this.update(this.name, typeArgumentList);
+        };
+
+        GenericTypeSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return GenericTypeSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.GenericTypeSyntax = GenericTypeSyntax;
+
+    var TypeQuerySyntax = (function (_super) {
+        __extends(TypeQuerySyntax, _super);
+        function TypeQuerySyntax(typeOfKeyword, name, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.typeOfKeyword = typeOfKeyword;
+            this.name = name;
+        }
+        TypeQuerySyntax.prototype.accept = function (visitor) {
+            return visitor.visitTypeQuery(this);
+        };
+
+        TypeQuerySyntax.prototype.kind = function () {
+            return 127 /* TypeQuery */;
+        };
+
+        TypeQuerySyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        TypeQuerySyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.typeOfKeyword;
+                case 1:
+                    return this.name;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        TypeQuerySyntax.prototype.isType = function () {
+            return true;
+        };
+
+        TypeQuerySyntax.prototype.update = function (typeOfKeyword, name) {
+            if (this.typeOfKeyword === typeOfKeyword && this.name === name) {
+                return this;
+            }
+
+            return new TypeQuerySyntax(typeOfKeyword, name, this.parsedInStrictMode());
+        };
+
+        TypeQuerySyntax.create1 = function (name) {
+            return new TypeQuerySyntax(TypeScript.Syntax.token(39 /* TypeOfKeyword */), name, false);
+        };
+
+        TypeQuerySyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        TypeQuerySyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        TypeQuerySyntax.prototype.withTypeOfKeyword = function (typeOfKeyword) {
+            return this.update(typeOfKeyword, this.name);
+        };
+
+        TypeQuerySyntax.prototype.withName = function (name) {
+            return this.update(this.typeOfKeyword, name);
+        };
+
+        TypeQuerySyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return TypeQuerySyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.TypeQuerySyntax = TypeQuerySyntax;
+
+    var TypeAnnotationSyntax = (function (_super) {
+        __extends(TypeAnnotationSyntax, _super);
+        function TypeAnnotationSyntax(colonToken, type, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.colonToken = colonToken;
+            this.type = type;
+        }
+        TypeAnnotationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitTypeAnnotation(this);
+        };
+
+        TypeAnnotationSyntax.prototype.kind = function () {
+            return 244 /* TypeAnnotation */;
+        };
+
+        TypeAnnotationSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        TypeAnnotationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.colonToken;
+                case 1:
+                    return this.type;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        TypeAnnotationSyntax.prototype.update = function (colonToken, type) {
+            if (this.colonToken === colonToken && this.type === type) {
+                return this;
+            }
+
+            return new TypeAnnotationSyntax(colonToken, type, this.parsedInStrictMode());
+        };
+
+        TypeAnnotationSyntax.create1 = function (type) {
+            return new TypeAnnotationSyntax(TypeScript.Syntax.token(106 /* ColonToken */), type, false);
+        };
+
+        TypeAnnotationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        TypeAnnotationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        TypeAnnotationSyntax.prototype.withColonToken = function (colonToken) {
+            return this.update(colonToken, this.type);
+        };
+
+        TypeAnnotationSyntax.prototype.withType = function (type) {
+            return this.update(this.colonToken, type);
+        };
+
+        TypeAnnotationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return TypeAnnotationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.TypeAnnotationSyntax = TypeAnnotationSyntax;
+
+    var BlockSyntax = (function (_super) {
+        __extends(BlockSyntax, _super);
+        function BlockSyntax(openBraceToken, statements, closeBraceToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.openBraceToken = openBraceToken;
+            this.statements = statements;
+            this.closeBraceToken = closeBraceToken;
+        }
+        BlockSyntax.prototype.accept = function (visitor) {
+            return visitor.visitBlock(this);
+        };
+
+        BlockSyntax.prototype.kind = function () {
+            return 146 /* Block */;
+        };
+
+        BlockSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        BlockSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.openBraceToken;
+                case 1:
+                    return this.statements;
+                case 2:
+                    return this.closeBraceToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        BlockSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        BlockSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        BlockSyntax.prototype.update = function (openBraceToken, statements, closeBraceToken) {
+            if (this.openBraceToken === openBraceToken && this.statements === statements && this.closeBraceToken === closeBraceToken) {
+                return this;
+            }
+
+            return new BlockSyntax(openBraceToken, statements, closeBraceToken, this.parsedInStrictMode());
+        };
+
+        BlockSyntax.create = function (openBraceToken, closeBraceToken) {
+            return new BlockSyntax(openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false);
+        };
+
+        BlockSyntax.create1 = function () {
+            return new BlockSyntax(TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false);
+        };
+
+        BlockSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        BlockSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        BlockSyntax.prototype.withOpenBraceToken = function (openBraceToken) {
+            return this.update(openBraceToken, this.statements, this.closeBraceToken);
+        };
+
+        BlockSyntax.prototype.withStatements = function (statements) {
+            return this.update(this.openBraceToken, statements, this.closeBraceToken);
+        };
+
+        BlockSyntax.prototype.withStatement = function (statement) {
+            return this.withStatements(TypeScript.Syntax.list([statement]));
+        };
+
+        BlockSyntax.prototype.withCloseBraceToken = function (closeBraceToken) {
+            return this.update(this.openBraceToken, this.statements, closeBraceToken);
+        };
+
+        BlockSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.statements.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return BlockSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.BlockSyntax = BlockSyntax;
+
+    var ParameterSyntax = (function (_super) {
+        __extends(ParameterSyntax, _super);
+        function ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.dotDotDotToken = dotDotDotToken;
+            this.modifiers = modifiers;
+            this.identifier = identifier;
+            this.questionToken = questionToken;
+            this.typeAnnotation = typeAnnotation;
+            this.equalsValueClause = equalsValueClause;
+        }
+        ParameterSyntax.prototype.accept = function (visitor) {
+            return visitor.visitParameter(this);
+        };
+
+        ParameterSyntax.prototype.kind = function () {
+            return 242 /* Parameter */;
+        };
+
+        ParameterSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        ParameterSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.dotDotDotToken;
+                case 1:
+                    return this.modifiers;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.questionToken;
+                case 4:
+                    return this.typeAnnotation;
+                case 5:
+                    return this.equalsValueClause;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ParameterSyntax.prototype.update = function (dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) {
+            if (this.dotDotDotToken === dotDotDotToken && this.modifiers === modifiers && this.identifier === identifier && this.questionToken === questionToken && this.typeAnnotation === typeAnnotation && this.equalsValueClause === equalsValueClause) {
+                return this;
+            }
+
+            return new ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, this.parsedInStrictMode());
+        };
+
+        ParameterSyntax.create = function (identifier) {
+            return new ParameterSyntax(null, TypeScript.Syntax.emptyList, identifier, null, null, null, false);
+        };
+
+        ParameterSyntax.create1 = function (identifier) {
+            return new ParameterSyntax(null, TypeScript.Syntax.emptyList, identifier, null, null, null, false);
+        };
+
+        ParameterSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ParameterSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ParameterSyntax.prototype.withDotDotDotToken = function (dotDotDotToken) {
+            return this.update(dotDotDotToken, this.modifiers, this.identifier, this.questionToken, this.typeAnnotation, this.equalsValueClause);
+        };
+
+        ParameterSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(this.dotDotDotToken, modifiers, this.identifier, this.questionToken, this.typeAnnotation, this.equalsValueClause);
+        };
+
+        ParameterSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        ParameterSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.dotDotDotToken, this.modifiers, identifier, this.questionToken, this.typeAnnotation, this.equalsValueClause);
+        };
+
+        ParameterSyntax.prototype.withQuestionToken = function (questionToken) {
+            return this.update(this.dotDotDotToken, this.modifiers, this.identifier, questionToken, this.typeAnnotation, this.equalsValueClause);
+        };
+
+        ParameterSyntax.prototype.withTypeAnnotation = function (typeAnnotation) {
+            return this.update(this.dotDotDotToken, this.modifiers, this.identifier, this.questionToken, typeAnnotation, this.equalsValueClause);
+        };
+
+        ParameterSyntax.prototype.withEqualsValueClause = function (equalsValueClause) {
+            return this.update(this.dotDotDotToken, this.modifiers, this.identifier, this.questionToken, this.typeAnnotation, equalsValueClause);
+        };
+
+        ParameterSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.dotDotDotToken !== null) {
+                return true;
+            }
+            if (this.modifiers.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.questionToken !== null) {
+                return true;
+            }
+            if (this.typeAnnotation !== null) {
+                return true;
+            }
+            if (this.equalsValueClause !== null) {
+                return true;
+            }
+            return false;
+        };
+        return ParameterSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ParameterSyntax = ParameterSyntax;
+
+    var MemberAccessExpressionSyntax = (function (_super) {
+        __extends(MemberAccessExpressionSyntax, _super);
+        function MemberAccessExpressionSyntax(expression, dotToken, name, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.expression = expression;
+            this.dotToken = dotToken;
+            this.name = name;
+        }
+        MemberAccessExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitMemberAccessExpression(this);
+        };
+
+        MemberAccessExpressionSyntax.prototype.kind = function () {
+            return 212 /* MemberAccessExpression */;
+        };
+
+        MemberAccessExpressionSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        MemberAccessExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.expression;
+                case 1:
+                    return this.dotToken;
+                case 2:
+                    return this.name;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        MemberAccessExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        MemberAccessExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        MemberAccessExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        MemberAccessExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        MemberAccessExpressionSyntax.prototype.update = function (expression, dotToken, name) {
+            if (this.expression === expression && this.dotToken === dotToken && this.name === name) {
+                return this;
+            }
+
+            return new MemberAccessExpressionSyntax(expression, dotToken, name, this.parsedInStrictMode());
+        };
+
+        MemberAccessExpressionSyntax.create1 = function (expression, name) {
+            return new MemberAccessExpressionSyntax(expression, TypeScript.Syntax.token(76 /* DotToken */), name, false);
+        };
+
+        MemberAccessExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        MemberAccessExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        MemberAccessExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(expression, this.dotToken, this.name);
+        };
+
+        MemberAccessExpressionSyntax.prototype.withDotToken = function (dotToken) {
+            return this.update(this.expression, dotToken, this.name);
+        };
+
+        MemberAccessExpressionSyntax.prototype.withName = function (name) {
+            return this.update(this.expression, this.dotToken, name);
+        };
+
+        MemberAccessExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return MemberAccessExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.MemberAccessExpressionSyntax = MemberAccessExpressionSyntax;
+
+    var PostfixUnaryExpressionSyntax = (function (_super) {
+        __extends(PostfixUnaryExpressionSyntax, _super);
+        function PostfixUnaryExpressionSyntax(kind, operand, operatorToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.operand = operand;
+            this.operatorToken = operatorToken;
+
+            this._kind = kind;
+        }
+        PostfixUnaryExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitPostfixUnaryExpression(this);
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.operand;
+                case 1:
+                    return this.operatorToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.kind = function () {
+            return this._kind;
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.update = function (kind, operand, operatorToken) {
+            if (this._kind === kind && this.operand === operand && this.operatorToken === operatorToken) {
+                return this;
+            }
+
+            return new PostfixUnaryExpressionSyntax(kind, operand, operatorToken, this.parsedInStrictMode());
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.withKind = function (kind) {
+            return this.update(kind, this.operand, this.operatorToken);
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.withOperand = function (operand) {
+            return this.update(this._kind, operand, this.operatorToken);
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.withOperatorToken = function (operatorToken) {
+            return this.update(this._kind, this.operand, operatorToken);
+        };
+
+        PostfixUnaryExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.operand.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return PostfixUnaryExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.PostfixUnaryExpressionSyntax = PostfixUnaryExpressionSyntax;
+
+    var ElementAccessExpressionSyntax = (function (_super) {
+        __extends(ElementAccessExpressionSyntax, _super);
+        function ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.expression = expression;
+            this.openBracketToken = openBracketToken;
+            this.argumentExpression = argumentExpression;
+            this.closeBracketToken = closeBracketToken;
+        }
+        ElementAccessExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitElementAccessExpression(this);
+        };
+
+        ElementAccessExpressionSyntax.prototype.kind = function () {
+            return 221 /* ElementAccessExpression */;
+        };
+
+        ElementAccessExpressionSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        ElementAccessExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.expression;
+                case 1:
+                    return this.openBracketToken;
+                case 2:
+                    return this.argumentExpression;
+                case 3:
+                    return this.closeBracketToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ElementAccessExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        ElementAccessExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        ElementAccessExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        ElementAccessExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        ElementAccessExpressionSyntax.prototype.update = function (expression, openBracketToken, argumentExpression, closeBracketToken) {
+            if (this.expression === expression && this.openBracketToken === openBracketToken && this.argumentExpression === argumentExpression && this.closeBracketToken === closeBracketToken) {
+                return this;
+            }
+
+            return new ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, this.parsedInStrictMode());
+        };
+
+        ElementAccessExpressionSyntax.create1 = function (expression, argumentExpression) {
+            return new ElementAccessExpressionSyntax(expression, TypeScript.Syntax.token(74 /* OpenBracketToken */), argumentExpression, TypeScript.Syntax.token(75 /* CloseBracketToken */), false);
+        };
+
+        ElementAccessExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ElementAccessExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ElementAccessExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(expression, this.openBracketToken, this.argumentExpression, this.closeBracketToken);
+        };
+
+        ElementAccessExpressionSyntax.prototype.withOpenBracketToken = function (openBracketToken) {
+            return this.update(this.expression, openBracketToken, this.argumentExpression, this.closeBracketToken);
+        };
+
+        ElementAccessExpressionSyntax.prototype.withArgumentExpression = function (argumentExpression) {
+            return this.update(this.expression, this.openBracketToken, argumentExpression, this.closeBracketToken);
+        };
+
+        ElementAccessExpressionSyntax.prototype.withCloseBracketToken = function (closeBracketToken) {
+            return this.update(this.expression, this.openBracketToken, this.argumentExpression, closeBracketToken);
+        };
+
+        ElementAccessExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.argumentExpression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ElementAccessExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ElementAccessExpressionSyntax = ElementAccessExpressionSyntax;
+
+    var InvocationExpressionSyntax = (function (_super) {
+        __extends(InvocationExpressionSyntax, _super);
+        function InvocationExpressionSyntax(expression, argumentList, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.expression = expression;
+            this.argumentList = argumentList;
+        }
+        InvocationExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitInvocationExpression(this);
+        };
+
+        InvocationExpressionSyntax.prototype.kind = function () {
+            return 213 /* InvocationExpression */;
+        };
+
+        InvocationExpressionSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        InvocationExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.expression;
+                case 1:
+                    return this.argumentList;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        InvocationExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        InvocationExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        InvocationExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        InvocationExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        InvocationExpressionSyntax.prototype.update = function (expression, argumentList) {
+            if (this.expression === expression && this.argumentList === argumentList) {
+                return this;
+            }
+
+            return new InvocationExpressionSyntax(expression, argumentList, this.parsedInStrictMode());
+        };
+
+        InvocationExpressionSyntax.create1 = function (expression) {
+            return new InvocationExpressionSyntax(expression, ArgumentListSyntax.create1(), false);
+        };
+
+        InvocationExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        InvocationExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        InvocationExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(expression, this.argumentList);
+        };
+
+        InvocationExpressionSyntax.prototype.withArgumentList = function (argumentList) {
+            return this.update(this.expression, argumentList);
+        };
+
+        InvocationExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.argumentList.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return InvocationExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.InvocationExpressionSyntax = InvocationExpressionSyntax;
+
+    var ArgumentListSyntax = (function (_super) {
+        __extends(ArgumentListSyntax, _super);
+        function ArgumentListSyntax(typeArgumentList, openParenToken, _arguments, closeParenToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.typeArgumentList = typeArgumentList;
+            this.openParenToken = openParenToken;
+            this.closeParenToken = closeParenToken;
+
+            this.arguments = _arguments;
+        }
+        ArgumentListSyntax.prototype.accept = function (visitor) {
+            return visitor.visitArgumentList(this);
+        };
+
+        ArgumentListSyntax.prototype.kind = function () {
+            return 226 /* ArgumentList */;
+        };
+
+        ArgumentListSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        ArgumentListSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.typeArgumentList;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.arguments;
+                case 3:
+                    return this.closeParenToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ArgumentListSyntax.prototype.update = function (typeArgumentList, openParenToken, _arguments, closeParenToken) {
+            if (this.typeArgumentList === typeArgumentList && this.openParenToken === openParenToken && this.arguments === _arguments && this.closeParenToken === closeParenToken) {
+                return this;
+            }
+
+            return new ArgumentListSyntax(typeArgumentList, openParenToken, _arguments, closeParenToken, this.parsedInStrictMode());
+        };
+
+        ArgumentListSyntax.create = function (openParenToken, closeParenToken) {
+            return new ArgumentListSyntax(null, openParenToken, TypeScript.Syntax.emptySeparatedList, closeParenToken, false);
+        };
+
+        ArgumentListSyntax.create1 = function () {
+            return new ArgumentListSyntax(null, TypeScript.Syntax.token(72 /* OpenParenToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(73 /* CloseParenToken */), false);
+        };
+
+        ArgumentListSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ArgumentListSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ArgumentListSyntax.prototype.withTypeArgumentList = function (typeArgumentList) {
+            return this.update(typeArgumentList, this.openParenToken, this.arguments, this.closeParenToken);
+        };
+
+        ArgumentListSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.typeArgumentList, openParenToken, this.arguments, this.closeParenToken);
+        };
+
+        ArgumentListSyntax.prototype.withArguments = function (_arguments) {
+            return this.update(this.typeArgumentList, this.openParenToken, _arguments, this.closeParenToken);
+        };
+
+        ArgumentListSyntax.prototype.withArgument = function (_argument) {
+            return this.withArguments(TypeScript.Syntax.separatedList([_argument]));
+        };
+
+        ArgumentListSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.typeArgumentList, this.openParenToken, this.arguments, closeParenToken);
+        };
+
+        ArgumentListSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.typeArgumentList !== null && this.typeArgumentList.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.arguments.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ArgumentListSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ArgumentListSyntax = ArgumentListSyntax;
+
+    var BinaryExpressionSyntax = (function (_super) {
+        __extends(BinaryExpressionSyntax, _super);
+        function BinaryExpressionSyntax(kind, left, operatorToken, right, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.left = left;
+            this.operatorToken = operatorToken;
+            this.right = right;
+
+            this._kind = kind;
+        }
+        BinaryExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitBinaryExpression(this);
+        };
+
+        BinaryExpressionSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        BinaryExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.left;
+                case 1:
+                    return this.operatorToken;
+                case 2:
+                    return this.right;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        BinaryExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        BinaryExpressionSyntax.prototype.kind = function () {
+            return this._kind;
+        };
+
+        BinaryExpressionSyntax.prototype.update = function (kind, left, operatorToken, right) {
+            if (this._kind === kind && this.left === left && this.operatorToken === operatorToken && this.right === right) {
+                return this;
+            }
+
+            return new BinaryExpressionSyntax(kind, left, operatorToken, right, this.parsedInStrictMode());
+        };
+
+        BinaryExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        BinaryExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        BinaryExpressionSyntax.prototype.withKind = function (kind) {
+            return this.update(kind, this.left, this.operatorToken, this.right);
+        };
+
+        BinaryExpressionSyntax.prototype.withLeft = function (left) {
+            return this.update(this._kind, left, this.operatorToken, this.right);
+        };
+
+        BinaryExpressionSyntax.prototype.withOperatorToken = function (operatorToken) {
+            return this.update(this._kind, this.left, operatorToken, this.right);
+        };
+
+        BinaryExpressionSyntax.prototype.withRight = function (right) {
+            return this.update(this._kind, this.left, this.operatorToken, right);
+        };
+
+        BinaryExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.left.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.right.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return BinaryExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.BinaryExpressionSyntax = BinaryExpressionSyntax;
+
+    var ConditionalExpressionSyntax = (function (_super) {
+        __extends(ConditionalExpressionSyntax, _super);
+        function ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.condition = condition;
+            this.questionToken = questionToken;
+            this.whenTrue = whenTrue;
+            this.colonToken = colonToken;
+            this.whenFalse = whenFalse;
+        }
+        ConditionalExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitConditionalExpression(this);
+        };
+
+        ConditionalExpressionSyntax.prototype.kind = function () {
+            return 186 /* ConditionalExpression */;
+        };
+
+        ConditionalExpressionSyntax.prototype.childCount = function () {
+            return 5;
+        };
+
+        ConditionalExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.condition;
+                case 1:
+                    return this.questionToken;
+                case 2:
+                    return this.whenTrue;
+                case 3:
+                    return this.colonToken;
+                case 4:
+                    return this.whenFalse;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ConditionalExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        ConditionalExpressionSyntax.prototype.update = function (condition, questionToken, whenTrue, colonToken, whenFalse) {
+            if (this.condition === condition && this.questionToken === questionToken && this.whenTrue === whenTrue && this.colonToken === colonToken && this.whenFalse === whenFalse) {
+                return this;
+            }
+
+            return new ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, this.parsedInStrictMode());
+        };
+
+        ConditionalExpressionSyntax.create1 = function (condition, whenTrue, whenFalse) {
+            return new ConditionalExpressionSyntax(condition, TypeScript.Syntax.token(105 /* QuestionToken */), whenTrue, TypeScript.Syntax.token(106 /* ColonToken */), whenFalse, false);
+        };
+
+        ConditionalExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ConditionalExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ConditionalExpressionSyntax.prototype.withCondition = function (condition) {
+            return this.update(condition, this.questionToken, this.whenTrue, this.colonToken, this.whenFalse);
+        };
+
+        ConditionalExpressionSyntax.prototype.withQuestionToken = function (questionToken) {
+            return this.update(this.condition, questionToken, this.whenTrue, this.colonToken, this.whenFalse);
+        };
+
+        ConditionalExpressionSyntax.prototype.withWhenTrue = function (whenTrue) {
+            return this.update(this.condition, this.questionToken, whenTrue, this.colonToken, this.whenFalse);
+        };
+
+        ConditionalExpressionSyntax.prototype.withColonToken = function (colonToken) {
+            return this.update(this.condition, this.questionToken, this.whenTrue, colonToken, this.whenFalse);
+        };
+
+        ConditionalExpressionSyntax.prototype.withWhenFalse = function (whenFalse) {
+            return this.update(this.condition, this.questionToken, this.whenTrue, this.colonToken, whenFalse);
+        };
+
+        ConditionalExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.condition.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.whenTrue.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.whenFalse.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ConditionalExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ConditionalExpressionSyntax = ConditionalExpressionSyntax;
+
+    var ConstructSignatureSyntax = (function (_super) {
+        __extends(ConstructSignatureSyntax, _super);
+        function ConstructSignatureSyntax(newKeyword, callSignature, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.newKeyword = newKeyword;
+            this.callSignature = callSignature;
+        }
+        ConstructSignatureSyntax.prototype.accept = function (visitor) {
+            return visitor.visitConstructSignature(this);
+        };
+
+        ConstructSignatureSyntax.prototype.kind = function () {
+            return 143 /* ConstructSignature */;
+        };
+
+        ConstructSignatureSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        ConstructSignatureSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.newKeyword;
+                case 1:
+                    return this.callSignature;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ConstructSignatureSyntax.prototype.isTypeMember = function () {
+            return true;
+        };
+
+        ConstructSignatureSyntax.prototype.update = function (newKeyword, callSignature) {
+            if (this.newKeyword === newKeyword && this.callSignature === callSignature) {
+                return this;
+            }
+
+            return new ConstructSignatureSyntax(newKeyword, callSignature, this.parsedInStrictMode());
+        };
+
+        ConstructSignatureSyntax.create1 = function () {
+            return new ConstructSignatureSyntax(TypeScript.Syntax.token(31 /* NewKeyword */), CallSignatureSyntax.create1(), false);
+        };
+
+        ConstructSignatureSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ConstructSignatureSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ConstructSignatureSyntax.prototype.withNewKeyword = function (newKeyword) {
+            return this.update(newKeyword, this.callSignature);
+        };
+
+        ConstructSignatureSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(this.newKeyword, callSignature);
+        };
+
+        ConstructSignatureSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ConstructSignatureSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ConstructSignatureSyntax = ConstructSignatureSyntax;
+
+    var MethodSignatureSyntax = (function (_super) {
+        __extends(MethodSignatureSyntax, _super);
+        function MethodSignatureSyntax(propertyName, questionToken, callSignature, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.propertyName = propertyName;
+            this.questionToken = questionToken;
+            this.callSignature = callSignature;
+        }
+        MethodSignatureSyntax.prototype.accept = function (visitor) {
+            return visitor.visitMethodSignature(this);
+        };
+
+        MethodSignatureSyntax.prototype.kind = function () {
+            return 145 /* MethodSignature */;
+        };
+
+        MethodSignatureSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        MethodSignatureSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.propertyName;
+                case 1:
+                    return this.questionToken;
+                case 2:
+                    return this.callSignature;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        MethodSignatureSyntax.prototype.isTypeMember = function () {
+            return true;
+        };
+
+        MethodSignatureSyntax.prototype.update = function (propertyName, questionToken, callSignature) {
+            if (this.propertyName === propertyName && this.questionToken === questionToken && this.callSignature === callSignature) {
+                return this;
+            }
+
+            return new MethodSignatureSyntax(propertyName, questionToken, callSignature, this.parsedInStrictMode());
+        };
+
+        MethodSignatureSyntax.create = function (propertyName, callSignature) {
+            return new MethodSignatureSyntax(propertyName, null, callSignature, false);
+        };
+
+        MethodSignatureSyntax.create1 = function (propertyName) {
+            return new MethodSignatureSyntax(propertyName, null, CallSignatureSyntax.create1(), false);
+        };
+
+        MethodSignatureSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        MethodSignatureSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        MethodSignatureSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(propertyName, this.questionToken, this.callSignature);
+        };
+
+        MethodSignatureSyntax.prototype.withQuestionToken = function (questionToken) {
+            return this.update(this.propertyName, questionToken, this.callSignature);
+        };
+
+        MethodSignatureSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(this.propertyName, this.questionToken, callSignature);
+        };
+
+        MethodSignatureSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.callSignature.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return MethodSignatureSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.MethodSignatureSyntax = MethodSignatureSyntax;
+
+    var IndexSignatureSyntax = (function (_super) {
+        __extends(IndexSignatureSyntax, _super);
+        function IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.openBracketToken = openBracketToken;
+            this.parameter = parameter;
+            this.closeBracketToken = closeBracketToken;
+            this.typeAnnotation = typeAnnotation;
+        }
+        IndexSignatureSyntax.prototype.accept = function (visitor) {
+            return visitor.visitIndexSignature(this);
+        };
+
+        IndexSignatureSyntax.prototype.kind = function () {
+            return 144 /* IndexSignature */;
+        };
+
+        IndexSignatureSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        IndexSignatureSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.openBracketToken;
+                case 1:
+                    return this.parameter;
+                case 2:
+                    return this.closeBracketToken;
+                case 3:
+                    return this.typeAnnotation;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        IndexSignatureSyntax.prototype.isTypeMember = function () {
+            return true;
+        };
+
+        IndexSignatureSyntax.prototype.update = function (openBracketToken, parameter, closeBracketToken, typeAnnotation) {
+            if (this.openBracketToken === openBracketToken && this.parameter === parameter && this.closeBracketToken === closeBracketToken && this.typeAnnotation === typeAnnotation) {
+                return this;
+            }
+
+            return new IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, this.parsedInStrictMode());
+        };
+
+        IndexSignatureSyntax.create = function (openBracketToken, parameter, closeBracketToken) {
+            return new IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, null, false);
+        };
+
+        IndexSignatureSyntax.create1 = function (parameter) {
+            return new IndexSignatureSyntax(TypeScript.Syntax.token(74 /* OpenBracketToken */), parameter, TypeScript.Syntax.token(75 /* CloseBracketToken */), null, false);
+        };
+
+        IndexSignatureSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        IndexSignatureSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        IndexSignatureSyntax.prototype.withOpenBracketToken = function (openBracketToken) {
+            return this.update(openBracketToken, this.parameter, this.closeBracketToken, this.typeAnnotation);
+        };
+
+        IndexSignatureSyntax.prototype.withParameter = function (parameter) {
+            return this.update(this.openBracketToken, parameter, this.closeBracketToken, this.typeAnnotation);
+        };
+
+        IndexSignatureSyntax.prototype.withCloseBracketToken = function (closeBracketToken) {
+            return this.update(this.openBracketToken, this.parameter, closeBracketToken, this.typeAnnotation);
+        };
+
+        IndexSignatureSyntax.prototype.withTypeAnnotation = function (typeAnnotation) {
+            return this.update(this.openBracketToken, this.parameter, this.closeBracketToken, typeAnnotation);
+        };
+
+        IndexSignatureSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return IndexSignatureSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.IndexSignatureSyntax = IndexSignatureSyntax;
+
+    var PropertySignatureSyntax = (function (_super) {
+        __extends(PropertySignatureSyntax, _super);
+        function PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.propertyName = propertyName;
+            this.questionToken = questionToken;
+            this.typeAnnotation = typeAnnotation;
+        }
+        PropertySignatureSyntax.prototype.accept = function (visitor) {
+            return visitor.visitPropertySignature(this);
+        };
+
+        PropertySignatureSyntax.prototype.kind = function () {
+            return 141 /* PropertySignature */;
+        };
+
+        PropertySignatureSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        PropertySignatureSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.propertyName;
+                case 1:
+                    return this.questionToken;
+                case 2:
+                    return this.typeAnnotation;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        PropertySignatureSyntax.prototype.isTypeMember = function () {
+            return true;
+        };
+
+        PropertySignatureSyntax.prototype.update = function (propertyName, questionToken, typeAnnotation) {
+            if (this.propertyName === propertyName && this.questionToken === questionToken && this.typeAnnotation === typeAnnotation) {
+                return this;
+            }
+
+            return new PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, this.parsedInStrictMode());
+        };
+
+        PropertySignatureSyntax.create = function (propertyName) {
+            return new PropertySignatureSyntax(propertyName, null, null, false);
+        };
+
+        PropertySignatureSyntax.create1 = function (propertyName) {
+            return new PropertySignatureSyntax(propertyName, null, null, false);
+        };
+
+        PropertySignatureSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        PropertySignatureSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        PropertySignatureSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(propertyName, this.questionToken, this.typeAnnotation);
+        };
+
+        PropertySignatureSyntax.prototype.withQuestionToken = function (questionToken) {
+            return this.update(this.propertyName, questionToken, this.typeAnnotation);
+        };
+
+        PropertySignatureSyntax.prototype.withTypeAnnotation = function (typeAnnotation) {
+            return this.update(this.propertyName, this.questionToken, typeAnnotation);
+        };
+
+        PropertySignatureSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return PropertySignatureSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.PropertySignatureSyntax = PropertySignatureSyntax;
+
+    var CallSignatureSyntax = (function (_super) {
+        __extends(CallSignatureSyntax, _super);
+        function CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.typeParameterList = typeParameterList;
+            this.parameterList = parameterList;
+            this.typeAnnotation = typeAnnotation;
+        }
+        CallSignatureSyntax.prototype.accept = function (visitor) {
+            return visitor.visitCallSignature(this);
+        };
+
+        CallSignatureSyntax.prototype.kind = function () {
+            return 142 /* CallSignature */;
+        };
+
+        CallSignatureSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        CallSignatureSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.typeParameterList;
+                case 1:
+                    return this.parameterList;
+                case 2:
+                    return this.typeAnnotation;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        CallSignatureSyntax.prototype.isTypeMember = function () {
+            return true;
+        };
+
+        CallSignatureSyntax.prototype.update = function (typeParameterList, parameterList, typeAnnotation) {
+            if (this.typeParameterList === typeParameterList && this.parameterList === parameterList && this.typeAnnotation === typeAnnotation) {
+                return this;
+            }
+
+            return new CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, this.parsedInStrictMode());
+        };
+
+        CallSignatureSyntax.create = function (parameterList) {
+            return new CallSignatureSyntax(null, parameterList, null, false);
+        };
+
+        CallSignatureSyntax.create1 = function () {
+            return new CallSignatureSyntax(null, ParameterListSyntax.create1(), null, false);
+        };
+
+        CallSignatureSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        CallSignatureSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        CallSignatureSyntax.prototype.withTypeParameterList = function (typeParameterList) {
+            return this.update(typeParameterList, this.parameterList, this.typeAnnotation);
+        };
+
+        CallSignatureSyntax.prototype.withParameterList = function (parameterList) {
+            return this.update(this.typeParameterList, parameterList, this.typeAnnotation);
+        };
+
+        CallSignatureSyntax.prototype.withTypeAnnotation = function (typeAnnotation) {
+            return this.update(this.typeParameterList, this.parameterList, typeAnnotation);
+        };
+
+        CallSignatureSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.typeParameterList !== null) {
+                return true;
+            }
+            if (this.parameterList.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.typeAnnotation !== null) {
+                return true;
+            }
+            return false;
+        };
+        return CallSignatureSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.CallSignatureSyntax = CallSignatureSyntax;
+
+    var ParameterListSyntax = (function (_super) {
+        __extends(ParameterListSyntax, _super);
+        function ParameterListSyntax(openParenToken, parameters, closeParenToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.openParenToken = openParenToken;
+            this.parameters = parameters;
+            this.closeParenToken = closeParenToken;
+        }
+        ParameterListSyntax.prototype.accept = function (visitor) {
+            return visitor.visitParameterList(this);
+        };
+
+        ParameterListSyntax.prototype.kind = function () {
+            return 227 /* ParameterList */;
+        };
+
+        ParameterListSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ParameterListSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.openParenToken;
+                case 1:
+                    return this.parameters;
+                case 2:
+                    return this.closeParenToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ParameterListSyntax.prototype.update = function (openParenToken, parameters, closeParenToken) {
+            if (this.openParenToken === openParenToken && this.parameters === parameters && this.closeParenToken === closeParenToken) {
+                return this;
+            }
+
+            return new ParameterListSyntax(openParenToken, parameters, closeParenToken, this.parsedInStrictMode());
+        };
+
+        ParameterListSyntax.create = function (openParenToken, closeParenToken) {
+            return new ParameterListSyntax(openParenToken, TypeScript.Syntax.emptySeparatedList, closeParenToken, false);
+        };
+
+        ParameterListSyntax.create1 = function () {
+            return new ParameterListSyntax(TypeScript.Syntax.token(72 /* OpenParenToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(73 /* CloseParenToken */), false);
+        };
+
+        ParameterListSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ParameterListSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ParameterListSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(openParenToken, this.parameters, this.closeParenToken);
+        };
+
+        ParameterListSyntax.prototype.withParameters = function (parameters) {
+            return this.update(this.openParenToken, parameters, this.closeParenToken);
+        };
+
+        ParameterListSyntax.prototype.withParameter = function (parameter) {
+            return this.withParameters(TypeScript.Syntax.separatedList([parameter]));
+        };
+
+        ParameterListSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.openParenToken, this.parameters, closeParenToken);
+        };
+
+        ParameterListSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.parameters.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ParameterListSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ParameterListSyntax = ParameterListSyntax;
+
+    var TypeParameterListSyntax = (function (_super) {
+        __extends(TypeParameterListSyntax, _super);
+        function TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.lessThanToken = lessThanToken;
+            this.typeParameters = typeParameters;
+            this.greaterThanToken = greaterThanToken;
+        }
+        TypeParameterListSyntax.prototype.accept = function (visitor) {
+            return visitor.visitTypeParameterList(this);
+        };
+
+        TypeParameterListSyntax.prototype.kind = function () {
+            return 229 /* TypeParameterList */;
+        };
+
+        TypeParameterListSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        TypeParameterListSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.lessThanToken;
+                case 1:
+                    return this.typeParameters;
+                case 2:
+                    return this.greaterThanToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        TypeParameterListSyntax.prototype.update = function (lessThanToken, typeParameters, greaterThanToken) {
+            if (this.lessThanToken === lessThanToken && this.typeParameters === typeParameters && this.greaterThanToken === greaterThanToken) {
+                return this;
+            }
+
+            return new TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, this.parsedInStrictMode());
+        };
+
+        TypeParameterListSyntax.create = function (lessThanToken, greaterThanToken) {
+            return new TypeParameterListSyntax(lessThanToken, TypeScript.Syntax.emptySeparatedList, greaterThanToken, false);
+        };
+
+        TypeParameterListSyntax.create1 = function () {
+            return new TypeParameterListSyntax(TypeScript.Syntax.token(80 /* LessThanToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(81 /* GreaterThanToken */), false);
+        };
+
+        TypeParameterListSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        TypeParameterListSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        TypeParameterListSyntax.prototype.withLessThanToken = function (lessThanToken) {
+            return this.update(lessThanToken, this.typeParameters, this.greaterThanToken);
+        };
+
+        TypeParameterListSyntax.prototype.withTypeParameters = function (typeParameters) {
+            return this.update(this.lessThanToken, typeParameters, this.greaterThanToken);
+        };
+
+        TypeParameterListSyntax.prototype.withTypeParameter = function (typeParameter) {
+            return this.withTypeParameters(TypeScript.Syntax.separatedList([typeParameter]));
+        };
+
+        TypeParameterListSyntax.prototype.withGreaterThanToken = function (greaterThanToken) {
+            return this.update(this.lessThanToken, this.typeParameters, greaterThanToken);
+        };
+
+        TypeParameterListSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return TypeParameterListSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.TypeParameterListSyntax = TypeParameterListSyntax;
+
+    var TypeParameterSyntax = (function (_super) {
+        __extends(TypeParameterSyntax, _super);
+        function TypeParameterSyntax(identifier, constraint, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.identifier = identifier;
+            this.constraint = constraint;
+        }
+        TypeParameterSyntax.prototype.accept = function (visitor) {
+            return visitor.visitTypeParameter(this);
+        };
+
+        TypeParameterSyntax.prototype.kind = function () {
+            return 238 /* TypeParameter */;
+        };
+
+        TypeParameterSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        TypeParameterSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.identifier;
+                case 1:
+                    return this.constraint;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        TypeParameterSyntax.prototype.update = function (identifier, constraint) {
+            if (this.identifier === identifier && this.constraint === constraint) {
+                return this;
+            }
+
+            return new TypeParameterSyntax(identifier, constraint, this.parsedInStrictMode());
+        };
+
+        TypeParameterSyntax.create = function (identifier) {
+            return new TypeParameterSyntax(identifier, null, false);
+        };
+
+        TypeParameterSyntax.create1 = function (identifier) {
+            return new TypeParameterSyntax(identifier, null, false);
+        };
+
+        TypeParameterSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        TypeParameterSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        TypeParameterSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(identifier, this.constraint);
+        };
+
+        TypeParameterSyntax.prototype.withConstraint = function (constraint) {
+            return this.update(this.identifier, constraint);
+        };
+
+        TypeParameterSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return TypeParameterSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.TypeParameterSyntax = TypeParameterSyntax;
+
+    var ConstraintSyntax = (function (_super) {
+        __extends(ConstraintSyntax, _super);
+        function ConstraintSyntax(extendsKeyword, type, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.extendsKeyword = extendsKeyword;
+            this.type = type;
+        }
+        ConstraintSyntax.prototype.accept = function (visitor) {
+            return visitor.visitConstraint(this);
+        };
+
+        ConstraintSyntax.prototype.kind = function () {
+            return 239 /* Constraint */;
+        };
+
+        ConstraintSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        ConstraintSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.extendsKeyword;
+                case 1:
+                    return this.type;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ConstraintSyntax.prototype.update = function (extendsKeyword, type) {
+            if (this.extendsKeyword === extendsKeyword && this.type === type) {
+                return this;
+            }
+
+            return new ConstraintSyntax(extendsKeyword, type, this.parsedInStrictMode());
+        };
+
+        ConstraintSyntax.create1 = function (type) {
+            return new ConstraintSyntax(TypeScript.Syntax.token(48 /* ExtendsKeyword */), type, false);
+        };
+
+        ConstraintSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ConstraintSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ConstraintSyntax.prototype.withExtendsKeyword = function (extendsKeyword) {
+            return this.update(extendsKeyword, this.type);
+        };
+
+        ConstraintSyntax.prototype.withType = function (type) {
+            return this.update(this.extendsKeyword, type);
+        };
+
+        ConstraintSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ConstraintSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ConstraintSyntax = ConstraintSyntax;
+
+    var ElseClauseSyntax = (function (_super) {
+        __extends(ElseClauseSyntax, _super);
+        function ElseClauseSyntax(elseKeyword, statement, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.elseKeyword = elseKeyword;
+            this.statement = statement;
+        }
+        ElseClauseSyntax.prototype.accept = function (visitor) {
+            return visitor.visitElseClause(this);
+        };
+
+        ElseClauseSyntax.prototype.kind = function () {
+            return 235 /* ElseClause */;
+        };
+
+        ElseClauseSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        ElseClauseSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.elseKeyword;
+                case 1:
+                    return this.statement;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ElseClauseSyntax.prototype.update = function (elseKeyword, statement) {
+            if (this.elseKeyword === elseKeyword && this.statement === statement) {
+                return this;
+            }
+
+            return new ElseClauseSyntax(elseKeyword, statement, this.parsedInStrictMode());
+        };
+
+        ElseClauseSyntax.create1 = function (statement) {
+            return new ElseClauseSyntax(TypeScript.Syntax.token(23 /* ElseKeyword */), statement, false);
+        };
+
+        ElseClauseSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ElseClauseSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ElseClauseSyntax.prototype.withElseKeyword = function (elseKeyword) {
+            return this.update(elseKeyword, this.statement);
+        };
+
+        ElseClauseSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.elseKeyword, statement);
+        };
+
+        ElseClauseSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ElseClauseSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ElseClauseSyntax = ElseClauseSyntax;
+
+    var IfStatementSyntax = (function (_super) {
+        __extends(IfStatementSyntax, _super);
+        function IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.ifKeyword = ifKeyword;
+            this.openParenToken = openParenToken;
+            this.condition = condition;
+            this.closeParenToken = closeParenToken;
+            this.statement = statement;
+            this.elseClause = elseClause;
+        }
+        IfStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitIfStatement(this);
+        };
+
+        IfStatementSyntax.prototype.kind = function () {
+            return 147 /* IfStatement */;
+        };
+
+        IfStatementSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        IfStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.ifKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.condition;
+                case 3:
+                    return this.closeParenToken;
+                case 4:
+                    return this.statement;
+                case 5:
+                    return this.elseClause;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        IfStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        IfStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        IfStatementSyntax.prototype.update = function (ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause) {
+            if (this.ifKeyword === ifKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.statement === statement && this.elseClause === elseClause) {
+                return this;
+            }
+
+            return new IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, this.parsedInStrictMode());
+        };
+
+        IfStatementSyntax.create = function (ifKeyword, openParenToken, condition, closeParenToken, statement) {
+            return new IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, null, false);
+        };
+
+        IfStatementSyntax.create1 = function (condition, statement) {
+            return new IfStatementSyntax(TypeScript.Syntax.token(28 /* IfKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, null, false);
+        };
+
+        IfStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        IfStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        IfStatementSyntax.prototype.withIfKeyword = function (ifKeyword) {
+            return this.update(ifKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement, this.elseClause);
+        };
+
+        IfStatementSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.ifKeyword, openParenToken, this.condition, this.closeParenToken, this.statement, this.elseClause);
+        };
+
+        IfStatementSyntax.prototype.withCondition = function (condition) {
+            return this.update(this.ifKeyword, this.openParenToken, condition, this.closeParenToken, this.statement, this.elseClause);
+        };
+
+        IfStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.ifKeyword, this.openParenToken, this.condition, closeParenToken, this.statement, this.elseClause);
+        };
+
+        IfStatementSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.ifKeyword, this.openParenToken, this.condition, this.closeParenToken, statement, this.elseClause);
+        };
+
+        IfStatementSyntax.prototype.withElseClause = function (elseClause) {
+            return this.update(this.ifKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement, elseClause);
+        };
+
+        IfStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.condition.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.elseClause !== null && this.elseClause.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return IfStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.IfStatementSyntax = IfStatementSyntax;
+
+    var ExpressionStatementSyntax = (function (_super) {
+        __extends(ExpressionStatementSyntax, _super);
+        function ExpressionStatementSyntax(expression, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.expression = expression;
+            this.semicolonToken = semicolonToken;
+        }
+        ExpressionStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitExpressionStatement(this);
+        };
+
+        ExpressionStatementSyntax.prototype.kind = function () {
+            return 149 /* ExpressionStatement */;
+        };
+
+        ExpressionStatementSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        ExpressionStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.expression;
+                case 1:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ExpressionStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        ExpressionStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ExpressionStatementSyntax.prototype.update = function (expression, semicolonToken) {
+            if (this.expression === expression && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new ExpressionStatementSyntax(expression, semicolonToken, this.parsedInStrictMode());
+        };
+
+        ExpressionStatementSyntax.create1 = function (expression) {
+            return new ExpressionStatementSyntax(expression, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        ExpressionStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ExpressionStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ExpressionStatementSyntax.prototype.withExpression = function (expression) {
+            return this.update(expression, this.semicolonToken);
+        };
+
+        ExpressionStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.expression, semicolonToken);
+        };
+
+        ExpressionStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ExpressionStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ExpressionStatementSyntax = ExpressionStatementSyntax;
+
+    var ConstructorDeclarationSyntax = (function (_super) {
+        __extends(ConstructorDeclarationSyntax, _super);
+        function ConstructorDeclarationSyntax(modifiers, constructorKeyword, callSignature, block, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.constructorKeyword = constructorKeyword;
+            this.callSignature = callSignature;
+            this.block = block;
+            this.semicolonToken = semicolonToken;
+        }
+        ConstructorDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitConstructorDeclaration(this);
+        };
+
+        ConstructorDeclarationSyntax.prototype.kind = function () {
+            return 137 /* ConstructorDeclaration */;
+        };
+
+        ConstructorDeclarationSyntax.prototype.childCount = function () {
+            return 5;
+        };
+
+        ConstructorDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.constructorKeyword;
+                case 2:
+                    return this.callSignature;
+                case 3:
+                    return this.block;
+                case 4:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ConstructorDeclarationSyntax.prototype.isClassElement = function () {
+            return true;
+        };
+
+        ConstructorDeclarationSyntax.prototype.update = function (modifiers, constructorKeyword, callSignature, block, semicolonToken) {
+            if (this.modifiers === modifiers && this.constructorKeyword === constructorKeyword && this.callSignature === callSignature && this.block === block && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new ConstructorDeclarationSyntax(modifiers, constructorKeyword, callSignature, block, semicolonToken, this.parsedInStrictMode());
+        };
+
+        ConstructorDeclarationSyntax.create = function (constructorKeyword, callSignature) {
+            return new ConstructorDeclarationSyntax(TypeScript.Syntax.emptyList, constructorKeyword, callSignature, null, null, false);
+        };
+
+        ConstructorDeclarationSyntax.create1 = function () {
+            return new ConstructorDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(62 /* ConstructorKeyword */), CallSignatureSyntax.create1(), null, null, false);
+        };
+
+        ConstructorDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ConstructorDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ConstructorDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.constructorKeyword, this.callSignature, this.block, this.semicolonToken);
+        };
+
+        ConstructorDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        ConstructorDeclarationSyntax.prototype.withConstructorKeyword = function (constructorKeyword) {
+            return this.update(this.modifiers, constructorKeyword, this.callSignature, this.block, this.semicolonToken);
+        };
+
+        ConstructorDeclarationSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(this.modifiers, this.constructorKeyword, callSignature, this.block, this.semicolonToken);
+        };
+
+        ConstructorDeclarationSyntax.prototype.withBlock = function (block) {
+            return this.update(this.modifiers, this.constructorKeyword, this.callSignature, block, this.semicolonToken);
+        };
+
+        ConstructorDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.modifiers, this.constructorKeyword, this.callSignature, this.block, semicolonToken);
+        };
+
+        ConstructorDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return ConstructorDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ConstructorDeclarationSyntax = ConstructorDeclarationSyntax;
+
+    var MemberFunctionDeclarationSyntax = (function (_super) {
+        __extends(MemberFunctionDeclarationSyntax, _super);
+        function MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.propertyName = propertyName;
+            this.callSignature = callSignature;
+            this.block = block;
+            this.semicolonToken = semicolonToken;
+        }
+        MemberFunctionDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitMemberFunctionDeclaration(this);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.kind = function () {
+            return 135 /* MemberFunctionDeclaration */;
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.childCount = function () {
+            return 5;
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.propertyName;
+                case 2:
+                    return this.callSignature;
+                case 3:
+                    return this.block;
+                case 4:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.isMemberDeclaration = function () {
+            return true;
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.isClassElement = function () {
+            return true;
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.update = function (modifiers, propertyName, callSignature, block, semicolonToken) {
+            if (this.modifiers === modifiers && this.propertyName === propertyName && this.callSignature === callSignature && this.block === block && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, this.parsedInStrictMode());
+        };
+
+        MemberFunctionDeclarationSyntax.create = function (propertyName, callSignature) {
+            return new MemberFunctionDeclarationSyntax(TypeScript.Syntax.emptyList, propertyName, callSignature, null, null, false);
+        };
+
+        MemberFunctionDeclarationSyntax.create1 = function (propertyName) {
+            return new MemberFunctionDeclarationSyntax(TypeScript.Syntax.emptyList, propertyName, CallSignatureSyntax.create1(), null, null, false);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.propertyName, this.callSignature, this.block, this.semicolonToken);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(this.modifiers, propertyName, this.callSignature, this.block, this.semicolonToken);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(this.modifiers, this.propertyName, callSignature, this.block, this.semicolonToken);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withBlock = function (block) {
+            return this.update(this.modifiers, this.propertyName, this.callSignature, block, this.semicolonToken);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.modifiers, this.propertyName, this.callSignature, this.block, semicolonToken);
+        };
+
+        MemberFunctionDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return MemberFunctionDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.MemberFunctionDeclarationSyntax = MemberFunctionDeclarationSyntax;
+
+    var GetAccessorSyntax = (function (_super) {
+        __extends(GetAccessorSyntax, _super);
+        function GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.getKeyword = getKeyword;
+            this.propertyName = propertyName;
+            this.parameterList = parameterList;
+            this.typeAnnotation = typeAnnotation;
+            this.block = block;
+        }
+        GetAccessorSyntax.prototype.accept = function (visitor) {
+            return visitor.visitGetAccessor(this);
+        };
+
+        GetAccessorSyntax.prototype.kind = function () {
+            return 139 /* GetAccessor */;
+        };
+
+        GetAccessorSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        GetAccessorSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.getKeyword;
+                case 2:
+                    return this.propertyName;
+                case 3:
+                    return this.parameterList;
+                case 4:
+                    return this.typeAnnotation;
+                case 5:
+                    return this.block;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        GetAccessorSyntax.prototype.isMemberDeclaration = function () {
+            return true;
+        };
+
+        GetAccessorSyntax.prototype.isPropertyAssignment = function () {
+            return true;
+        };
+
+        GetAccessorSyntax.prototype.isClassElement = function () {
+            return true;
+        };
+
+        GetAccessorSyntax.prototype.update = function (modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block) {
+            if (this.modifiers === modifiers && this.getKeyword === getKeyword && this.propertyName === propertyName && this.parameterList === parameterList && this.typeAnnotation === typeAnnotation && this.block === block) {
+                return this;
+            }
+
+            return new GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, this.parsedInStrictMode());
+        };
+
+        GetAccessorSyntax.create = function (getKeyword, propertyName, parameterList, block) {
+            return new GetAccessorSyntax(TypeScript.Syntax.emptyList, getKeyword, propertyName, parameterList, null, block, false);
+        };
+
+        GetAccessorSyntax.create1 = function (propertyName) {
+            return new GetAccessorSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(64 /* GetKeyword */), propertyName, ParameterListSyntax.create1(), null, BlockSyntax.create1(), false);
+        };
+
+        GetAccessorSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        GetAccessorSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        GetAccessorSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.getKeyword, this.propertyName, this.parameterList, this.typeAnnotation, this.block);
+        };
+
+        GetAccessorSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        GetAccessorSyntax.prototype.withGetKeyword = function (getKeyword) {
+            return this.update(this.modifiers, getKeyword, this.propertyName, this.parameterList, this.typeAnnotation, this.block);
+        };
+
+        GetAccessorSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(this.modifiers, this.getKeyword, propertyName, this.parameterList, this.typeAnnotation, this.block);
+        };
+
+        GetAccessorSyntax.prototype.withParameterList = function (parameterList) {
+            return this.update(this.modifiers, this.getKeyword, this.propertyName, parameterList, this.typeAnnotation, this.block);
+        };
+
+        GetAccessorSyntax.prototype.withTypeAnnotation = function (typeAnnotation) {
+            return this.update(this.modifiers, this.getKeyword, this.propertyName, this.parameterList, typeAnnotation, this.block);
+        };
+
+        GetAccessorSyntax.prototype.withBlock = function (block) {
+            return this.update(this.modifiers, this.getKeyword, this.propertyName, this.parameterList, this.typeAnnotation, block);
+        };
+
+        GetAccessorSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.modifiers.childCount() > 0) {
+                return true;
+            }
+            if (this.parameterList.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.typeAnnotation !== null) {
+                return true;
+            }
+            if (this.block.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return GetAccessorSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.GetAccessorSyntax = GetAccessorSyntax;
+
+    var SetAccessorSyntax = (function (_super) {
+        __extends(SetAccessorSyntax, _super);
+        function SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.setKeyword = setKeyword;
+            this.propertyName = propertyName;
+            this.parameterList = parameterList;
+            this.block = block;
+        }
+        SetAccessorSyntax.prototype.accept = function (visitor) {
+            return visitor.visitSetAccessor(this);
+        };
+
+        SetAccessorSyntax.prototype.kind = function () {
+            return 140 /* SetAccessor */;
+        };
+
+        SetAccessorSyntax.prototype.childCount = function () {
+            return 5;
+        };
+
+        SetAccessorSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.setKeyword;
+                case 2:
+                    return this.propertyName;
+                case 3:
+                    return this.parameterList;
+                case 4:
+                    return this.block;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        SetAccessorSyntax.prototype.isMemberDeclaration = function () {
+            return true;
+        };
+
+        SetAccessorSyntax.prototype.isPropertyAssignment = function () {
+            return true;
+        };
+
+        SetAccessorSyntax.prototype.isClassElement = function () {
+            return true;
+        };
+
+        SetAccessorSyntax.prototype.update = function (modifiers, setKeyword, propertyName, parameterList, block) {
+            if (this.modifiers === modifiers && this.setKeyword === setKeyword && this.propertyName === propertyName && this.parameterList === parameterList && this.block === block) {
+                return this;
+            }
+
+            return new SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, this.parsedInStrictMode());
+        };
+
+        SetAccessorSyntax.create = function (setKeyword, propertyName, parameterList, block) {
+            return new SetAccessorSyntax(TypeScript.Syntax.emptyList, setKeyword, propertyName, parameterList, block, false);
+        };
+
+        SetAccessorSyntax.create1 = function (propertyName) {
+            return new SetAccessorSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(68 /* SetKeyword */), propertyName, ParameterListSyntax.create1(), BlockSyntax.create1(), false);
+        };
+
+        SetAccessorSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        SetAccessorSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        SetAccessorSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.setKeyword, this.propertyName, this.parameterList, this.block);
+        };
+
+        SetAccessorSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        SetAccessorSyntax.prototype.withSetKeyword = function (setKeyword) {
+            return this.update(this.modifiers, setKeyword, this.propertyName, this.parameterList, this.block);
+        };
+
+        SetAccessorSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(this.modifiers, this.setKeyword, propertyName, this.parameterList, this.block);
+        };
+
+        SetAccessorSyntax.prototype.withParameterList = function (parameterList) {
+            return this.update(this.modifiers, this.setKeyword, this.propertyName, parameterList, this.block);
+        };
+
+        SetAccessorSyntax.prototype.withBlock = function (block) {
+            return this.update(this.modifiers, this.setKeyword, this.propertyName, this.parameterList, block);
+        };
+
+        SetAccessorSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return SetAccessorSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.SetAccessorSyntax = SetAccessorSyntax;
+
+    var MemberVariableDeclarationSyntax = (function (_super) {
+        __extends(MemberVariableDeclarationSyntax, _super);
+        function MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.variableDeclarator = variableDeclarator;
+            this.semicolonToken = semicolonToken;
+        }
+        MemberVariableDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitMemberVariableDeclaration(this);
+        };
+
+        MemberVariableDeclarationSyntax.prototype.kind = function () {
+            return 136 /* MemberVariableDeclaration */;
+        };
+
+        MemberVariableDeclarationSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        MemberVariableDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.variableDeclarator;
+                case 2:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        MemberVariableDeclarationSyntax.prototype.isMemberDeclaration = function () {
+            return true;
+        };
+
+        MemberVariableDeclarationSyntax.prototype.isClassElement = function () {
+            return true;
+        };
+
+        MemberVariableDeclarationSyntax.prototype.update = function (modifiers, variableDeclarator, semicolonToken) {
+            if (this.modifiers === modifiers && this.variableDeclarator === variableDeclarator && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, this.parsedInStrictMode());
+        };
+
+        MemberVariableDeclarationSyntax.create = function (variableDeclarator, semicolonToken) {
+            return new MemberVariableDeclarationSyntax(TypeScript.Syntax.emptyList, variableDeclarator, semicolonToken, false);
+        };
+
+        MemberVariableDeclarationSyntax.create1 = function (variableDeclarator) {
+            return new MemberVariableDeclarationSyntax(TypeScript.Syntax.emptyList, variableDeclarator, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        MemberVariableDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        MemberVariableDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        MemberVariableDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.variableDeclarator, this.semicolonToken);
+        };
+
+        MemberVariableDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        MemberVariableDeclarationSyntax.prototype.withVariableDeclarator = function (variableDeclarator) {
+            return this.update(this.modifiers, variableDeclarator, this.semicolonToken);
+        };
+
+        MemberVariableDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.modifiers, this.variableDeclarator, semicolonToken);
+        };
+
+        MemberVariableDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return MemberVariableDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.MemberVariableDeclarationSyntax = MemberVariableDeclarationSyntax;
+
+    var IndexMemberDeclarationSyntax = (function (_super) {
+        __extends(IndexMemberDeclarationSyntax, _super);
+        function IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.indexSignature = indexSignature;
+            this.semicolonToken = semicolonToken;
+        }
+        IndexMemberDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitIndexMemberDeclaration(this);
+        };
+
+        IndexMemberDeclarationSyntax.prototype.kind = function () {
+            return 138 /* IndexMemberDeclaration */;
+        };
+
+        IndexMemberDeclarationSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        IndexMemberDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.indexSignature;
+                case 2:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        IndexMemberDeclarationSyntax.prototype.isClassElement = function () {
+            return true;
+        };
+
+        IndexMemberDeclarationSyntax.prototype.update = function (modifiers, indexSignature, semicolonToken) {
+            if (this.modifiers === modifiers && this.indexSignature === indexSignature && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, this.parsedInStrictMode());
+        };
+
+        IndexMemberDeclarationSyntax.create = function (indexSignature, semicolonToken) {
+            return new IndexMemberDeclarationSyntax(TypeScript.Syntax.emptyList, indexSignature, semicolonToken, false);
+        };
+
+        IndexMemberDeclarationSyntax.create1 = function (indexSignature) {
+            return new IndexMemberDeclarationSyntax(TypeScript.Syntax.emptyList, indexSignature, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        IndexMemberDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        IndexMemberDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        IndexMemberDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.indexSignature, this.semicolonToken);
+        };
+
+        IndexMemberDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        IndexMemberDeclarationSyntax.prototype.withIndexSignature = function (indexSignature) {
+            return this.update(this.modifiers, indexSignature, this.semicolonToken);
+        };
+
+        IndexMemberDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.modifiers, this.indexSignature, semicolonToken);
+        };
+
+        IndexMemberDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return IndexMemberDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.IndexMemberDeclarationSyntax = IndexMemberDeclarationSyntax;
+
+    var ThrowStatementSyntax = (function (_super) {
+        __extends(ThrowStatementSyntax, _super);
+        function ThrowStatementSyntax(throwKeyword, expression, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.throwKeyword = throwKeyword;
+            this.expression = expression;
+            this.semicolonToken = semicolonToken;
+        }
+        ThrowStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitThrowStatement(this);
+        };
+
+        ThrowStatementSyntax.prototype.kind = function () {
+            return 157 /* ThrowStatement */;
+        };
+
+        ThrowStatementSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ThrowStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.throwKeyword;
+                case 1:
+                    return this.expression;
+                case 2:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ThrowStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        ThrowStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ThrowStatementSyntax.prototype.update = function (throwKeyword, expression, semicolonToken) {
+            if (this.throwKeyword === throwKeyword && this.expression === expression && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new ThrowStatementSyntax(throwKeyword, expression, semicolonToken, this.parsedInStrictMode());
+        };
+
+        ThrowStatementSyntax.create1 = function (expression) {
+            return new ThrowStatementSyntax(TypeScript.Syntax.token(36 /* ThrowKeyword */), expression, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        ThrowStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ThrowStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ThrowStatementSyntax.prototype.withThrowKeyword = function (throwKeyword) {
+            return this.update(throwKeyword, this.expression, this.semicolonToken);
+        };
+
+        ThrowStatementSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.throwKeyword, expression, this.semicolonToken);
+        };
+
+        ThrowStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.throwKeyword, this.expression, semicolonToken);
+        };
+
+        ThrowStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ThrowStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ThrowStatementSyntax = ThrowStatementSyntax;
+
+    var ReturnStatementSyntax = (function (_super) {
+        __extends(ReturnStatementSyntax, _super);
+        function ReturnStatementSyntax(returnKeyword, expression, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.returnKeyword = returnKeyword;
+            this.expression = expression;
+            this.semicolonToken = semicolonToken;
+        }
+        ReturnStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitReturnStatement(this);
+        };
+
+        ReturnStatementSyntax.prototype.kind = function () {
+            return 150 /* ReturnStatement */;
+        };
+
+        ReturnStatementSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ReturnStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.returnKeyword;
+                case 1:
+                    return this.expression;
+                case 2:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ReturnStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        ReturnStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ReturnStatementSyntax.prototype.update = function (returnKeyword, expression, semicolonToken) {
+            if (this.returnKeyword === returnKeyword && this.expression === expression && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new ReturnStatementSyntax(returnKeyword, expression, semicolonToken, this.parsedInStrictMode());
+        };
+
+        ReturnStatementSyntax.create = function (returnKeyword, semicolonToken) {
+            return new ReturnStatementSyntax(returnKeyword, null, semicolonToken, false);
+        };
+
+        ReturnStatementSyntax.create1 = function () {
+            return new ReturnStatementSyntax(TypeScript.Syntax.token(33 /* ReturnKeyword */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        ReturnStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ReturnStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ReturnStatementSyntax.prototype.withReturnKeyword = function (returnKeyword) {
+            return this.update(returnKeyword, this.expression, this.semicolonToken);
+        };
+
+        ReturnStatementSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.returnKeyword, expression, this.semicolonToken);
+        };
+
+        ReturnStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.returnKeyword, this.expression, semicolonToken);
+        };
+
+        ReturnStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression !== null && this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ReturnStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ReturnStatementSyntax = ReturnStatementSyntax;
+
+    var ObjectCreationExpressionSyntax = (function (_super) {
+        __extends(ObjectCreationExpressionSyntax, _super);
+        function ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.newKeyword = newKeyword;
+            this.expression = expression;
+            this.argumentList = argumentList;
+        }
+        ObjectCreationExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitObjectCreationExpression(this);
+        };
+
+        ObjectCreationExpressionSyntax.prototype.kind = function () {
+            return 216 /* ObjectCreationExpression */;
+        };
+
+        ObjectCreationExpressionSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ObjectCreationExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.newKeyword;
+                case 1:
+                    return this.expression;
+                case 2:
+                    return this.argumentList;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ObjectCreationExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        ObjectCreationExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        ObjectCreationExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        ObjectCreationExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        ObjectCreationExpressionSyntax.prototype.update = function (newKeyword, expression, argumentList) {
+            if (this.newKeyword === newKeyword && this.expression === expression && this.argumentList === argumentList) {
+                return this;
+            }
+
+            return new ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, this.parsedInStrictMode());
+        };
+
+        ObjectCreationExpressionSyntax.create = function (newKeyword, expression) {
+            return new ObjectCreationExpressionSyntax(newKeyword, expression, null, false);
+        };
+
+        ObjectCreationExpressionSyntax.create1 = function (expression) {
+            return new ObjectCreationExpressionSyntax(TypeScript.Syntax.token(31 /* NewKeyword */), expression, null, false);
+        };
+
+        ObjectCreationExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ObjectCreationExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ObjectCreationExpressionSyntax.prototype.withNewKeyword = function (newKeyword) {
+            return this.update(newKeyword, this.expression, this.argumentList);
+        };
+
+        ObjectCreationExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.newKeyword, expression, this.argumentList);
+        };
+
+        ObjectCreationExpressionSyntax.prototype.withArgumentList = function (argumentList) {
+            return this.update(this.newKeyword, this.expression, argumentList);
+        };
+
+        ObjectCreationExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.argumentList !== null && this.argumentList.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ObjectCreationExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ObjectCreationExpressionSyntax = ObjectCreationExpressionSyntax;
+
+    var SwitchStatementSyntax = (function (_super) {
+        __extends(SwitchStatementSyntax, _super);
+        function SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.switchKeyword = switchKeyword;
+            this.openParenToken = openParenToken;
+            this.expression = expression;
+            this.closeParenToken = closeParenToken;
+            this.openBraceToken = openBraceToken;
+            this.switchClauses = switchClauses;
+            this.closeBraceToken = closeBraceToken;
+        }
+        SwitchStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitSwitchStatement(this);
+        };
+
+        SwitchStatementSyntax.prototype.kind = function () {
+            return 151 /* SwitchStatement */;
+        };
+
+        SwitchStatementSyntax.prototype.childCount = function () {
+            return 7;
+        };
+
+        SwitchStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.switchKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.expression;
+                case 3:
+                    return this.closeParenToken;
+                case 4:
+                    return this.openBraceToken;
+                case 5:
+                    return this.switchClauses;
+                case 6:
+                    return this.closeBraceToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        SwitchStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        SwitchStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        SwitchStatementSyntax.prototype.update = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken) {
+            if (this.switchKeyword === switchKeyword && this.openParenToken === openParenToken && this.expression === expression && this.closeParenToken === closeParenToken && this.openBraceToken === openBraceToken && this.switchClauses === switchClauses && this.closeBraceToken === closeBraceToken) {
+                return this;
+            }
+
+            return new SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, this.parsedInStrictMode());
+        };
+
+        SwitchStatementSyntax.create = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, closeBraceToken) {
+            return new SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false);
+        };
+
+        SwitchStatementSyntax.create1 = function (expression) {
+            return new SwitchStatementSyntax(TypeScript.Syntax.token(34 /* SwitchKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), expression, TypeScript.Syntax.token(73 /* CloseParenToken */), TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false);
+        };
+
+        SwitchStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        SwitchStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        SwitchStatementSyntax.prototype.withSwitchKeyword = function (switchKeyword) {
+            return this.update(switchKeyword, this.openParenToken, this.expression, this.closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken);
+        };
+
+        SwitchStatementSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.switchKeyword, openParenToken, this.expression, this.closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken);
+        };
+
+        SwitchStatementSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.switchKeyword, this.openParenToken, expression, this.closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken);
+        };
+
+        SwitchStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.switchKeyword, this.openParenToken, this.expression, closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken);
+        };
+
+        SwitchStatementSyntax.prototype.withOpenBraceToken = function (openBraceToken) {
+            return this.update(this.switchKeyword, this.openParenToken, this.expression, this.closeParenToken, openBraceToken, this.switchClauses, this.closeBraceToken);
+        };
+
+        SwitchStatementSyntax.prototype.withSwitchClauses = function (switchClauses) {
+            return this.update(this.switchKeyword, this.openParenToken, this.expression, this.closeParenToken, this.openBraceToken, switchClauses, this.closeBraceToken);
+        };
+
+        SwitchStatementSyntax.prototype.withSwitchClause = function (switchClause) {
+            return this.withSwitchClauses(TypeScript.Syntax.list([switchClause]));
+        };
+
+        SwitchStatementSyntax.prototype.withCloseBraceToken = function (closeBraceToken) {
+            return this.update(this.switchKeyword, this.openParenToken, this.expression, this.closeParenToken, this.openBraceToken, this.switchClauses, closeBraceToken);
+        };
+
+        SwitchStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.switchClauses.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return SwitchStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.SwitchStatementSyntax = SwitchStatementSyntax;
+
+    var CaseSwitchClauseSyntax = (function (_super) {
+        __extends(CaseSwitchClauseSyntax, _super);
+        function CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.caseKeyword = caseKeyword;
+            this.expression = expression;
+            this.colonToken = colonToken;
+            this.statements = statements;
+        }
+        CaseSwitchClauseSyntax.prototype.accept = function (visitor) {
+            return visitor.visitCaseSwitchClause(this);
+        };
+
+        CaseSwitchClauseSyntax.prototype.kind = function () {
+            return 233 /* CaseSwitchClause */;
+        };
+
+        CaseSwitchClauseSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        CaseSwitchClauseSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.caseKeyword;
+                case 1:
+                    return this.expression;
+                case 2:
+                    return this.colonToken;
+                case 3:
+                    return this.statements;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        CaseSwitchClauseSyntax.prototype.isSwitchClause = function () {
+            return true;
+        };
+
+        CaseSwitchClauseSyntax.prototype.update = function (caseKeyword, expression, colonToken, statements) {
+            if (this.caseKeyword === caseKeyword && this.expression === expression && this.colonToken === colonToken && this.statements === statements) {
+                return this;
+            }
+
+            return new CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, this.parsedInStrictMode());
+        };
+
+        CaseSwitchClauseSyntax.create = function (caseKeyword, expression, colonToken) {
+            return new CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, TypeScript.Syntax.emptyList, false);
+        };
+
+        CaseSwitchClauseSyntax.create1 = function (expression) {
+            return new CaseSwitchClauseSyntax(TypeScript.Syntax.token(16 /* CaseKeyword */), expression, TypeScript.Syntax.token(106 /* ColonToken */), TypeScript.Syntax.emptyList, false);
+        };
+
+        CaseSwitchClauseSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        CaseSwitchClauseSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        CaseSwitchClauseSyntax.prototype.withCaseKeyword = function (caseKeyword) {
+            return this.update(caseKeyword, this.expression, this.colonToken, this.statements);
+        };
+
+        CaseSwitchClauseSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.caseKeyword, expression, this.colonToken, this.statements);
+        };
+
+        CaseSwitchClauseSyntax.prototype.withColonToken = function (colonToken) {
+            return this.update(this.caseKeyword, this.expression, colonToken, this.statements);
+        };
+
+        CaseSwitchClauseSyntax.prototype.withStatements = function (statements) {
+            return this.update(this.caseKeyword, this.expression, this.colonToken, statements);
+        };
+
+        CaseSwitchClauseSyntax.prototype.withStatement = function (statement) {
+            return this.withStatements(TypeScript.Syntax.list([statement]));
+        };
+
+        CaseSwitchClauseSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.statements.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return CaseSwitchClauseSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.CaseSwitchClauseSyntax = CaseSwitchClauseSyntax;
+
+    var DefaultSwitchClauseSyntax = (function (_super) {
+        __extends(DefaultSwitchClauseSyntax, _super);
+        function DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.defaultKeyword = defaultKeyword;
+            this.colonToken = colonToken;
+            this.statements = statements;
+        }
+        DefaultSwitchClauseSyntax.prototype.accept = function (visitor) {
+            return visitor.visitDefaultSwitchClause(this);
+        };
+
+        DefaultSwitchClauseSyntax.prototype.kind = function () {
+            return 234 /* DefaultSwitchClause */;
+        };
+
+        DefaultSwitchClauseSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        DefaultSwitchClauseSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.defaultKeyword;
+                case 1:
+                    return this.colonToken;
+                case 2:
+                    return this.statements;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        DefaultSwitchClauseSyntax.prototype.isSwitchClause = function () {
+            return true;
+        };
+
+        DefaultSwitchClauseSyntax.prototype.update = function (defaultKeyword, colonToken, statements) {
+            if (this.defaultKeyword === defaultKeyword && this.colonToken === colonToken && this.statements === statements) {
+                return this;
+            }
+
+            return new DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, this.parsedInStrictMode());
+        };
+
+        DefaultSwitchClauseSyntax.create = function (defaultKeyword, colonToken) {
+            return new DefaultSwitchClauseSyntax(defaultKeyword, colonToken, TypeScript.Syntax.emptyList, false);
+        };
+
+        DefaultSwitchClauseSyntax.create1 = function () {
+            return new DefaultSwitchClauseSyntax(TypeScript.Syntax.token(20 /* DefaultKeyword */), TypeScript.Syntax.token(106 /* ColonToken */), TypeScript.Syntax.emptyList, false);
+        };
+
+        DefaultSwitchClauseSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        DefaultSwitchClauseSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        DefaultSwitchClauseSyntax.prototype.withDefaultKeyword = function (defaultKeyword) {
+            return this.update(defaultKeyword, this.colonToken, this.statements);
+        };
+
+        DefaultSwitchClauseSyntax.prototype.withColonToken = function (colonToken) {
+            return this.update(this.defaultKeyword, colonToken, this.statements);
+        };
+
+        DefaultSwitchClauseSyntax.prototype.withStatements = function (statements) {
+            return this.update(this.defaultKeyword, this.colonToken, statements);
+        };
+
+        DefaultSwitchClauseSyntax.prototype.withStatement = function (statement) {
+            return this.withStatements(TypeScript.Syntax.list([statement]));
+        };
+
+        DefaultSwitchClauseSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.statements.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return DefaultSwitchClauseSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.DefaultSwitchClauseSyntax = DefaultSwitchClauseSyntax;
+
+    var BreakStatementSyntax = (function (_super) {
+        __extends(BreakStatementSyntax, _super);
+        function BreakStatementSyntax(breakKeyword, identifier, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.breakKeyword = breakKeyword;
+            this.identifier = identifier;
+            this.semicolonToken = semicolonToken;
+        }
+        BreakStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitBreakStatement(this);
+        };
+
+        BreakStatementSyntax.prototype.kind = function () {
+            return 152 /* BreakStatement */;
+        };
+
+        BreakStatementSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        BreakStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.breakKeyword;
+                case 1:
+                    return this.identifier;
+                case 2:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        BreakStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        BreakStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        BreakStatementSyntax.prototype.update = function (breakKeyword, identifier, semicolonToken) {
+            if (this.breakKeyword === breakKeyword && this.identifier === identifier && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new BreakStatementSyntax(breakKeyword, identifier, semicolonToken, this.parsedInStrictMode());
+        };
+
+        BreakStatementSyntax.create = function (breakKeyword, semicolonToken) {
+            return new BreakStatementSyntax(breakKeyword, null, semicolonToken, false);
+        };
+
+        BreakStatementSyntax.create1 = function () {
+            return new BreakStatementSyntax(TypeScript.Syntax.token(15 /* BreakKeyword */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        BreakStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        BreakStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        BreakStatementSyntax.prototype.withBreakKeyword = function (breakKeyword) {
+            return this.update(breakKeyword, this.identifier, this.semicolonToken);
+        };
+
+        BreakStatementSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.breakKeyword, identifier, this.semicolonToken);
+        };
+
+        BreakStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.breakKeyword, this.identifier, semicolonToken);
+        };
+
+        BreakStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            return false;
+        };
+        return BreakStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.BreakStatementSyntax = BreakStatementSyntax;
+
+    var ContinueStatementSyntax = (function (_super) {
+        __extends(ContinueStatementSyntax, _super);
+        function ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.continueKeyword = continueKeyword;
+            this.identifier = identifier;
+            this.semicolonToken = semicolonToken;
+        }
+        ContinueStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitContinueStatement(this);
+        };
+
+        ContinueStatementSyntax.prototype.kind = function () {
+            return 153 /* ContinueStatement */;
+        };
+
+        ContinueStatementSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ContinueStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.continueKeyword;
+                case 1:
+                    return this.identifier;
+                case 2:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ContinueStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        ContinueStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ContinueStatementSyntax.prototype.update = function (continueKeyword, identifier, semicolonToken) {
+            if (this.continueKeyword === continueKeyword && this.identifier === identifier && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, this.parsedInStrictMode());
+        };
+
+        ContinueStatementSyntax.create = function (continueKeyword, semicolonToken) {
+            return new ContinueStatementSyntax(continueKeyword, null, semicolonToken, false);
+        };
+
+        ContinueStatementSyntax.create1 = function () {
+            return new ContinueStatementSyntax(TypeScript.Syntax.token(18 /* ContinueKeyword */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        ContinueStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ContinueStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ContinueStatementSyntax.prototype.withContinueKeyword = function (continueKeyword) {
+            return this.update(continueKeyword, this.identifier, this.semicolonToken);
+        };
+
+        ContinueStatementSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.continueKeyword, identifier, this.semicolonToken);
+        };
+
+        ContinueStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.continueKeyword, this.identifier, semicolonToken);
+        };
+
+        ContinueStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            return false;
+        };
+        return ContinueStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ContinueStatementSyntax = ContinueStatementSyntax;
+
+    var ForStatementSyntax = (function (_super) {
+        __extends(ForStatementSyntax, _super);
+        function ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.forKeyword = forKeyword;
+            this.openParenToken = openParenToken;
+            this.variableDeclaration = variableDeclaration;
+            this.initializer = initializer;
+            this.firstSemicolonToken = firstSemicolonToken;
+            this.condition = condition;
+            this.secondSemicolonToken = secondSemicolonToken;
+            this.incrementor = incrementor;
+            this.closeParenToken = closeParenToken;
+            this.statement = statement;
+        }
+        ForStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitForStatement(this);
+        };
+
+        ForStatementSyntax.prototype.kind = function () {
+            return 154 /* ForStatement */;
+        };
+
+        ForStatementSyntax.prototype.childCount = function () {
+            return 10;
+        };
+
+        ForStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.forKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.variableDeclaration;
+                case 3:
+                    return this.initializer;
+                case 4:
+                    return this.firstSemicolonToken;
+                case 5:
+                    return this.condition;
+                case 6:
+                    return this.secondSemicolonToken;
+                case 7:
+                    return this.incrementor;
+                case 8:
+                    return this.closeParenToken;
+                case 9:
+                    return this.statement;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ForStatementSyntax.prototype.isIterationStatement = function () {
+            return true;
+        };
+
+        ForStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        ForStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ForStatementSyntax.prototype.update = function (forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement) {
+            if (this.forKeyword === forKeyword && this.openParenToken === openParenToken && this.variableDeclaration === variableDeclaration && this.initializer === initializer && this.firstSemicolonToken === firstSemicolonToken && this.condition === condition && this.secondSemicolonToken === secondSemicolonToken && this.incrementor === incrementor && this.closeParenToken === closeParenToken && this.statement === statement) {
+                return this;
+            }
+
+            return new ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, this.parsedInStrictMode());
+        };
+
+        ForStatementSyntax.create = function (forKeyword, openParenToken, firstSemicolonToken, secondSemicolonToken, closeParenToken, statement) {
+            return new ForStatementSyntax(forKeyword, openParenToken, null, null, firstSemicolonToken, null, secondSemicolonToken, null, closeParenToken, statement, false);
+        };
+
+        ForStatementSyntax.create1 = function (statement) {
+            return new ForStatementSyntax(TypeScript.Syntax.token(26 /* ForKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), null, null, TypeScript.Syntax.token(78 /* SemicolonToken */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), null, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false);
+        };
+
+        ForStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ForStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ForStatementSyntax.prototype.withForKeyword = function (forKeyword) {
+            return this.update(forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.forKeyword, openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withVariableDeclaration = function (variableDeclaration) {
+            return this.update(this.forKeyword, this.openParenToken, variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withInitializer = function (initializer) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withFirstSemicolonToken = function (firstSemicolonToken) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withCondition = function (condition) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withSecondSemicolonToken = function (secondSemicolonToken) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withIncrementor = function (incrementor) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, incrementor, this.closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, closeParenToken, this.statement);
+        };
+
+        ForStatementSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, statement);
+        };
+
+        ForStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.variableDeclaration !== null && this.variableDeclaration.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.initializer !== null && this.initializer.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.condition !== null && this.condition.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.incrementor !== null && this.incrementor.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ForStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ForStatementSyntax = ForStatementSyntax;
+
+    var ForInStatementSyntax = (function (_super) {
+        __extends(ForInStatementSyntax, _super);
+        function ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.forKeyword = forKeyword;
+            this.openParenToken = openParenToken;
+            this.variableDeclaration = variableDeclaration;
+            this.left = left;
+            this.inKeyword = inKeyword;
+            this.expression = expression;
+            this.closeParenToken = closeParenToken;
+            this.statement = statement;
+        }
+        ForInStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitForInStatement(this);
+        };
+
+        ForInStatementSyntax.prototype.kind = function () {
+            return 155 /* ForInStatement */;
+        };
+
+        ForInStatementSyntax.prototype.childCount = function () {
+            return 8;
+        };
+
+        ForInStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.forKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.variableDeclaration;
+                case 3:
+                    return this.left;
+                case 4:
+                    return this.inKeyword;
+                case 5:
+                    return this.expression;
+                case 6:
+                    return this.closeParenToken;
+                case 7:
+                    return this.statement;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ForInStatementSyntax.prototype.isIterationStatement = function () {
+            return true;
+        };
+
+        ForInStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        ForInStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        ForInStatementSyntax.prototype.update = function (forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement) {
+            if (this.forKeyword === forKeyword && this.openParenToken === openParenToken && this.variableDeclaration === variableDeclaration && this.left === left && this.inKeyword === inKeyword && this.expression === expression && this.closeParenToken === closeParenToken && this.statement === statement) {
+                return this;
+            }
+
+            return new ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, this.parsedInStrictMode());
+        };
+
+        ForInStatementSyntax.create = function (forKeyword, openParenToken, inKeyword, expression, closeParenToken, statement) {
+            return new ForInStatementSyntax(forKeyword, openParenToken, null, null, inKeyword, expression, closeParenToken, statement, false);
+        };
+
+        ForInStatementSyntax.create1 = function (expression, statement) {
+            return new ForInStatementSyntax(TypeScript.Syntax.token(26 /* ForKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), null, null, TypeScript.Syntax.token(29 /* InKeyword */), expression, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false);
+        };
+
+        ForInStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ForInStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ForInStatementSyntax.prototype.withForKeyword = function (forKeyword) {
+            return this.update(forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, this.statement);
+        };
+
+        ForInStatementSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.forKeyword, openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, this.statement);
+        };
+
+        ForInStatementSyntax.prototype.withVariableDeclaration = function (variableDeclaration) {
+            return this.update(this.forKeyword, this.openParenToken, variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, this.statement);
+        };
+
+        ForInStatementSyntax.prototype.withLeft = function (left) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, left, this.inKeyword, this.expression, this.closeParenToken, this.statement);
+        };
+
+        ForInStatementSyntax.prototype.withInKeyword = function (inKeyword) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, inKeyword, this.expression, this.closeParenToken, this.statement);
+        };
+
+        ForInStatementSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, expression, this.closeParenToken, this.statement);
+        };
+
+        ForInStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, closeParenToken, this.statement);
+        };
+
+        ForInStatementSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, statement);
+        };
+
+        ForInStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.variableDeclaration !== null && this.variableDeclaration.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.left !== null && this.left.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ForInStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ForInStatementSyntax = ForInStatementSyntax;
+
+    var WhileStatementSyntax = (function (_super) {
+        __extends(WhileStatementSyntax, _super);
+        function WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.whileKeyword = whileKeyword;
+            this.openParenToken = openParenToken;
+            this.condition = condition;
+            this.closeParenToken = closeParenToken;
+            this.statement = statement;
+        }
+        WhileStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitWhileStatement(this);
+        };
+
+        WhileStatementSyntax.prototype.kind = function () {
+            return 158 /* WhileStatement */;
+        };
+
+        WhileStatementSyntax.prototype.childCount = function () {
+            return 5;
+        };
+
+        WhileStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.whileKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.condition;
+                case 3:
+                    return this.closeParenToken;
+                case 4:
+                    return this.statement;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        WhileStatementSyntax.prototype.isIterationStatement = function () {
+            return true;
+        };
+
+        WhileStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        WhileStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        WhileStatementSyntax.prototype.update = function (whileKeyword, openParenToken, condition, closeParenToken, statement) {
+            if (this.whileKeyword === whileKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.statement === statement) {
+                return this;
+            }
+
+            return new WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, this.parsedInStrictMode());
+        };
+
+        WhileStatementSyntax.create1 = function (condition, statement) {
+            return new WhileStatementSyntax(TypeScript.Syntax.token(42 /* WhileKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false);
+        };
+
+        WhileStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        WhileStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        WhileStatementSyntax.prototype.withWhileKeyword = function (whileKeyword) {
+            return this.update(whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement);
+        };
+
+        WhileStatementSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.whileKeyword, openParenToken, this.condition, this.closeParenToken, this.statement);
+        };
+
+        WhileStatementSyntax.prototype.withCondition = function (condition) {
+            return this.update(this.whileKeyword, this.openParenToken, condition, this.closeParenToken, this.statement);
+        };
+
+        WhileStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.whileKeyword, this.openParenToken, this.condition, closeParenToken, this.statement);
+        };
+
+        WhileStatementSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, statement);
+        };
+
+        WhileStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.condition.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return WhileStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.WhileStatementSyntax = WhileStatementSyntax;
+
+    var WithStatementSyntax = (function (_super) {
+        __extends(WithStatementSyntax, _super);
+        function WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.withKeyword = withKeyword;
+            this.openParenToken = openParenToken;
+            this.condition = condition;
+            this.closeParenToken = closeParenToken;
+            this.statement = statement;
+        }
+        WithStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitWithStatement(this);
+        };
+
+        WithStatementSyntax.prototype.kind = function () {
+            return 163 /* WithStatement */;
+        };
+
+        WithStatementSyntax.prototype.childCount = function () {
+            return 5;
+        };
+
+        WithStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.withKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.condition;
+                case 3:
+                    return this.closeParenToken;
+                case 4:
+                    return this.statement;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        WithStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        WithStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        WithStatementSyntax.prototype.update = function (withKeyword, openParenToken, condition, closeParenToken, statement) {
+            if (this.withKeyword === withKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.statement === statement) {
+                return this;
+            }
+
+            return new WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, this.parsedInStrictMode());
+        };
+
+        WithStatementSyntax.create1 = function (condition, statement) {
+            return new WithStatementSyntax(TypeScript.Syntax.token(43 /* WithKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false);
+        };
+
+        WithStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        WithStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        WithStatementSyntax.prototype.withWithKeyword = function (withKeyword) {
+            return this.update(withKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement);
+        };
+
+        WithStatementSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.withKeyword, openParenToken, this.condition, this.closeParenToken, this.statement);
+        };
+
+        WithStatementSyntax.prototype.withCondition = function (condition) {
+            return this.update(this.withKeyword, this.openParenToken, condition, this.closeParenToken, this.statement);
+        };
+
+        WithStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.withKeyword, this.openParenToken, this.condition, closeParenToken, this.statement);
+        };
+
+        WithStatementSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.withKeyword, this.openParenToken, this.condition, this.closeParenToken, statement);
+        };
+
+        WithStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.condition.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return WithStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.WithStatementSyntax = WithStatementSyntax;
+
+    var EnumDeclarationSyntax = (function (_super) {
+        __extends(EnumDeclarationSyntax, _super);
+        function EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.modifiers = modifiers;
+            this.enumKeyword = enumKeyword;
+            this.identifier = identifier;
+            this.openBraceToken = openBraceToken;
+            this.enumElements = enumElements;
+            this.closeBraceToken = closeBraceToken;
+        }
+        EnumDeclarationSyntax.prototype.accept = function (visitor) {
+            return visitor.visitEnumDeclaration(this);
+        };
+
+        EnumDeclarationSyntax.prototype.kind = function () {
+            return 132 /* EnumDeclaration */;
+        };
+
+        EnumDeclarationSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        EnumDeclarationSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.modifiers;
+                case 1:
+                    return this.enumKeyword;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.openBraceToken;
+                case 4:
+                    return this.enumElements;
+                case 5:
+                    return this.closeBraceToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        EnumDeclarationSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        EnumDeclarationSyntax.prototype.update = function (modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken) {
+            if (this.modifiers === modifiers && this.enumKeyword === enumKeyword && this.identifier === identifier && this.openBraceToken === openBraceToken && this.enumElements === enumElements && this.closeBraceToken === closeBraceToken) {
+                return this;
+            }
+
+            return new EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, this.parsedInStrictMode());
+        };
+
+        EnumDeclarationSyntax.create = function (enumKeyword, identifier, openBraceToken, closeBraceToken) {
+            return new EnumDeclarationSyntax(TypeScript.Syntax.emptyList, enumKeyword, identifier, openBraceToken, TypeScript.Syntax.emptySeparatedList, closeBraceToken, false);
+        };
+
+        EnumDeclarationSyntax.create1 = function (identifier) {
+            return new EnumDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(46 /* EnumKeyword */), identifier, TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false);
+        };
+
+        EnumDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        EnumDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        EnumDeclarationSyntax.prototype.withModifiers = function (modifiers) {
+            return this.update(modifiers, this.enumKeyword, this.identifier, this.openBraceToken, this.enumElements, this.closeBraceToken);
+        };
+
+        EnumDeclarationSyntax.prototype.withModifier = function (modifier) {
+            return this.withModifiers(TypeScript.Syntax.list([modifier]));
+        };
+
+        EnumDeclarationSyntax.prototype.withEnumKeyword = function (enumKeyword) {
+            return this.update(this.modifiers, enumKeyword, this.identifier, this.openBraceToken, this.enumElements, this.closeBraceToken);
+        };
+
+        EnumDeclarationSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.modifiers, this.enumKeyword, identifier, this.openBraceToken, this.enumElements, this.closeBraceToken);
+        };
+
+        EnumDeclarationSyntax.prototype.withOpenBraceToken = function (openBraceToken) {
+            return this.update(this.modifiers, this.enumKeyword, this.identifier, openBraceToken, this.enumElements, this.closeBraceToken);
+        };
+
+        EnumDeclarationSyntax.prototype.withEnumElements = function (enumElements) {
+            return this.update(this.modifiers, this.enumKeyword, this.identifier, this.openBraceToken, enumElements, this.closeBraceToken);
+        };
+
+        EnumDeclarationSyntax.prototype.withEnumElement = function (enumElement) {
+            return this.withEnumElements(TypeScript.Syntax.separatedList([enumElement]));
+        };
+
+        EnumDeclarationSyntax.prototype.withCloseBraceToken = function (closeBraceToken) {
+            return this.update(this.modifiers, this.enumKeyword, this.identifier, this.openBraceToken, this.enumElements, closeBraceToken);
+        };
+
+        EnumDeclarationSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return EnumDeclarationSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.EnumDeclarationSyntax = EnumDeclarationSyntax;
+
+    var EnumElementSyntax = (function (_super) {
+        __extends(EnumElementSyntax, _super);
+        function EnumElementSyntax(propertyName, equalsValueClause, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.propertyName = propertyName;
+            this.equalsValueClause = equalsValueClause;
+        }
+        EnumElementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitEnumElement(this);
+        };
+
+        EnumElementSyntax.prototype.kind = function () {
+            return 243 /* EnumElement */;
+        };
+
+        EnumElementSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        EnumElementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.propertyName;
+                case 1:
+                    return this.equalsValueClause;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        EnumElementSyntax.prototype.update = function (propertyName, equalsValueClause) {
+            if (this.propertyName === propertyName && this.equalsValueClause === equalsValueClause) {
+                return this;
+            }
+
+            return new EnumElementSyntax(propertyName, equalsValueClause, this.parsedInStrictMode());
+        };
+
+        EnumElementSyntax.create = function (propertyName) {
+            return new EnumElementSyntax(propertyName, null, false);
+        };
+
+        EnumElementSyntax.create1 = function (propertyName) {
+            return new EnumElementSyntax(propertyName, null, false);
+        };
+
+        EnumElementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        EnumElementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        EnumElementSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(propertyName, this.equalsValueClause);
+        };
+
+        EnumElementSyntax.prototype.withEqualsValueClause = function (equalsValueClause) {
+            return this.update(this.propertyName, equalsValueClause);
+        };
+
+        EnumElementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.equalsValueClause !== null && this.equalsValueClause.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return EnumElementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.EnumElementSyntax = EnumElementSyntax;
+
+    var CastExpressionSyntax = (function (_super) {
+        __extends(CastExpressionSyntax, _super);
+        function CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.lessThanToken = lessThanToken;
+            this.type = type;
+            this.greaterThanToken = greaterThanToken;
+            this.expression = expression;
+        }
+        CastExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitCastExpression(this);
+        };
+
+        CastExpressionSyntax.prototype.kind = function () {
+            return 220 /* CastExpression */;
+        };
+
+        CastExpressionSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        CastExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.lessThanToken;
+                case 1:
+                    return this.type;
+                case 2:
+                    return this.greaterThanToken;
+                case 3:
+                    return this.expression;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        CastExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        CastExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        CastExpressionSyntax.prototype.update = function (lessThanToken, type, greaterThanToken, expression) {
+            if (this.lessThanToken === lessThanToken && this.type === type && this.greaterThanToken === greaterThanToken && this.expression === expression) {
+                return this;
+            }
+
+            return new CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, this.parsedInStrictMode());
+        };
+
+        CastExpressionSyntax.create1 = function (type, expression) {
+            return new CastExpressionSyntax(TypeScript.Syntax.token(80 /* LessThanToken */), type, TypeScript.Syntax.token(81 /* GreaterThanToken */), expression, false);
+        };
+
+        CastExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        CastExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        CastExpressionSyntax.prototype.withLessThanToken = function (lessThanToken) {
+            return this.update(lessThanToken, this.type, this.greaterThanToken, this.expression);
+        };
+
+        CastExpressionSyntax.prototype.withType = function (type) {
+            return this.update(this.lessThanToken, type, this.greaterThanToken, this.expression);
+        };
+
+        CastExpressionSyntax.prototype.withGreaterThanToken = function (greaterThanToken) {
+            return this.update(this.lessThanToken, this.type, greaterThanToken, this.expression);
+        };
+
+        CastExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.lessThanToken, this.type, this.greaterThanToken, expression);
+        };
+
+        CastExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            return true;
+        };
+        return CastExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.CastExpressionSyntax = CastExpressionSyntax;
+
+    var ObjectLiteralExpressionSyntax = (function (_super) {
+        __extends(ObjectLiteralExpressionSyntax, _super);
+        function ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.openBraceToken = openBraceToken;
+            this.propertyAssignments = propertyAssignments;
+            this.closeBraceToken = closeBraceToken;
+        }
+        ObjectLiteralExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitObjectLiteralExpression(this);
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.kind = function () {
+            return 215 /* ObjectLiteralExpression */;
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.openBraceToken;
+                case 1:
+                    return this.propertyAssignments;
+                case 2:
+                    return this.closeBraceToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.isPrimaryExpression = function () {
+            return true;
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.update = function (openBraceToken, propertyAssignments, closeBraceToken) {
+            if (this.openBraceToken === openBraceToken && this.propertyAssignments === propertyAssignments && this.closeBraceToken === closeBraceToken) {
+                return this;
+            }
+
+            return new ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, this.parsedInStrictMode());
+        };
+
+        ObjectLiteralExpressionSyntax.create = function (openBraceToken, closeBraceToken) {
+            return new ObjectLiteralExpressionSyntax(openBraceToken, TypeScript.Syntax.emptySeparatedList, closeBraceToken, false);
+        };
+
+        ObjectLiteralExpressionSyntax.create1 = function () {
+            return new ObjectLiteralExpressionSyntax(TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false);
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.withOpenBraceToken = function (openBraceToken) {
+            return this.update(openBraceToken, this.propertyAssignments, this.closeBraceToken);
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.withPropertyAssignments = function (propertyAssignments) {
+            return this.update(this.openBraceToken, propertyAssignments, this.closeBraceToken);
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.withPropertyAssignment = function (propertyAssignment) {
+            return this.withPropertyAssignments(TypeScript.Syntax.separatedList([propertyAssignment]));
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.withCloseBraceToken = function (closeBraceToken) {
+            return this.update(this.openBraceToken, this.propertyAssignments, closeBraceToken);
+        };
+
+        ObjectLiteralExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.propertyAssignments.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return ObjectLiteralExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.ObjectLiteralExpressionSyntax = ObjectLiteralExpressionSyntax;
+
+    var SimplePropertyAssignmentSyntax = (function (_super) {
+        __extends(SimplePropertyAssignmentSyntax, _super);
+        function SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.propertyName = propertyName;
+            this.colonToken = colonToken;
+            this.expression = expression;
+        }
+        SimplePropertyAssignmentSyntax.prototype.accept = function (visitor) {
+            return visitor.visitSimplePropertyAssignment(this);
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.kind = function () {
+            return 240 /* SimplePropertyAssignment */;
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.propertyName;
+                case 1:
+                    return this.colonToken;
+                case 2:
+                    return this.expression;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.isPropertyAssignment = function () {
+            return true;
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.update = function (propertyName, colonToken, expression) {
+            if (this.propertyName === propertyName && this.colonToken === colonToken && this.expression === expression) {
+                return this;
+            }
+
+            return new SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, this.parsedInStrictMode());
+        };
+
+        SimplePropertyAssignmentSyntax.create1 = function (propertyName, expression) {
+            return new SimplePropertyAssignmentSyntax(propertyName, TypeScript.Syntax.token(106 /* ColonToken */), expression, false);
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(propertyName, this.colonToken, this.expression);
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.withColonToken = function (colonToken) {
+            return this.update(this.propertyName, colonToken, this.expression);
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.propertyName, this.colonToken, expression);
+        };
+
+        SimplePropertyAssignmentSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return SimplePropertyAssignmentSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.SimplePropertyAssignmentSyntax = SimplePropertyAssignmentSyntax;
+
+    var FunctionPropertyAssignmentSyntax = (function (_super) {
+        __extends(FunctionPropertyAssignmentSyntax, _super);
+        function FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.propertyName = propertyName;
+            this.callSignature = callSignature;
+            this.block = block;
+        }
+        FunctionPropertyAssignmentSyntax.prototype.accept = function (visitor) {
+            return visitor.visitFunctionPropertyAssignment(this);
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.kind = function () {
+            return 241 /* FunctionPropertyAssignment */;
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.propertyName;
+                case 1:
+                    return this.callSignature;
+                case 2:
+                    return this.block;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.isPropertyAssignment = function () {
+            return true;
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.update = function (propertyName, callSignature, block) {
+            if (this.propertyName === propertyName && this.callSignature === callSignature && this.block === block) {
+                return this;
+            }
+
+            return new FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, this.parsedInStrictMode());
+        };
+
+        FunctionPropertyAssignmentSyntax.create1 = function (propertyName) {
+            return new FunctionPropertyAssignmentSyntax(propertyName, CallSignatureSyntax.create1(), BlockSyntax.create1(), false);
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.withPropertyName = function (propertyName) {
+            return this.update(propertyName, this.callSignature, this.block);
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(this.propertyName, callSignature, this.block);
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.withBlock = function (block) {
+            return this.update(this.propertyName, this.callSignature, block);
+        };
+
+        FunctionPropertyAssignmentSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.callSignature.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.block.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return FunctionPropertyAssignmentSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.FunctionPropertyAssignmentSyntax = FunctionPropertyAssignmentSyntax;
+
+    var FunctionExpressionSyntax = (function (_super) {
+        __extends(FunctionExpressionSyntax, _super);
+        function FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.functionKeyword = functionKeyword;
+            this.identifier = identifier;
+            this.callSignature = callSignature;
+            this.block = block;
+        }
+        FunctionExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitFunctionExpression(this);
+        };
+
+        FunctionExpressionSyntax.prototype.kind = function () {
+            return 222 /* FunctionExpression */;
+        };
+
+        FunctionExpressionSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        FunctionExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.functionKeyword;
+                case 1:
+                    return this.identifier;
+                case 2:
+                    return this.callSignature;
+                case 3:
+                    return this.block;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        FunctionExpressionSyntax.prototype.isPrimaryExpression = function () {
+            return true;
+        };
+
+        FunctionExpressionSyntax.prototype.isMemberExpression = function () {
+            return true;
+        };
+
+        FunctionExpressionSyntax.prototype.isPostfixExpression = function () {
+            return true;
+        };
+
+        FunctionExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        FunctionExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        FunctionExpressionSyntax.prototype.update = function (functionKeyword, identifier, callSignature, block) {
+            if (this.functionKeyword === functionKeyword && this.identifier === identifier && this.callSignature === callSignature && this.block === block) {
+                return this;
+            }
+
+            return new FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, this.parsedInStrictMode());
+        };
+
+        FunctionExpressionSyntax.create = function (functionKeyword, callSignature, block) {
+            return new FunctionExpressionSyntax(functionKeyword, null, callSignature, block, false);
+        };
+
+        FunctionExpressionSyntax.create1 = function () {
+            return new FunctionExpressionSyntax(TypeScript.Syntax.token(27 /* FunctionKeyword */), null, CallSignatureSyntax.create1(), BlockSyntax.create1(), false);
+        };
+
+        FunctionExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        FunctionExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        FunctionExpressionSyntax.prototype.withFunctionKeyword = function (functionKeyword) {
+            return this.update(functionKeyword, this.identifier, this.callSignature, this.block);
+        };
+
+        FunctionExpressionSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.functionKeyword, identifier, this.callSignature, this.block);
+        };
+
+        FunctionExpressionSyntax.prototype.withCallSignature = function (callSignature) {
+            return this.update(this.functionKeyword, this.identifier, callSignature, this.block);
+        };
+
+        FunctionExpressionSyntax.prototype.withBlock = function (block) {
+            return this.update(this.functionKeyword, this.identifier, this.callSignature, block);
+        };
+
+        FunctionExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.callSignature.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.block.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return FunctionExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.FunctionExpressionSyntax = FunctionExpressionSyntax;
+
+    var EmptyStatementSyntax = (function (_super) {
+        __extends(EmptyStatementSyntax, _super);
+        function EmptyStatementSyntax(semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.semicolonToken = semicolonToken;
+        }
+        EmptyStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitEmptyStatement(this);
+        };
+
+        EmptyStatementSyntax.prototype.kind = function () {
+            return 156 /* EmptyStatement */;
+        };
+
+        EmptyStatementSyntax.prototype.childCount = function () {
+            return 1;
+        };
+
+        EmptyStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        EmptyStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        EmptyStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        EmptyStatementSyntax.prototype.update = function (semicolonToken) {
+            if (this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new EmptyStatementSyntax(semicolonToken, this.parsedInStrictMode());
+        };
+
+        EmptyStatementSyntax.create1 = function () {
+            return new EmptyStatementSyntax(TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        EmptyStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        EmptyStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        EmptyStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(semicolonToken);
+        };
+
+        EmptyStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            return false;
+        };
+        return EmptyStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.EmptyStatementSyntax = EmptyStatementSyntax;
+
+    var TryStatementSyntax = (function (_super) {
+        __extends(TryStatementSyntax, _super);
+        function TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.tryKeyword = tryKeyword;
+            this.block = block;
+            this.catchClause = catchClause;
+            this.finallyClause = finallyClause;
+        }
+        TryStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitTryStatement(this);
+        };
+
+        TryStatementSyntax.prototype.kind = function () {
+            return 159 /* TryStatement */;
+        };
+
+        TryStatementSyntax.prototype.childCount = function () {
+            return 4;
+        };
+
+        TryStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.tryKeyword;
+                case 1:
+                    return this.block;
+                case 2:
+                    return this.catchClause;
+                case 3:
+                    return this.finallyClause;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        TryStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        TryStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        TryStatementSyntax.prototype.update = function (tryKeyword, block, catchClause, finallyClause) {
+            if (this.tryKeyword === tryKeyword && this.block === block && this.catchClause === catchClause && this.finallyClause === finallyClause) {
+                return this;
+            }
+
+            return new TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, this.parsedInStrictMode());
+        };
+
+        TryStatementSyntax.create = function (tryKeyword, block) {
+            return new TryStatementSyntax(tryKeyword, block, null, null, false);
+        };
+
+        TryStatementSyntax.create1 = function () {
+            return new TryStatementSyntax(TypeScript.Syntax.token(38 /* TryKeyword */), BlockSyntax.create1(), null, null, false);
+        };
+
+        TryStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        TryStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        TryStatementSyntax.prototype.withTryKeyword = function (tryKeyword) {
+            return this.update(tryKeyword, this.block, this.catchClause, this.finallyClause);
+        };
+
+        TryStatementSyntax.prototype.withBlock = function (block) {
+            return this.update(this.tryKeyword, block, this.catchClause, this.finallyClause);
+        };
+
+        TryStatementSyntax.prototype.withCatchClause = function (catchClause) {
+            return this.update(this.tryKeyword, this.block, catchClause, this.finallyClause);
+        };
+
+        TryStatementSyntax.prototype.withFinallyClause = function (finallyClause) {
+            return this.update(this.tryKeyword, this.block, this.catchClause, finallyClause);
+        };
+
+        TryStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.block.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.catchClause !== null && this.catchClause.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.finallyClause !== null && this.finallyClause.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return TryStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.TryStatementSyntax = TryStatementSyntax;
+
+    var CatchClauseSyntax = (function (_super) {
+        __extends(CatchClauseSyntax, _super);
+        function CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.catchKeyword = catchKeyword;
+            this.openParenToken = openParenToken;
+            this.identifier = identifier;
+            this.typeAnnotation = typeAnnotation;
+            this.closeParenToken = closeParenToken;
+            this.block = block;
+        }
+        CatchClauseSyntax.prototype.accept = function (visitor) {
+            return visitor.visitCatchClause(this);
+        };
+
+        CatchClauseSyntax.prototype.kind = function () {
+            return 236 /* CatchClause */;
+        };
+
+        CatchClauseSyntax.prototype.childCount = function () {
+            return 6;
+        };
+
+        CatchClauseSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.catchKeyword;
+                case 1:
+                    return this.openParenToken;
+                case 2:
+                    return this.identifier;
+                case 3:
+                    return this.typeAnnotation;
+                case 4:
+                    return this.closeParenToken;
+                case 5:
+                    return this.block;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        CatchClauseSyntax.prototype.update = function (catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block) {
+            if (this.catchKeyword === catchKeyword && this.openParenToken === openParenToken && this.identifier === identifier && this.typeAnnotation === typeAnnotation && this.closeParenToken === closeParenToken && this.block === block) {
+                return this;
+            }
+
+            return new CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, this.parsedInStrictMode());
+        };
+
+        CatchClauseSyntax.create = function (catchKeyword, openParenToken, identifier, closeParenToken, block) {
+            return new CatchClauseSyntax(catchKeyword, openParenToken, identifier, null, closeParenToken, block, false);
+        };
+
+        CatchClauseSyntax.create1 = function (identifier) {
+            return new CatchClauseSyntax(TypeScript.Syntax.token(17 /* CatchKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), identifier, null, TypeScript.Syntax.token(73 /* CloseParenToken */), BlockSyntax.create1(), false);
+        };
+
+        CatchClauseSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        CatchClauseSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        CatchClauseSyntax.prototype.withCatchKeyword = function (catchKeyword) {
+            return this.update(catchKeyword, this.openParenToken, this.identifier, this.typeAnnotation, this.closeParenToken, this.block);
+        };
+
+        CatchClauseSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.catchKeyword, openParenToken, this.identifier, this.typeAnnotation, this.closeParenToken, this.block);
+        };
+
+        CatchClauseSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(this.catchKeyword, this.openParenToken, identifier, this.typeAnnotation, this.closeParenToken, this.block);
+        };
+
+        CatchClauseSyntax.prototype.withTypeAnnotation = function (typeAnnotation) {
+            return this.update(this.catchKeyword, this.openParenToken, this.identifier, typeAnnotation, this.closeParenToken, this.block);
+        };
+
+        CatchClauseSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.catchKeyword, this.openParenToken, this.identifier, this.typeAnnotation, closeParenToken, this.block);
+        };
+
+        CatchClauseSyntax.prototype.withBlock = function (block) {
+            return this.update(this.catchKeyword, this.openParenToken, this.identifier, this.typeAnnotation, this.closeParenToken, block);
+        };
+
+        CatchClauseSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.typeAnnotation !== null && this.typeAnnotation.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.block.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return CatchClauseSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.CatchClauseSyntax = CatchClauseSyntax;
+
+    var FinallyClauseSyntax = (function (_super) {
+        __extends(FinallyClauseSyntax, _super);
+        function FinallyClauseSyntax(finallyKeyword, block, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.finallyKeyword = finallyKeyword;
+            this.block = block;
+        }
+        FinallyClauseSyntax.prototype.accept = function (visitor) {
+            return visitor.visitFinallyClause(this);
+        };
+
+        FinallyClauseSyntax.prototype.kind = function () {
+            return 237 /* FinallyClause */;
+        };
+
+        FinallyClauseSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        FinallyClauseSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.finallyKeyword;
+                case 1:
+                    return this.block;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        FinallyClauseSyntax.prototype.update = function (finallyKeyword, block) {
+            if (this.finallyKeyword === finallyKeyword && this.block === block) {
+                return this;
+            }
+
+            return new FinallyClauseSyntax(finallyKeyword, block, this.parsedInStrictMode());
+        };
+
+        FinallyClauseSyntax.create1 = function () {
+            return new FinallyClauseSyntax(TypeScript.Syntax.token(25 /* FinallyKeyword */), BlockSyntax.create1(), false);
+        };
+
+        FinallyClauseSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        FinallyClauseSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        FinallyClauseSyntax.prototype.withFinallyKeyword = function (finallyKeyword) {
+            return this.update(finallyKeyword, this.block);
+        };
+
+        FinallyClauseSyntax.prototype.withBlock = function (block) {
+            return this.update(this.finallyKeyword, block);
+        };
+
+        FinallyClauseSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.block.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return FinallyClauseSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.FinallyClauseSyntax = FinallyClauseSyntax;
+
+    var LabeledStatementSyntax = (function (_super) {
+        __extends(LabeledStatementSyntax, _super);
+        function LabeledStatementSyntax(identifier, colonToken, statement, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.identifier = identifier;
+            this.colonToken = colonToken;
+            this.statement = statement;
+        }
+        LabeledStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitLabeledStatement(this);
+        };
+
+        LabeledStatementSyntax.prototype.kind = function () {
+            return 160 /* LabeledStatement */;
+        };
+
+        LabeledStatementSyntax.prototype.childCount = function () {
+            return 3;
+        };
+
+        LabeledStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.identifier;
+                case 1:
+                    return this.colonToken;
+                case 2:
+                    return this.statement;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        LabeledStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        LabeledStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        LabeledStatementSyntax.prototype.update = function (identifier, colonToken, statement) {
+            if (this.identifier === identifier && this.colonToken === colonToken && this.statement === statement) {
+                return this;
+            }
+
+            return new LabeledStatementSyntax(identifier, colonToken, statement, this.parsedInStrictMode());
+        };
+
+        LabeledStatementSyntax.create1 = function (identifier, statement) {
+            return new LabeledStatementSyntax(identifier, TypeScript.Syntax.token(106 /* ColonToken */), statement, false);
+        };
+
+        LabeledStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        LabeledStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        LabeledStatementSyntax.prototype.withIdentifier = function (identifier) {
+            return this.update(identifier, this.colonToken, this.statement);
+        };
+
+        LabeledStatementSyntax.prototype.withColonToken = function (colonToken) {
+            return this.update(this.identifier, colonToken, this.statement);
+        };
+
+        LabeledStatementSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.identifier, this.colonToken, statement);
+        };
+
+        LabeledStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return LabeledStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.LabeledStatementSyntax = LabeledStatementSyntax;
+
+    var DoStatementSyntax = (function (_super) {
+        __extends(DoStatementSyntax, _super);
+        function DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.doKeyword = doKeyword;
+            this.statement = statement;
+            this.whileKeyword = whileKeyword;
+            this.openParenToken = openParenToken;
+            this.condition = condition;
+            this.closeParenToken = closeParenToken;
+            this.semicolonToken = semicolonToken;
+        }
+        DoStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitDoStatement(this);
+        };
+
+        DoStatementSyntax.prototype.kind = function () {
+            return 161 /* DoStatement */;
+        };
+
+        DoStatementSyntax.prototype.childCount = function () {
+            return 7;
+        };
+
+        DoStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.doKeyword;
+                case 1:
+                    return this.statement;
+                case 2:
+                    return this.whileKeyword;
+                case 3:
+                    return this.openParenToken;
+                case 4:
+                    return this.condition;
+                case 5:
+                    return this.closeParenToken;
+                case 6:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        DoStatementSyntax.prototype.isIterationStatement = function () {
+            return true;
+        };
+
+        DoStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        DoStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        DoStatementSyntax.prototype.update = function (doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken) {
+            if (this.doKeyword === doKeyword && this.statement === statement && this.whileKeyword === whileKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, this.parsedInStrictMode());
+        };
+
+        DoStatementSyntax.create1 = function (statement, condition) {
+            return new DoStatementSyntax(TypeScript.Syntax.token(22 /* DoKeyword */), statement, TypeScript.Syntax.token(42 /* WhileKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        DoStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        DoStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        DoStatementSyntax.prototype.withDoKeyword = function (doKeyword) {
+            return this.update(doKeyword, this.statement, this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.semicolonToken);
+        };
+
+        DoStatementSyntax.prototype.withStatement = function (statement) {
+            return this.update(this.doKeyword, statement, this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.semicolonToken);
+        };
+
+        DoStatementSyntax.prototype.withWhileKeyword = function (whileKeyword) {
+            return this.update(this.doKeyword, this.statement, whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.semicolonToken);
+        };
+
+        DoStatementSyntax.prototype.withOpenParenToken = function (openParenToken) {
+            return this.update(this.doKeyword, this.statement, this.whileKeyword, openParenToken, this.condition, this.closeParenToken, this.semicolonToken);
+        };
+
+        DoStatementSyntax.prototype.withCondition = function (condition) {
+            return this.update(this.doKeyword, this.statement, this.whileKeyword, this.openParenToken, condition, this.closeParenToken, this.semicolonToken);
+        };
+
+        DoStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) {
+            return this.update(this.doKeyword, this.statement, this.whileKeyword, this.openParenToken, this.condition, closeParenToken, this.semicolonToken);
+        };
+
+        DoStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.doKeyword, this.statement, this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, semicolonToken);
+        };
+
+        DoStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.statement.isTypeScriptSpecific()) {
+                return true;
+            }
+            if (this.condition.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return DoStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.DoStatementSyntax = DoStatementSyntax;
+
+    var TypeOfExpressionSyntax = (function (_super) {
+        __extends(TypeOfExpressionSyntax, _super);
+        function TypeOfExpressionSyntax(typeOfKeyword, expression, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.typeOfKeyword = typeOfKeyword;
+            this.expression = expression;
+        }
+        TypeOfExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitTypeOfExpression(this);
+        };
+
+        TypeOfExpressionSyntax.prototype.kind = function () {
+            return 171 /* TypeOfExpression */;
+        };
+
+        TypeOfExpressionSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        TypeOfExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.typeOfKeyword;
+                case 1:
+                    return this.expression;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        TypeOfExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        TypeOfExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        TypeOfExpressionSyntax.prototype.update = function (typeOfKeyword, expression) {
+            if (this.typeOfKeyword === typeOfKeyword && this.expression === expression) {
+                return this;
+            }
+
+            return new TypeOfExpressionSyntax(typeOfKeyword, expression, this.parsedInStrictMode());
+        };
+
+        TypeOfExpressionSyntax.create1 = function (expression) {
+            return new TypeOfExpressionSyntax(TypeScript.Syntax.token(39 /* TypeOfKeyword */), expression, false);
+        };
+
+        TypeOfExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        TypeOfExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        TypeOfExpressionSyntax.prototype.withTypeOfKeyword = function (typeOfKeyword) {
+            return this.update(typeOfKeyword, this.expression);
+        };
+
+        TypeOfExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.typeOfKeyword, expression);
+        };
+
+        TypeOfExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return TypeOfExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.TypeOfExpressionSyntax = TypeOfExpressionSyntax;
+
+    var DeleteExpressionSyntax = (function (_super) {
+        __extends(DeleteExpressionSyntax, _super);
+        function DeleteExpressionSyntax(deleteKeyword, expression, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.deleteKeyword = deleteKeyword;
+            this.expression = expression;
+        }
+        DeleteExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitDeleteExpression(this);
+        };
+
+        DeleteExpressionSyntax.prototype.kind = function () {
+            return 170 /* DeleteExpression */;
+        };
+
+        DeleteExpressionSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        DeleteExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.deleteKeyword;
+                case 1:
+                    return this.expression;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        DeleteExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        DeleteExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        DeleteExpressionSyntax.prototype.update = function (deleteKeyword, expression) {
+            if (this.deleteKeyword === deleteKeyword && this.expression === expression) {
+                return this;
+            }
+
+            return new DeleteExpressionSyntax(deleteKeyword, expression, this.parsedInStrictMode());
+        };
+
+        DeleteExpressionSyntax.create1 = function (expression) {
+            return new DeleteExpressionSyntax(TypeScript.Syntax.token(21 /* DeleteKeyword */), expression, false);
+        };
+
+        DeleteExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        DeleteExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        DeleteExpressionSyntax.prototype.withDeleteKeyword = function (deleteKeyword) {
+            return this.update(deleteKeyword, this.expression);
+        };
+
+        DeleteExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.deleteKeyword, expression);
+        };
+
+        DeleteExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return DeleteExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.DeleteExpressionSyntax = DeleteExpressionSyntax;
+
+    var VoidExpressionSyntax = (function (_super) {
+        __extends(VoidExpressionSyntax, _super);
+        function VoidExpressionSyntax(voidKeyword, expression, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.voidKeyword = voidKeyword;
+            this.expression = expression;
+        }
+        VoidExpressionSyntax.prototype.accept = function (visitor) {
+            return visitor.visitVoidExpression(this);
+        };
+
+        VoidExpressionSyntax.prototype.kind = function () {
+            return 172 /* VoidExpression */;
+        };
+
+        VoidExpressionSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        VoidExpressionSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.voidKeyword;
+                case 1:
+                    return this.expression;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        VoidExpressionSyntax.prototype.isUnaryExpression = function () {
+            return true;
+        };
+
+        VoidExpressionSyntax.prototype.isExpression = function () {
+            return true;
+        };
+
+        VoidExpressionSyntax.prototype.update = function (voidKeyword, expression) {
+            if (this.voidKeyword === voidKeyword && this.expression === expression) {
+                return this;
+            }
+
+            return new VoidExpressionSyntax(voidKeyword, expression, this.parsedInStrictMode());
+        };
+
+        VoidExpressionSyntax.create1 = function (expression) {
+            return new VoidExpressionSyntax(TypeScript.Syntax.token(41 /* VoidKeyword */), expression, false);
+        };
+
+        VoidExpressionSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        VoidExpressionSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        VoidExpressionSyntax.prototype.withVoidKeyword = function (voidKeyword) {
+            return this.update(voidKeyword, this.expression);
+        };
+
+        VoidExpressionSyntax.prototype.withExpression = function (expression) {
+            return this.update(this.voidKeyword, expression);
+        };
+
+        VoidExpressionSyntax.prototype.isTypeScriptSpecific = function () {
+            if (this.expression.isTypeScriptSpecific()) {
+                return true;
+            }
+            return false;
+        };
+        return VoidExpressionSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.VoidExpressionSyntax = VoidExpressionSyntax;
+
+    var DebuggerStatementSyntax = (function (_super) {
+        __extends(DebuggerStatementSyntax, _super);
+        function DebuggerStatementSyntax(debuggerKeyword, semicolonToken, parsedInStrictMode) {
+            _super.call(this, parsedInStrictMode);
+            this.debuggerKeyword = debuggerKeyword;
+            this.semicolonToken = semicolonToken;
+        }
+        DebuggerStatementSyntax.prototype.accept = function (visitor) {
+            return visitor.visitDebuggerStatement(this);
+        };
+
+        DebuggerStatementSyntax.prototype.kind = function () {
+            return 162 /* DebuggerStatement */;
+        };
+
+        DebuggerStatementSyntax.prototype.childCount = function () {
+            return 2;
+        };
+
+        DebuggerStatementSyntax.prototype.childAt = function (slot) {
+            switch (slot) {
+                case 0:
+                    return this.debuggerKeyword;
+                case 1:
+                    return this.semicolonToken;
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        DebuggerStatementSyntax.prototype.isStatement = function () {
+            return true;
+        };
+
+        DebuggerStatementSyntax.prototype.isModuleElement = function () {
+            return true;
+        };
+
+        DebuggerStatementSyntax.prototype.update = function (debuggerKeyword, semicolonToken) {
+            if (this.debuggerKeyword === debuggerKeyword && this.semicolonToken === semicolonToken) {
+                return this;
+            }
+
+            return new DebuggerStatementSyntax(debuggerKeyword, semicolonToken, this.parsedInStrictMode());
+        };
+
+        DebuggerStatementSyntax.create1 = function () {
+            return new DebuggerStatementSyntax(TypeScript.Syntax.token(19 /* DebuggerKeyword */), TypeScript.Syntax.token(78 /* SemicolonToken */), false);
+        };
+
+        DebuggerStatementSyntax.prototype.withLeadingTrivia = function (trivia) {
+            return _super.prototype.withLeadingTrivia.call(this, trivia);
+        };
+
+        DebuggerStatementSyntax.prototype.withTrailingTrivia = function (trivia) {
+            return _super.prototype.withTrailingTrivia.call(this, trivia);
+        };
+
+        DebuggerStatementSyntax.prototype.withDebuggerKeyword = function (debuggerKeyword) {
+            return this.update(debuggerKeyword, this.semicolonToken);
+        };
+
+        DebuggerStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) {
+            return this.update(this.debuggerKeyword, semicolonToken);
+        };
+
+        DebuggerStatementSyntax.prototype.isTypeScriptSpecific = function () {
+            return false;
+        };
+        return DebuggerStatementSyntax;
+    })(TypeScript.SyntaxNode);
+    TypeScript.DebuggerStatementSyntax = DebuggerStatementSyntax;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxRewriter = (function () {
+        function SyntaxRewriter() {
+        }
+        SyntaxRewriter.prototype.visitToken = function (token) {
+            return token;
+        };
+
+        SyntaxRewriter.prototype.visitNode = function (node) {
+            return node.accept(this);
+        };
+
+        SyntaxRewriter.prototype.visitNodeOrToken = function (node) {
+            return node.isToken() ? this.visitToken(node) : this.visitNode(node);
+        };
+
+        SyntaxRewriter.prototype.visitList = function (list) {
+            var newItems = null;
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var item = list.childAt(i);
+                var newItem = this.visitNodeOrToken(item);
+
+                if (item !== newItem && newItems === null) {
+                    newItems = [];
+                    for (var j = 0; j < i; j++) {
+                        newItems.push(list.childAt(j));
+                    }
+                }
+
+                if (newItems) {
+                    newItems.push(newItem);
+                }
+            }
+
+            return newItems === null ? list : TypeScript.Syntax.list(newItems);
+        };
+
+        SyntaxRewriter.prototype.visitSeparatedList = function (list) {
+            var newItems = null;
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var item = list.childAt(i);
+                var newItem = item.isToken() ? this.visitToken(item) : this.visitNode(item);
+
+                if (item !== newItem && newItems === null) {
+                    newItems = [];
+                    for (var j = 0; j < i; j++) {
+                        newItems.push(list.childAt(j));
+                    }
+                }
+
+                if (newItems) {
+                    newItems.push(newItem);
+                }
+            }
+
+            return newItems === null ? list : TypeScript.Syntax.separatedList(newItems);
+        };
+
+        SyntaxRewriter.prototype.visitSourceUnit = function (node) {
+            return node.update(this.visitList(node.moduleElements), this.visitToken(node.endOfFileToken));
+        };
+
+        SyntaxRewriter.prototype.visitExternalModuleReference = function (node) {
+            return node.update(this.visitToken(node.requireKeyword), this.visitToken(node.openParenToken), this.visitToken(node.stringLiteral), this.visitToken(node.closeParenToken));
+        };
+
+        SyntaxRewriter.prototype.visitModuleNameModuleReference = function (node) {
+            return node.update(this.visitNodeOrToken(node.moduleName));
+        };
+
+        SyntaxRewriter.prototype.visitImportDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.importKeyword), this.visitToken(node.identifier), this.visitToken(node.equalsToken), this.visitNodeOrToken(node.moduleReference), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitExportAssignment = function (node) {
+            return node.update(this.visitToken(node.exportKeyword), this.visitToken(node.equalsToken), this.visitToken(node.identifier), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitClassDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.classKeyword), this.visitToken(node.identifier), node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitList(node.heritageClauses), this.visitToken(node.openBraceToken), this.visitList(node.classElements), this.visitToken(node.closeBraceToken));
+        };
+
+        SyntaxRewriter.prototype.visitInterfaceDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.interfaceKeyword), this.visitToken(node.identifier), node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitList(node.heritageClauses), this.visitNode(node.body));
+        };
+
+        SyntaxRewriter.prototype.visitHeritageClause = function (node) {
+            return node.update(node.kind(), this.visitToken(node.extendsOrImplementsKeyword), this.visitSeparatedList(node.typeNames));
+        };
+
+        SyntaxRewriter.prototype.visitModuleDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.moduleKeyword), node.name === null ? null : this.visitNodeOrToken(node.name), node.stringLiteral === null ? null : this.visitToken(node.stringLiteral), this.visitToken(node.openBraceToken), this.visitList(node.moduleElements), this.visitToken(node.closeBraceToken));
+        };
+
+        SyntaxRewriter.prototype.visitFunctionDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.functionKeyword), this.visitToken(node.identifier), this.visitNode(node.callSignature), node.block === null ? null : this.visitNode(node.block), node.semicolonToken === null ? null : this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitVariableStatement = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitNode(node.variableDeclaration), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitVariableDeclaration = function (node) {
+            return node.update(this.visitToken(node.varKeyword), this.visitSeparatedList(node.variableDeclarators));
+        };
+
+        SyntaxRewriter.prototype.visitVariableDeclarator = function (node) {
+            return node.update(this.visitToken(node.propertyName), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), node.equalsValueClause === null ? null : this.visitNode(node.equalsValueClause));
+        };
+
+        SyntaxRewriter.prototype.visitEqualsValueClause = function (node) {
+            return node.update(this.visitToken(node.equalsToken), this.visitNodeOrToken(node.value));
+        };
+
+        SyntaxRewriter.prototype.visitPrefixUnaryExpression = function (node) {
+            return node.update(node.kind(), this.visitToken(node.operatorToken), this.visitNodeOrToken(node.operand));
+        };
+
+        SyntaxRewriter.prototype.visitArrayLiteralExpression = function (node) {
+            return node.update(this.visitToken(node.openBracketToken), this.visitSeparatedList(node.expressions), this.visitToken(node.closeBracketToken));
+        };
+
+        SyntaxRewriter.prototype.visitOmittedExpression = function (node) {
+            return node;
+        };
+
+        SyntaxRewriter.prototype.visitParenthesizedExpression = function (node) {
+            return node.update(this.visitToken(node.openParenToken), this.visitNodeOrToken(node.expression), this.visitToken(node.closeParenToken));
+        };
+
+        SyntaxRewriter.prototype.visitSimpleArrowFunctionExpression = function (node) {
+            return node.update(this.visitToken(node.identifier), this.visitToken(node.equalsGreaterThanToken), node.block === null ? null : this.visitNode(node.block), node.expression === null ? null : this.visitNodeOrToken(node.expression));
+        };
+
+        SyntaxRewriter.prototype.visitParenthesizedArrowFunctionExpression = function (node) {
+            return node.update(this.visitNode(node.callSignature), this.visitToken(node.equalsGreaterThanToken), node.block === null ? null : this.visitNode(node.block), node.expression === null ? null : this.visitNodeOrToken(node.expression));
+        };
+
+        SyntaxRewriter.prototype.visitQualifiedName = function (node) {
+            return node.update(this.visitNodeOrToken(node.left), this.visitToken(node.dotToken), this.visitToken(node.right));
+        };
+
+        SyntaxRewriter.prototype.visitTypeArgumentList = function (node) {
+            return node.update(this.visitToken(node.lessThanToken), this.visitSeparatedList(node.typeArguments), this.visitToken(node.greaterThanToken));
+        };
+
+        SyntaxRewriter.prototype.visitConstructorType = function (node) {
+            return node.update(this.visitToken(node.newKeyword), node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitNode(node.parameterList), this.visitToken(node.equalsGreaterThanToken), this.visitNodeOrToken(node.type));
+        };
+
+        SyntaxRewriter.prototype.visitFunctionType = function (node) {
+            return node.update(node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitNode(node.parameterList), this.visitToken(node.equalsGreaterThanToken), this.visitNodeOrToken(node.type));
+        };
+
+        SyntaxRewriter.prototype.visitObjectType = function (node) {
+            return node.update(this.visitToken(node.openBraceToken), this.visitSeparatedList(node.typeMembers), this.visitToken(node.closeBraceToken));
+        };
+
+        SyntaxRewriter.prototype.visitArrayType = function (node) {
+            return node.update(this.visitNodeOrToken(node.type), this.visitToken(node.openBracketToken), this.visitToken(node.closeBracketToken));
+        };
+
+        SyntaxRewriter.prototype.visitGenericType = function (node) {
+            return node.update(this.visitNodeOrToken(node.name), this.visitNode(node.typeArgumentList));
+        };
+
+        SyntaxRewriter.prototype.visitTypeQuery = function (node) {
+            return node.update(this.visitToken(node.typeOfKeyword), this.visitNodeOrToken(node.name));
+        };
+
+        SyntaxRewriter.prototype.visitTypeAnnotation = function (node) {
+            return node.update(this.visitToken(node.colonToken), this.visitNodeOrToken(node.type));
+        };
+
+        SyntaxRewriter.prototype.visitBlock = function (node) {
+            return node.update(this.visitToken(node.openBraceToken), this.visitList(node.statements), this.visitToken(node.closeBraceToken));
+        };
+
+        SyntaxRewriter.prototype.visitParameter = function (node) {
+            return node.update(node.dotDotDotToken === null ? null : this.visitToken(node.dotDotDotToken), this.visitList(node.modifiers), this.visitToken(node.identifier), node.questionToken === null ? null : this.visitToken(node.questionToken), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), node.equalsValueClause === null ? null : this.visitNode(node.equalsValueClause));
+        };
+
+        SyntaxRewriter.prototype.visitMemberAccessExpression = function (node) {
+            return node.update(this.visitNodeOrToken(node.expression), this.visitToken(node.dotToken), this.visitToken(node.name));
+        };
+
+        SyntaxRewriter.prototype.visitPostfixUnaryExpression = function (node) {
+            return node.update(node.kind(), this.visitNodeOrToken(node.operand), this.visitToken(node.operatorToken));
+        };
+
+        SyntaxRewriter.prototype.visitElementAccessExpression = function (node) {
+            return node.update(this.visitNodeOrToken(node.expression), this.visitToken(node.openBracketToken), this.visitNodeOrToken(node.argumentExpression), this.visitToken(node.closeBracketToken));
+        };
+
+        SyntaxRewriter.prototype.visitInvocationExpression = function (node) {
+            return node.update(this.visitNodeOrToken(node.expression), this.visitNode(node.argumentList));
+        };
+
+        SyntaxRewriter.prototype.visitArgumentList = function (node) {
+            return node.update(node.typeArgumentList === null ? null : this.visitNode(node.typeArgumentList), this.visitToken(node.openParenToken), this.visitSeparatedList(node.arguments), this.visitToken(node.closeParenToken));
+        };
+
+        SyntaxRewriter.prototype.visitBinaryExpression = function (node) {
+            return node.update(node.kind(), this.visitNodeOrToken(node.left), this.visitToken(node.operatorToken), this.visitNodeOrToken(node.right));
+        };
+
+        SyntaxRewriter.prototype.visitConditionalExpression = function (node) {
+            return node.update(this.visitNodeOrToken(node.condition), this.visitToken(node.questionToken), this.visitNodeOrToken(node.whenTrue), this.visitToken(node.colonToken), this.visitNodeOrToken(node.whenFalse));
+        };
+
+        SyntaxRewriter.prototype.visitConstructSignature = function (node) {
+            return node.update(this.visitToken(node.newKeyword), this.visitNode(node.callSignature));
+        };
+
+        SyntaxRewriter.prototype.visitMethodSignature = function (node) {
+            return node.update(this.visitToken(node.propertyName), node.questionToken === null ? null : this.visitToken(node.questionToken), this.visitNode(node.callSignature));
+        };
+
+        SyntaxRewriter.prototype.visitIndexSignature = function (node) {
+            return node.update(this.visitToken(node.openBracketToken), this.visitNode(node.parameter), this.visitToken(node.closeBracketToken), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation));
+        };
+
+        SyntaxRewriter.prototype.visitPropertySignature = function (node) {
+            return node.update(this.visitToken(node.propertyName), node.questionToken === null ? null : this.visitToken(node.questionToken), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation));
+        };
+
+        SyntaxRewriter.prototype.visitCallSignature = function (node) {
+            return node.update(node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitNode(node.parameterList), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation));
+        };
+
+        SyntaxRewriter.prototype.visitParameterList = function (node) {
+            return node.update(this.visitToken(node.openParenToken), this.visitSeparatedList(node.parameters), this.visitToken(node.closeParenToken));
+        };
+
+        SyntaxRewriter.prototype.visitTypeParameterList = function (node) {
+            return node.update(this.visitToken(node.lessThanToken), this.visitSeparatedList(node.typeParameters), this.visitToken(node.greaterThanToken));
+        };
+
+        SyntaxRewriter.prototype.visitTypeParameter = function (node) {
+            return node.update(this.visitToken(node.identifier), node.constraint === null ? null : this.visitNode(node.constraint));
+        };
+
+        SyntaxRewriter.prototype.visitConstraint = function (node) {
+            return node.update(this.visitToken(node.extendsKeyword), this.visitNodeOrToken(node.type));
+        };
+
+        SyntaxRewriter.prototype.visitElseClause = function (node) {
+            return node.update(this.visitToken(node.elseKeyword), this.visitNodeOrToken(node.statement));
+        };
+
+        SyntaxRewriter.prototype.visitIfStatement = function (node) {
+            return node.update(this.visitToken(node.ifKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement), node.elseClause === null ? null : this.visitNode(node.elseClause));
+        };
+
+        SyntaxRewriter.prototype.visitExpressionStatement = function (node) {
+            return node.update(this.visitNodeOrToken(node.expression), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitConstructorDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.constructorKeyword), this.visitNode(node.callSignature), node.block === null ? null : this.visitNode(node.block), node.semicolonToken === null ? null : this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitMemberFunctionDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.propertyName), this.visitNode(node.callSignature), node.block === null ? null : this.visitNode(node.block), node.semicolonToken === null ? null : this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitGetAccessor = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.getKeyword), this.visitToken(node.propertyName), this.visitNode(node.parameterList), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), this.visitNode(node.block));
+        };
+
+        SyntaxRewriter.prototype.visitSetAccessor = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.setKeyword), this.visitToken(node.propertyName), this.visitNode(node.parameterList), this.visitNode(node.block));
+        };
+
+        SyntaxRewriter.prototype.visitMemberVariableDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitNode(node.variableDeclarator), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitIndexMemberDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitNode(node.indexSignature), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitThrowStatement = function (node) {
+            return node.update(this.visitToken(node.throwKeyword), this.visitNodeOrToken(node.expression), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitReturnStatement = function (node) {
+            return node.update(this.visitToken(node.returnKeyword), node.expression === null ? null : this.visitNodeOrToken(node.expression), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitObjectCreationExpression = function (node) {
+            return node.update(this.visitToken(node.newKeyword), this.visitNodeOrToken(node.expression), node.argumentList === null ? null : this.visitNode(node.argumentList));
+        };
+
+        SyntaxRewriter.prototype.visitSwitchStatement = function (node) {
+            return node.update(this.visitToken(node.switchKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.expression), this.visitToken(node.closeParenToken), this.visitToken(node.openBraceToken), this.visitList(node.switchClauses), this.visitToken(node.closeBraceToken));
+        };
+
+        SyntaxRewriter.prototype.visitCaseSwitchClause = function (node) {
+            return node.update(this.visitToken(node.caseKeyword), this.visitNodeOrToken(node.expression), this.visitToken(node.colonToken), this.visitList(node.statements));
+        };
+
+        SyntaxRewriter.prototype.visitDefaultSwitchClause = function (node) {
+            return node.update(this.visitToken(node.defaultKeyword), this.visitToken(node.colonToken), this.visitList(node.statements));
+        };
+
+        SyntaxRewriter.prototype.visitBreakStatement = function (node) {
+            return node.update(this.visitToken(node.breakKeyword), node.identifier === null ? null : this.visitToken(node.identifier), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitContinueStatement = function (node) {
+            return node.update(this.visitToken(node.continueKeyword), node.identifier === null ? null : this.visitToken(node.identifier), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitForStatement = function (node) {
+            return node.update(this.visitToken(node.forKeyword), this.visitToken(node.openParenToken), node.variableDeclaration === null ? null : this.visitNode(node.variableDeclaration), node.initializer === null ? null : this.visitNodeOrToken(node.initializer), this.visitToken(node.firstSemicolonToken), node.condition === null ? null : this.visitNodeOrToken(node.condition), this.visitToken(node.secondSemicolonToken), node.incrementor === null ? null : this.visitNodeOrToken(node.incrementor), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement));
+        };
+
+        SyntaxRewriter.prototype.visitForInStatement = function (node) {
+            return node.update(this.visitToken(node.forKeyword), this.visitToken(node.openParenToken), node.variableDeclaration === null ? null : this.visitNode(node.variableDeclaration), node.left === null ? null : this.visitNodeOrToken(node.left), this.visitToken(node.inKeyword), this.visitNodeOrToken(node.expression), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement));
+        };
+
+        SyntaxRewriter.prototype.visitWhileStatement = function (node) {
+            return node.update(this.visitToken(node.whileKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement));
+        };
+
+        SyntaxRewriter.prototype.visitWithStatement = function (node) {
+            return node.update(this.visitToken(node.withKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement));
+        };
+
+        SyntaxRewriter.prototype.visitEnumDeclaration = function (node) {
+            return node.update(this.visitList(node.modifiers), this.visitToken(node.enumKeyword), this.visitToken(node.identifier), this.visitToken(node.openBraceToken), this.visitSeparatedList(node.enumElements), this.visitToken(node.closeBraceToken));
+        };
+
+        SyntaxRewriter.prototype.visitEnumElement = function (node) {
+            return node.update(this.visitToken(node.propertyName), node.equalsValueClause === null ? null : this.visitNode(node.equalsValueClause));
+        };
+
+        SyntaxRewriter.prototype.visitCastExpression = function (node) {
+            return node.update(this.visitToken(node.lessThanToken), this.visitNodeOrToken(node.type), this.visitToken(node.greaterThanToken), this.visitNodeOrToken(node.expression));
+        };
+
+        SyntaxRewriter.prototype.visitObjectLiteralExpression = function (node) {
+            return node.update(this.visitToken(node.openBraceToken), this.visitSeparatedList(node.propertyAssignments), this.visitToken(node.closeBraceToken));
+        };
+
+        SyntaxRewriter.prototype.visitSimplePropertyAssignment = function (node) {
+            return node.update(this.visitToken(node.propertyName), this.visitToken(node.colonToken), this.visitNodeOrToken(node.expression));
+        };
+
+        SyntaxRewriter.prototype.visitFunctionPropertyAssignment = function (node) {
+            return node.update(this.visitToken(node.propertyName), this.visitNode(node.callSignature), this.visitNode(node.block));
+        };
+
+        SyntaxRewriter.prototype.visitFunctionExpression = function (node) {
+            return node.update(this.visitToken(node.functionKeyword), node.identifier === null ? null : this.visitToken(node.identifier), this.visitNode(node.callSignature), this.visitNode(node.block));
+        };
+
+        SyntaxRewriter.prototype.visitEmptyStatement = function (node) {
+            return node.update(this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitTryStatement = function (node) {
+            return node.update(this.visitToken(node.tryKeyword), this.visitNode(node.block), node.catchClause === null ? null : this.visitNode(node.catchClause), node.finallyClause === null ? null : this.visitNode(node.finallyClause));
+        };
+
+        SyntaxRewriter.prototype.visitCatchClause = function (node) {
+            return node.update(this.visitToken(node.catchKeyword), this.visitToken(node.openParenToken), this.visitToken(node.identifier), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), this.visitToken(node.closeParenToken), this.visitNode(node.block));
+        };
+
+        SyntaxRewriter.prototype.visitFinallyClause = function (node) {
+            return node.update(this.visitToken(node.finallyKeyword), this.visitNode(node.block));
+        };
+
+        SyntaxRewriter.prototype.visitLabeledStatement = function (node) {
+            return node.update(this.visitToken(node.identifier), this.visitToken(node.colonToken), this.visitNodeOrToken(node.statement));
+        };
+
+        SyntaxRewriter.prototype.visitDoStatement = function (node) {
+            return node.update(this.visitToken(node.doKeyword), this.visitNodeOrToken(node.statement), this.visitToken(node.whileKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitToken(node.semicolonToken));
+        };
+
+        SyntaxRewriter.prototype.visitTypeOfExpression = function (node) {
+            return node.update(this.visitToken(node.typeOfKeyword), this.visitNodeOrToken(node.expression));
+        };
+
+        SyntaxRewriter.prototype.visitDeleteExpression = function (node) {
+            return node.update(this.visitToken(node.deleteKeyword), this.visitNodeOrToken(node.expression));
+        };
+
+        SyntaxRewriter.prototype.visitVoidExpression = function (node) {
+            return node.update(this.visitToken(node.voidKeyword), this.visitNodeOrToken(node.expression));
+        };
+
+        SyntaxRewriter.prototype.visitDebuggerStatement = function (node) {
+            return node.update(this.visitToken(node.debuggerKeyword), this.visitToken(node.semicolonToken));
+        };
+        return SyntaxRewriter;
+    })();
+    TypeScript.SyntaxRewriter = SyntaxRewriter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxDedenter = (function (_super) {
+        __extends(SyntaxDedenter, _super);
+        function SyntaxDedenter(dedentFirstToken, dedentationAmount, minimumIndent, options) {
+            _super.call(this);
+            this.dedentationAmount = dedentationAmount;
+            this.minimumIndent = minimumIndent;
+            this.options = options;
+            this.lastTriviaWasNewLine = dedentFirstToken;
+        }
+        SyntaxDedenter.prototype.abort = function () {
+            this.lastTriviaWasNewLine = false;
+            this.dedentationAmount = 0;
+        };
+
+        SyntaxDedenter.prototype.isAborted = function () {
+            return this.dedentationAmount === 0;
+        };
+
+        SyntaxDedenter.prototype.visitToken = function (token) {
+            if (token.width() === 0) {
+                return token;
+            }
+
+            var result = token;
+            if (this.lastTriviaWasNewLine) {
+                result = token.withLeadingTrivia(this.dedentTriviaList(token.leadingTrivia()));
+            }
+
+            if (this.isAborted()) {
+                return token;
+            }
+
+            this.lastTriviaWasNewLine = token.hasTrailingNewLine();
+            return result;
+        };
+
+        SyntaxDedenter.prototype.dedentTriviaList = function (triviaList) {
+            var result = [];
+            var dedentNextWhitespace = true;
+
+            for (var i = 0, n = triviaList.count(); i < n && !this.isAborted(); i++) {
+                var trivia = triviaList.syntaxTriviaAt(i);
+
+                var dedentThisTrivia = dedentNextWhitespace;
+                dedentNextWhitespace = false;
+
+                if (dedentThisTrivia) {
+                    if (trivia.kind() === 4 /* WhitespaceTrivia */) {
+                        var hasFollowingNewLine = (i < triviaList.count() - 1) && triviaList.syntaxTriviaAt(i + 1).kind() === 5 /* NewLineTrivia */;
+                        result.push(this.dedentWhitespace(trivia, hasFollowingNewLine));
+                        continue;
+                    } else if (trivia.kind() !== 5 /* NewLineTrivia */) {
+                        this.abort();
+                        break;
+                    }
+                }
+
+                if (trivia.kind() === 6 /* MultiLineCommentTrivia */) {
+                    result.push(this.dedentMultiLineComment(trivia));
+                    continue;
+                }
+
+                result.push(trivia);
+                if (trivia.kind() === 5 /* NewLineTrivia */) {
+                    dedentNextWhitespace = true;
+                }
+            }
+
+            if (dedentNextWhitespace) {
+                this.abort();
+            }
+
+            if (this.isAborted()) {
+                return triviaList;
+            }
+
+            return TypeScript.Syntax.triviaList(result);
+        };
+
+        SyntaxDedenter.prototype.dedentSegment = function (segment, hasFollowingNewLineTrivia) {
+            var firstNonWhitespacePosition = TypeScript.Indentation.firstNonWhitespacePosition(segment);
+
+            if (firstNonWhitespacePosition === segment.length) {
+                if (hasFollowingNewLineTrivia) {
+                    return "";
+                }
+            } else if (TypeScript.CharacterInfo.isLineTerminator(segment.charCodeAt(firstNonWhitespacePosition))) {
+                return segment.substring(firstNonWhitespacePosition);
+            }
+
+            var firstNonWhitespaceColumn = TypeScript.Indentation.columnForPositionInString(segment, firstNonWhitespacePosition, this.options);
+
+            var newFirstNonWhitespaceColumn = TypeScript.MathPrototype.min(firstNonWhitespaceColumn, TypeScript.MathPrototype.max(firstNonWhitespaceColumn - this.dedentationAmount, this.minimumIndent));
+
+            if (newFirstNonWhitespaceColumn === firstNonWhitespaceColumn) {
+                this.abort();
+                return segment;
+            }
+
+            this.dedentationAmount = firstNonWhitespaceColumn - newFirstNonWhitespaceColumn;
+            TypeScript.Debug.assert(this.dedentationAmount >= 0);
+
+            var indentationString = TypeScript.Indentation.indentationString(newFirstNonWhitespaceColumn, this.options);
+
+            return indentationString + segment.substring(firstNonWhitespacePosition);
+        };
+
+        SyntaxDedenter.prototype.dedentWhitespace = function (trivia, hasFollowingNewLineTrivia) {
+            var newIndentation = this.dedentSegment(trivia.fullText(), hasFollowingNewLineTrivia);
+            return TypeScript.Syntax.whitespace(newIndentation);
+        };
+
+        SyntaxDedenter.prototype.dedentMultiLineComment = function (trivia) {
+            var segments = TypeScript.Syntax.splitMultiLineCommentTriviaIntoMultipleLines(trivia);
+            if (segments.length === 1) {
+                return trivia;
+            }
+
+            for (var i = 1; i < segments.length; i++) {
+                var segment = segments[i];
+                segments[i] = this.dedentSegment(segment, false);
+            }
+
+            var result = segments.join("");
+
+            return TypeScript.Syntax.multiLineComment(result);
+        };
+
+        SyntaxDedenter.dedentNode = function (node, dedentFirstToken, dedentAmount, minimumIndent, options) {
+            var dedenter = new SyntaxDedenter(dedentFirstToken, dedentAmount, minimumIndent, options);
+            var result = node.accept(dedenter);
+
+            if (dedenter.isAborted()) {
+                return node;
+            }
+
+            return result;
+        };
+        return SyntaxDedenter;
+    })(TypeScript.SyntaxRewriter);
+    TypeScript.SyntaxDedenter = SyntaxDedenter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxIndenter = (function (_super) {
+        __extends(SyntaxIndenter, _super);
+        function SyntaxIndenter(indentFirstToken, indentationAmount, options) {
+            _super.call(this);
+            this.indentationAmount = indentationAmount;
+            this.options = options;
+            this.lastTriviaWasNewLine = indentFirstToken;
+            this.indentationTrivia = TypeScript.Indentation.indentationTrivia(this.indentationAmount, this.options);
+        }
+        SyntaxIndenter.prototype.visitToken = function (token) {
+            if (token.width() === 0) {
+                return token;
+            }
+
+            var result = token;
+            if (this.lastTriviaWasNewLine) {
+                result = token.withLeadingTrivia(this.indentTriviaList(token.leadingTrivia()));
+            }
+
+            this.lastTriviaWasNewLine = token.hasTrailingNewLine();
+            return result;
+        };
+
+        SyntaxIndenter.prototype.indentTriviaList = function (triviaList) {
+            var result = [];
+
+            var indentNextTrivia = true;
+            for (var i = 0, n = triviaList.count(); i < n; i++) {
+                var trivia = triviaList.syntaxTriviaAt(i);
+
+                var indentThisTrivia = indentNextTrivia;
+                indentNextTrivia = false;
+
+                switch (trivia.kind()) {
+                    case 6 /* MultiLineCommentTrivia */:
+                        this.indentMultiLineComment(trivia, indentThisTrivia, result);
+                        continue;
+
+                    case 7 /* SingleLineCommentTrivia */:
+                    case 8 /* SkippedTokenTrivia */:
+                        this.indentSingleLineOrSkippedText(trivia, indentThisTrivia, result);
+                        continue;
+
+                    case 4 /* WhitespaceTrivia */:
+                        this.indentWhitespace(trivia, indentThisTrivia, result);
+                        continue;
+
+                    case 5 /* NewLineTrivia */:
+                        result.push(trivia);
+                        indentNextTrivia = true;
+                        continue;
+
+                    default:
+                        throw TypeScript.Errors.invalidOperation();
+                }
+            }
+
+            if (indentNextTrivia) {
+                result.push(this.indentationTrivia);
+            }
+
+            return TypeScript.Syntax.triviaList(result);
+        };
+
+        SyntaxIndenter.prototype.indentSegment = function (segment) {
+            var firstNonWhitespacePosition = TypeScript.Indentation.firstNonWhitespacePosition(segment);
+
+            if (firstNonWhitespacePosition < segment.length && TypeScript.CharacterInfo.isLineTerminator(segment.charCodeAt(firstNonWhitespacePosition))) {
+                return segment;
+            }
+
+            var firstNonWhitespaceColumn = TypeScript.Indentation.columnForPositionInString(segment, firstNonWhitespacePosition, this.options);
+
+            var newFirstNonWhitespaceColumn = firstNonWhitespaceColumn + this.indentationAmount;
+
+            var indentationString = TypeScript.Indentation.indentationString(newFirstNonWhitespaceColumn, this.options);
+
+            return indentationString + segment.substring(firstNonWhitespacePosition);
+        };
+
+        SyntaxIndenter.prototype.indentWhitespace = function (trivia, indentThisTrivia, result) {
+            if (!indentThisTrivia) {
+                result.push(trivia);
+                return;
+            }
+
+            var newIndentation = this.indentSegment(trivia.fullText());
+            result.push(TypeScript.Syntax.whitespace(newIndentation));
+        };
+
+        SyntaxIndenter.prototype.indentSingleLineOrSkippedText = function (trivia, indentThisTrivia, result) {
+            if (indentThisTrivia) {
+                result.push(this.indentationTrivia);
+            }
+
+            result.push(trivia);
+        };
+
+        SyntaxIndenter.prototype.indentMultiLineComment = function (trivia, indentThisTrivia, result) {
+            if (indentThisTrivia) {
+                result.push(this.indentationTrivia);
+            }
+
+            var segments = TypeScript.Syntax.splitMultiLineCommentTriviaIntoMultipleLines(trivia);
+
+            for (var i = 1; i < segments.length; i++) {
+                segments[i] = this.indentSegment(segments[i]);
+            }
+
+            var newText = segments.join("");
+            result.push(TypeScript.Syntax.multiLineComment(newText));
+        };
+
+        SyntaxIndenter.indentNode = function (node, indentFirstToken, indentAmount, options) {
+            var indenter = new SyntaxIndenter(indentFirstToken, indentAmount, options);
+            return node.accept(indenter);
+        };
+
+        SyntaxIndenter.indentNodes = function (nodes, indentFirstToken, indentAmount, options) {
+            var indenter = new SyntaxIndenter(indentFirstToken, indentAmount, options);
+            var result = TypeScript.ArrayUtilities.select(nodes, function (n) {
+                return n.accept(indenter);
+            });
+
+            return result;
+        };
+        return SyntaxIndenter;
+    })(TypeScript.SyntaxRewriter);
+    TypeScript.SyntaxIndenter = SyntaxIndenter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        var VariableWidthTokenWithNoTrivia = (function () {
+            function VariableWidthTokenWithNoTrivia(fullText, kind) {
+                this._fullText = fullText;
+                this.tokenKind = kind;
+            }
+            VariableWidthTokenWithNoTrivia.prototype.clone = function () {
+                return new VariableWidthTokenWithNoTrivia(this._fullText, this.tokenKind);
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.isNode = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.isToken = function () {
+                return true;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.isList = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.width = function () {
+                return this.fullWidth() - this.leadingTriviaWidth() - this.trailingTriviaWidth();
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.text = function () {
+                return this.fullText().substr(this.leadingTriviaWidth(), this.width());
+            };
+            VariableWidthTokenWithNoTrivia.prototype.fullText = function () {
+                return this._fullText;
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.value = function () {
+                if (this._value === undefined) {
+                    this._value = Syntax.value(this);
+                }
+
+                return this._value;
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.valueText = function () {
+                if (this._valueText === undefined) {
+                    this._valueText = Syntax.valueText(this);
+                }
+
+                return this._valueText;
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.hasLeadingTrivia = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.hasLeadingComment = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.hasLeadingNewLine = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.leadingTriviaWidth = function () {
+                return 0;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.leadingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.hasTrailingTrivia = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.hasTrailingComment = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.hasTrailingNewLine = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.trailingTriviaWidth = function () {
+                return 0;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.trailingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            VariableWidthTokenWithNoTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            VariableWidthTokenWithNoTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            VariableWidthTokenWithNoTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            VariableWidthTokenWithNoTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            VariableWidthTokenWithNoTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithNoTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return VariableWidthTokenWithNoTrivia;
+        })();
+        Syntax.VariableWidthTokenWithNoTrivia = VariableWidthTokenWithNoTrivia;
+
+        var VariableWidthTokenWithLeadingTrivia = (function () {
+            function VariableWidthTokenWithLeadingTrivia(fullText, kind, leadingTriviaInfo) {
+                this._fullText = fullText;
+                this.tokenKind = kind;
+                this._leadingTriviaInfo = leadingTriviaInfo;
+            }
+            VariableWidthTokenWithLeadingTrivia.prototype.clone = function () {
+                return new VariableWidthTokenWithLeadingTrivia(this._fullText, this.tokenKind, this._leadingTriviaInfo);
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.isNode = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.isToken = function () {
+                return true;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.isList = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.width = function () {
+                return this.fullWidth() - this.leadingTriviaWidth() - this.trailingTriviaWidth();
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.text = function () {
+                return this.fullText().substr(this.leadingTriviaWidth(), this.width());
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.fullText = function () {
+                return this._fullText;
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.value = function () {
+                if (this._value === undefined) {
+                    this._value = Syntax.value(this);
+                }
+
+                return this._value;
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.valueText = function () {
+                if (this._valueText === undefined) {
+                    this._valueText = Syntax.valueText(this);
+                }
+
+                return this._valueText;
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingTrivia = function () {
+                return true;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingComment = function () {
+                return hasTriviaComment(this._leadingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingNewLine = function () {
+                return hasTriviaNewLine(this._leadingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.leadingTriviaWidth = function () {
+                return getTriviaWidth(this._leadingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.leadingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), 0, getTriviaWidth(this._leadingTriviaInfo), false);
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingTrivia = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingComment = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingNewLine = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.trailingTriviaWidth = function () {
+                return 0;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.trailingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            VariableWidthTokenWithLeadingTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithLeadingTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return VariableWidthTokenWithLeadingTrivia;
+        })();
+        Syntax.VariableWidthTokenWithLeadingTrivia = VariableWidthTokenWithLeadingTrivia;
+
+        var VariableWidthTokenWithTrailingTrivia = (function () {
+            function VariableWidthTokenWithTrailingTrivia(fullText, kind, trailingTriviaInfo) {
+                this._fullText = fullText;
+                this.tokenKind = kind;
+                this._trailingTriviaInfo = trailingTriviaInfo;
+            }
+            VariableWidthTokenWithTrailingTrivia.prototype.clone = function () {
+                return new VariableWidthTokenWithTrailingTrivia(this._fullText, this.tokenKind, this._trailingTriviaInfo);
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.isNode = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.isToken = function () {
+                return true;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.isList = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.width = function () {
+                return this.fullWidth() - this.leadingTriviaWidth() - this.trailingTriviaWidth();
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.text = function () {
+                return this.fullText().substr(this.leadingTriviaWidth(), this.width());
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.fullText = function () {
+                return this._fullText;
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.value = function () {
+                if (this._value === undefined) {
+                    this._value = Syntax.value(this);
+                }
+
+                return this._value;
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.valueText = function () {
+                if (this._valueText === undefined) {
+                    this._valueText = Syntax.valueText(this);
+                }
+
+                return this._valueText;
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingTrivia = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingComment = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingNewLine = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.leadingTriviaWidth = function () {
+                return 0;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.leadingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingTrivia = function () {
+                return true;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingComment = function () {
+                return hasTriviaComment(this._trailingTriviaInfo);
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingNewLine = function () {
+                return hasTriviaNewLine(this._trailingTriviaInfo);
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.trailingTriviaWidth = function () {
+                return getTriviaWidth(this._trailingTriviaInfo);
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.trailingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), this.leadingTriviaWidth() + this.width(), getTriviaWidth(this._trailingTriviaInfo), true);
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            VariableWidthTokenWithTrailingTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithTrailingTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return VariableWidthTokenWithTrailingTrivia;
+        })();
+        Syntax.VariableWidthTokenWithTrailingTrivia = VariableWidthTokenWithTrailingTrivia;
+
+        var VariableWidthTokenWithLeadingAndTrailingTrivia = (function () {
+            function VariableWidthTokenWithLeadingAndTrailingTrivia(fullText, kind, leadingTriviaInfo, trailingTriviaInfo) {
+                this._fullText = fullText;
+                this.tokenKind = kind;
+                this._leadingTriviaInfo = leadingTriviaInfo;
+                this._trailingTriviaInfo = trailingTriviaInfo;
+            }
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.clone = function () {
+                return new VariableWidthTokenWithLeadingAndTrailingTrivia(this._fullText, this.tokenKind, this._leadingTriviaInfo, this._trailingTriviaInfo);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isNode = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isToken = function () {
+                return true;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isList = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.width = function () {
+                return this.fullWidth() - this.leadingTriviaWidth() - this.trailingTriviaWidth();
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.text = function () {
+                return this.fullText().substr(this.leadingTriviaWidth(), this.width());
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.fullText = function () {
+                return this._fullText;
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.value = function () {
+                if (this._value === undefined) {
+                    this._value = Syntax.value(this);
+                }
+
+                return this._value;
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.valueText = function () {
+                if (this._valueText === undefined) {
+                    this._valueText = Syntax.valueText(this);
+                }
+
+                return this._valueText;
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingTrivia = function () {
+                return true;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingComment = function () {
+                return hasTriviaComment(this._leadingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingNewLine = function () {
+                return hasTriviaNewLine(this._leadingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTriviaWidth = function () {
+                return getTriviaWidth(this._leadingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), 0, getTriviaWidth(this._leadingTriviaInfo), false);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingTrivia = function () {
+                return true;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingComment = function () {
+                return hasTriviaComment(this._trailingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingNewLine = function () {
+                return hasTriviaNewLine(this._trailingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTriviaWidth = function () {
+                return getTriviaWidth(this._trailingTriviaInfo);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), this.leadingTriviaWidth() + this.width(), getTriviaWidth(this._trailingTriviaInfo), true);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return VariableWidthTokenWithLeadingAndTrailingTrivia;
+        })();
+        Syntax.VariableWidthTokenWithLeadingAndTrailingTrivia = VariableWidthTokenWithLeadingAndTrailingTrivia;
+
+        var FixedWidthTokenWithNoTrivia = (function () {
+            function FixedWidthTokenWithNoTrivia(kind) {
+                this.tokenKind = kind;
+            }
+            FixedWidthTokenWithNoTrivia.prototype.clone = function () {
+                return new FixedWidthTokenWithNoTrivia(this.tokenKind);
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.isNode = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.isToken = function () {
+                return true;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.isList = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.width = function () {
+                return this.text().length;
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.text = function () {
+                return TypeScript.SyntaxFacts.getText(this.tokenKind);
+            };
+            FixedWidthTokenWithNoTrivia.prototype.fullText = function () {
+                return this.text();
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.value = function () {
+                return Syntax.value(this);
+            };
+            FixedWidthTokenWithNoTrivia.prototype.valueText = function () {
+                return Syntax.valueText(this);
+            };
+            FixedWidthTokenWithNoTrivia.prototype.hasLeadingTrivia = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.hasLeadingComment = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.hasLeadingNewLine = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.leadingTriviaWidth = function () {
+                return 0;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.leadingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.hasTrailingTrivia = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.hasTrailingComment = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.hasTrailingNewLine = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.trailingTriviaWidth = function () {
+                return 0;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.trailingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            FixedWidthTokenWithNoTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            FixedWidthTokenWithNoTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            FixedWidthTokenWithNoTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            FixedWidthTokenWithNoTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            FixedWidthTokenWithNoTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithNoTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return FixedWidthTokenWithNoTrivia;
+        })();
+        Syntax.FixedWidthTokenWithNoTrivia = FixedWidthTokenWithNoTrivia;
+
+        var FixedWidthTokenWithLeadingTrivia = (function () {
+            function FixedWidthTokenWithLeadingTrivia(fullText, kind, leadingTriviaInfo) {
+                this._fullText = fullText;
+                this.tokenKind = kind;
+                this._leadingTriviaInfo = leadingTriviaInfo;
+            }
+            FixedWidthTokenWithLeadingTrivia.prototype.clone = function () {
+                return new FixedWidthTokenWithLeadingTrivia(this._fullText, this.tokenKind, this._leadingTriviaInfo);
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.isNode = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.isToken = function () {
+                return true;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.isList = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.width = function () {
+                return this.text().length;
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.text = function () {
+                return TypeScript.SyntaxFacts.getText(this.tokenKind);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.fullText = function () {
+                return this._fullText;
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.value = function () {
+                return Syntax.value(this);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.valueText = function () {
+                return Syntax.valueText(this);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingTrivia = function () {
+                return true;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingComment = function () {
+                return hasTriviaComment(this._leadingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingNewLine = function () {
+                return hasTriviaNewLine(this._leadingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.leadingTriviaWidth = function () {
+                return getTriviaWidth(this._leadingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.leadingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), 0, getTriviaWidth(this._leadingTriviaInfo), false);
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingTrivia = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingComment = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingNewLine = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.trailingTriviaWidth = function () {
+                return 0;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.trailingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            FixedWidthTokenWithLeadingTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithLeadingTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return FixedWidthTokenWithLeadingTrivia;
+        })();
+        Syntax.FixedWidthTokenWithLeadingTrivia = FixedWidthTokenWithLeadingTrivia;
+
+        var FixedWidthTokenWithTrailingTrivia = (function () {
+            function FixedWidthTokenWithTrailingTrivia(fullText, kind, trailingTriviaInfo) {
+                this._fullText = fullText;
+                this.tokenKind = kind;
+                this._trailingTriviaInfo = trailingTriviaInfo;
+            }
+            FixedWidthTokenWithTrailingTrivia.prototype.clone = function () {
+                return new FixedWidthTokenWithTrailingTrivia(this._fullText, this.tokenKind, this._trailingTriviaInfo);
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.isNode = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.isToken = function () {
+                return true;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.isList = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.width = function () {
+                return this.text().length;
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.text = function () {
+                return TypeScript.SyntaxFacts.getText(this.tokenKind);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.fullText = function () {
+                return this._fullText;
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.value = function () {
+                return Syntax.value(this);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.valueText = function () {
+                return Syntax.valueText(this);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingTrivia = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingComment = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingNewLine = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.leadingTriviaWidth = function () {
+                return 0;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.leadingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingTrivia = function () {
+                return true;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingComment = function () {
+                return hasTriviaComment(this._trailingTriviaInfo);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingNewLine = function () {
+                return hasTriviaNewLine(this._trailingTriviaInfo);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.trailingTriviaWidth = function () {
+                return getTriviaWidth(this._trailingTriviaInfo);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.trailingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), this.leadingTriviaWidth() + this.width(), getTriviaWidth(this._trailingTriviaInfo), true);
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            FixedWidthTokenWithTrailingTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithTrailingTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return FixedWidthTokenWithTrailingTrivia;
+        })();
+        Syntax.FixedWidthTokenWithTrailingTrivia = FixedWidthTokenWithTrailingTrivia;
+
+        var FixedWidthTokenWithLeadingAndTrailingTrivia = (function () {
+            function FixedWidthTokenWithLeadingAndTrailingTrivia(fullText, kind, leadingTriviaInfo, trailingTriviaInfo) {
+                this._fullText = fullText;
+                this.tokenKind = kind;
+                this._leadingTriviaInfo = leadingTriviaInfo;
+                this._trailingTriviaInfo = trailingTriviaInfo;
+            }
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.clone = function () {
+                return new FixedWidthTokenWithLeadingAndTrailingTrivia(this._fullText, this.tokenKind, this._leadingTriviaInfo, this._trailingTriviaInfo);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isNode = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isToken = function () {
+                return true;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isList = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.childCount = function () {
+                return 0;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange('index');
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.width = function () {
+                return this.text().length;
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.text = function () {
+                return TypeScript.SyntaxFacts.getText(this.tokenKind);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.fullText = function () {
+                return this._fullText;
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.value = function () {
+                return Syntax.value(this);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.valueText = function () {
+                return Syntax.valueText(this);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingTrivia = function () {
+                return true;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingComment = function () {
+                return hasTriviaComment(this._leadingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingNewLine = function () {
+                return hasTriviaNewLine(this._leadingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTriviaWidth = function () {
+                return getTriviaWidth(this._leadingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), 0, getTriviaWidth(this._leadingTriviaInfo), false);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingTrivia = function () {
+                return true;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingComment = function () {
+                return hasTriviaComment(this._trailingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingNewLine = function () {
+                return hasTriviaNewLine(this._trailingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTriviaWidth = function () {
+                return getTriviaWidth(this._trailingTriviaInfo);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTrivia = function () {
+                return TypeScript.Scanner.scanTrivia(TypeScript.SimpleText.fromString(this._fullText), this.leadingTriviaWidth() + this.width(), getTriviaWidth(this._trailingTriviaInfo), true);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasSkippedToken = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.toJSON = function (key) {
+                return Syntax.tokenToJSON(this);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.firstToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.lastToken = function () {
+                return this;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isIncrementallyUnusable = function () {
+                return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.realize = function () {
+                return Syntax.realizeToken(this);
+            };
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.collectTextElements = function (elements) {
+                collectTokenTextElements(this, elements);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isExpression = function () {
+                return Syntax.isExpression(this);
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return FixedWidthTokenWithLeadingAndTrailingTrivia;
+        })();
+        Syntax.FixedWidthTokenWithLeadingAndTrailingTrivia = FixedWidthTokenWithLeadingAndTrailingTrivia;
+
+        function collectTokenTextElements(token, elements) {
+            token.leadingTrivia().collectTextElements(elements);
+            elements.push(token.text());
+            token.trailingTrivia().collectTextElements(elements);
+        }
+
+        function getTriviaWidth(value) {
+            return value >>> 2 /* TriviaFullWidthShift */;
+        }
+
+        function hasTriviaComment(value) {
+            return (value & 2 /* TriviaCommentMask */) !== 0;
+        }
+
+        function hasTriviaNewLine(value) {
+            return (value & 1 /* TriviaNewLineMask */) !== 0;
+        }
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        function isExpression(token) {
+            switch (token.tokenKind) {
+                case 11 /* IdentifierName */:
+                case 12 /* RegularExpressionLiteral */:
+                case 13 /* NumericLiteral */:
+                case 14 /* StringLiteral */:
+                case 24 /* FalseKeyword */:
+                case 32 /* NullKeyword */:
+                case 35 /* ThisKeyword */:
+                case 37 /* TrueKeyword */:
+                case 50 /* SuperKeyword */:
+                    return true;
+            }
+
+            return false;
+        }
+        Syntax.isExpression = isExpression;
+
+        function realizeToken(token) {
+            return new RealizedToken(token.tokenKind, token.leadingTrivia(), token.text(), token.value(), token.valueText(), token.trailingTrivia());
+        }
+        Syntax.realizeToken = realizeToken;
+
+        function convertToIdentifierName(token) {
+            TypeScript.Debug.assert(TypeScript.SyntaxFacts.isAnyKeyword(token.tokenKind));
+            return new RealizedToken(11 /* IdentifierName */, token.leadingTrivia(), token.text(), token.text(), token.text(), token.trailingTrivia());
+        }
+        Syntax.convertToIdentifierName = convertToIdentifierName;
+
+        function tokenToJSON(token) {
+            var result = {};
+
+            for (var name in TypeScript.SyntaxKind) {
+                if (TypeScript.SyntaxKind[name] === token.kind()) {
+                    result.kind = name;
+                    break;
+                }
+            }
+
+            result.width = token.width();
+            if (token.fullWidth() !== token.width()) {
+                result.fullWidth = token.fullWidth();
+            }
+
+            result.text = token.text();
+
+            var value = token.value();
+            if (value !== null) {
+                result.value = value;
+                result.valueText = token.valueText();
+            }
+
+            if (token.hasLeadingTrivia()) {
+                result.hasLeadingTrivia = true;
+            }
+
+            if (token.hasLeadingComment()) {
+                result.hasLeadingComment = true;
+            }
+
+            if (token.hasLeadingNewLine()) {
+                result.hasLeadingNewLine = true;
+            }
+
+            if (token.hasLeadingSkippedText()) {
+                result.hasLeadingSkippedText = true;
+            }
+
+            if (token.hasTrailingTrivia()) {
+                result.hasTrailingTrivia = true;
+            }
+
+            if (token.hasTrailingComment()) {
+                result.hasTrailingComment = true;
+            }
+
+            if (token.hasTrailingNewLine()) {
+                result.hasTrailingNewLine = true;
+            }
+
+            if (token.hasTrailingSkippedText()) {
+                result.hasTrailingSkippedText = true;
+            }
+
+            var trivia = token.leadingTrivia();
+            if (trivia.count() > 0) {
+                result.leadingTrivia = trivia;
+            }
+
+            trivia = token.trailingTrivia();
+            if (trivia.count() > 0) {
+                result.trailingTrivia = trivia;
+            }
+
+            return result;
+        }
+        Syntax.tokenToJSON = tokenToJSON;
+
+        function value(token) {
+            return value1(token.tokenKind, token.text());
+        }
+        Syntax.value = value;
+
+        function hexValue(text, start, length) {
+            var intChar = 0;
+            for (var i = 0; i < length; i++) {
+                var ch2 = text.charCodeAt(start + i);
+                if (!TypeScript.CharacterInfo.isHexDigit(ch2)) {
+                    break;
+                }
+
+                intChar = (intChar << 4) + TypeScript.CharacterInfo.hexValue(ch2);
+            }
+
+            return intChar;
+        }
+
+        var characterArray = [];
+
+        function convertEscapes(text) {
+            characterArray.length = 0;
+            var result = "";
+
+            for (var i = 0, n = text.length; i < n; i++) {
+                var ch = text.charCodeAt(i);
+
+                if (ch === 92 /* backslash */) {
+                    i++;
+                    if (i < n) {
+                        ch = text.charCodeAt(i);
+                        switch (ch) {
+                            case 48 /* _0 */:
+                                characterArray.push(0 /* nullCharacter */);
+                                continue;
+
+                            case 98 /* b */:
+                                characterArray.push(8 /* backspace */);
+                                continue;
+
+                            case 102 /* f */:
+                                characterArray.push(12 /* formFeed */);
+                                continue;
+
+                            case 110 /* n */:
+                                characterArray.push(10 /* lineFeed */);
+                                continue;
+
+                            case 114 /* r */:
+                                characterArray.push(13 /* carriageReturn */);
+                                continue;
+
+                            case 116 /* t */:
+                                characterArray.push(9 /* tab */);
+                                continue;
+
+                            case 118 /* v */:
+                                characterArray.push(11 /* verticalTab */);
+                                continue;
+
+                            case 120 /* x */:
+                                characterArray.push(hexValue(text, i + 1, 2));
+                                i += 2;
+                                continue;
+
+                            case 117 /* u */:
+                                characterArray.push(hexValue(text, i + 1, 4));
+                                i += 4;
+                                continue;
+
+                            case 13 /* carriageReturn */:
+                                var nextIndex = i + 1;
+                                if (nextIndex < text.length && text.charCodeAt(nextIndex) === 10 /* lineFeed */) {
+                                    i++;
+                                }
+                                continue;
+
+                            case 10 /* lineFeed */:
+                            case 8233 /* paragraphSeparator */:
+                            case 8232 /* lineSeparator */:
+                                continue;
+
+                            default:
+                        }
+                    }
+                }
+
+                characterArray.push(ch);
+
+                if (i && !(i % 1024)) {
+                    result = result.concat(String.fromCharCode.apply(null, characterArray));
+                    characterArray.length = 0;
+                }
+            }
+
+            if (characterArray.length) {
+                result = result.concat(String.fromCharCode.apply(null, characterArray));
+            }
+
+            return result;
+        }
+
+        function massageEscapes(text) {
+            return text.indexOf("\\") >= 0 ? convertEscapes(text) : text;
+        }
+        Syntax.massageEscapes = massageEscapes;
+
+        function value1(kind, text) {
+            if (kind === 11 /* IdentifierName */) {
+                return massageEscapes(text);
+            }
+
+            switch (kind) {
+                case 37 /* TrueKeyword */:
+                    return true;
+                case 24 /* FalseKeyword */:
+                    return false;
+                case 32 /* NullKeyword */:
+                    return null;
+            }
+
+            if (TypeScript.SyntaxFacts.isAnyKeyword(kind) || TypeScript.SyntaxFacts.isAnyPunctuation(kind)) {
+                return TypeScript.SyntaxFacts.getText(kind);
+            }
+
+            if (kind === 13 /* NumericLiteral */) {
+                return TypeScript.IntegerUtilities.isHexInteger(text) ? parseInt(text, 16) : parseFloat(text);
+            } else if (kind === 14 /* StringLiteral */) {
+                if (text.length > 1 && text.charCodeAt(text.length - 1) === text.charCodeAt(0)) {
+                    return massageEscapes(text.substr(1, text.length - 2));
+                } else {
+                    return massageEscapes(text.substr(1));
+                }
+            } else if (kind === 12 /* RegularExpressionLiteral */) {
+                return regularExpressionValue(text);
+            } else if (kind === 10 /* EndOfFileToken */ || kind === 9 /* ErrorToken */) {
+                return null;
+            } else {
+                throw TypeScript.Errors.invalidOperation();
+            }
+        }
+
+        function regularExpressionValue(text) {
+            try  {
+                var lastSlash = text.lastIndexOf("/");
+                var body = text.substring(1, lastSlash);
+                var flags = text.substring(lastSlash + 1);
+                return new RegExp(body, flags);
+            } catch (e) {
+                return null;
+            }
+        }
+
+        function valueText1(kind, text) {
+            var value = value1(kind, text);
+            return value === null ? "" : value.toString();
+        }
+
+        function valueText(token) {
+            var value = token.value();
+            return value === null ? "" : value.toString();
+        }
+        Syntax.valueText = valueText;
+
+        var EmptyToken = (function () {
+            function EmptyToken(kind) {
+                this.tokenKind = kind;
+            }
+            EmptyToken.prototype.clone = function () {
+                return new EmptyToken(this.tokenKind);
+            };
+
+            EmptyToken.prototype.kind = function () {
+                return this.tokenKind;
+            };
+
+            EmptyToken.prototype.isToken = function () {
+                return true;
+            };
+            EmptyToken.prototype.isNode = function () {
+                return false;
+            };
+            EmptyToken.prototype.isList = function () {
+                return false;
+            };
+            EmptyToken.prototype.isSeparatedList = function () {
+                return false;
+            };
+
+            EmptyToken.prototype.childCount = function () {
+                return 0;
+            };
+
+            EmptyToken.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            };
+
+            EmptyToken.prototype.toJSON = function (key) {
+                return tokenToJSON(this);
+            };
+            EmptyToken.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+
+            EmptyToken.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            EmptyToken.prototype.firstToken = function () {
+                return this;
+            };
+            EmptyToken.prototype.lastToken = function () {
+                return this;
+            };
+            EmptyToken.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+
+            EmptyToken.prototype.isIncrementallyUnusable = function () {
+                return true;
+            };
+
+            EmptyToken.prototype.fullWidth = function () {
+                return 0;
+            };
+            EmptyToken.prototype.width = function () {
+                return 0;
+            };
+            EmptyToken.prototype.text = function () {
+                return "";
+            };
+            EmptyToken.prototype.fullText = function () {
+                return "";
+            };
+            EmptyToken.prototype.value = function () {
+                return null;
+            };
+            EmptyToken.prototype.valueText = function () {
+                return "";
+            };
+
+            EmptyToken.prototype.hasLeadingTrivia = function () {
+                return false;
+            };
+            EmptyToken.prototype.hasLeadingComment = function () {
+                return false;
+            };
+            EmptyToken.prototype.hasLeadingNewLine = function () {
+                return false;
+            };
+            EmptyToken.prototype.hasLeadingSkippedText = function () {
+                return false;
+            };
+            EmptyToken.prototype.leadingTriviaWidth = function () {
+                return 0;
+            };
+            EmptyToken.prototype.hasTrailingTrivia = function () {
+                return false;
+            };
+            EmptyToken.prototype.hasTrailingComment = function () {
+                return false;
+            };
+            EmptyToken.prototype.hasTrailingNewLine = function () {
+                return false;
+            };
+            EmptyToken.prototype.hasTrailingSkippedText = function () {
+                return false;
+            };
+            EmptyToken.prototype.hasSkippedToken = function () {
+                return false;
+            };
+
+            EmptyToken.prototype.trailingTriviaWidth = function () {
+                return 0;
+            };
+            EmptyToken.prototype.leadingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+            EmptyToken.prototype.trailingTrivia = function () {
+                return Syntax.emptyTriviaList;
+            };
+            EmptyToken.prototype.realize = function () {
+                return realizeToken(this);
+            };
+            EmptyToken.prototype.collectTextElements = function (elements) {
+            };
+
+            EmptyToken.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return this.realize().withLeadingTrivia(leadingTrivia);
+            };
+
+            EmptyToken.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return this.realize().withTrailingTrivia(trailingTrivia);
+            };
+
+            EmptyToken.prototype.isExpression = function () {
+                return isExpression(this);
+            };
+
+            EmptyToken.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            EmptyToken.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            EmptyToken.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            EmptyToken.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return EmptyToken;
+        })();
+
+        function emptyToken(kind) {
+            return new EmptyToken(kind);
+        }
+        Syntax.emptyToken = emptyToken;
+
+        var RealizedToken = (function () {
+            function RealizedToken(tokenKind, leadingTrivia, text, value, valueText, trailingTrivia) {
+                this.tokenKind = tokenKind;
+                this._leadingTrivia = leadingTrivia;
+                this._text = text;
+                this._value = value;
+                this._valueText = valueText;
+                this._trailingTrivia = trailingTrivia;
+            }
+            RealizedToken.prototype.clone = function () {
+                return new RealizedToken(this.tokenKind, this._leadingTrivia, this._text, this._value, this._valueText, this._trailingTrivia);
+            };
+
+            RealizedToken.prototype.kind = function () {
+                return this.tokenKind;
+            };
+            RealizedToken.prototype.toJSON = function (key) {
+                return tokenToJSON(this);
+            };
+            RealizedToken.prototype.firstToken = function () {
+                return this;
+            };
+            RealizedToken.prototype.lastToken = function () {
+                return this;
+            };
+            RealizedToken.prototype.isTypeScriptSpecific = function () {
+                return false;
+            };
+
+            RealizedToken.prototype.isIncrementallyUnusable = function () {
+                return true;
+            };
+
+            RealizedToken.prototype.accept = function (visitor) {
+                return visitor.visitToken(this);
+            };
+
+            RealizedToken.prototype.childCount = function () {
+                return 0;
+            };
+
+            RealizedToken.prototype.childAt = function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            };
+
+            RealizedToken.prototype.isToken = function () {
+                return true;
+            };
+            RealizedToken.prototype.isNode = function () {
+                return false;
+            };
+            RealizedToken.prototype.isList = function () {
+                return false;
+            };
+            RealizedToken.prototype.isSeparatedList = function () {
+                return false;
+            };
+            RealizedToken.prototype.isTrivia = function () {
+                return false;
+            };
+            RealizedToken.prototype.isTriviaList = function () {
+                return false;
+            };
+
+            RealizedToken.prototype.fullWidth = function () {
+                return this._leadingTrivia.fullWidth() + this.width() + this._trailingTrivia.fullWidth();
+            };
+            RealizedToken.prototype.width = function () {
+                return this.text().length;
+            };
+
+            RealizedToken.prototype.text = function () {
+                return this._text;
+            };
+            RealizedToken.prototype.fullText = function () {
+                return this._leadingTrivia.fullText() + this.text() + this._trailingTrivia.fullText();
+            };
+
+            RealizedToken.prototype.value = function () {
+                return this._value;
+            };
+            RealizedToken.prototype.valueText = function () {
+                return this._valueText;
+            };
+
+            RealizedToken.prototype.hasLeadingTrivia = function () {
+                return this._leadingTrivia.count() > 0;
+            };
+            RealizedToken.prototype.hasLeadingComment = function () {
+                return this._leadingTrivia.hasComment();
+            };
+            RealizedToken.prototype.hasLeadingNewLine = function () {
+                return this._leadingTrivia.hasNewLine();
+            };
+            RealizedToken.prototype.hasLeadingSkippedText = function () {
+                return this._leadingTrivia.hasSkippedToken();
+            };
+            RealizedToken.prototype.leadingTriviaWidth = function () {
+                return this._leadingTrivia.fullWidth();
+            };
+
+            RealizedToken.prototype.hasTrailingTrivia = function () {
+                return this._trailingTrivia.count() > 0;
+            };
+            RealizedToken.prototype.hasTrailingComment = function () {
+                return this._trailingTrivia.hasComment();
+            };
+            RealizedToken.prototype.hasTrailingNewLine = function () {
+                return this._trailingTrivia.hasNewLine();
+            };
+            RealizedToken.prototype.hasTrailingSkippedText = function () {
+                return this._trailingTrivia.hasSkippedToken();
+            };
+            RealizedToken.prototype.trailingTriviaWidth = function () {
+                return this._trailingTrivia.fullWidth();
+            };
+
+            RealizedToken.prototype.hasSkippedToken = function () {
+                return this.hasLeadingSkippedText() || this.hasTrailingSkippedText();
+            };
+
+            RealizedToken.prototype.leadingTrivia = function () {
+                return this._leadingTrivia;
+            };
+            RealizedToken.prototype.trailingTrivia = function () {
+                return this._trailingTrivia;
+            };
+
+            RealizedToken.prototype.findTokenInternal = function (parent, position, fullStart) {
+                return new TypeScript.PositionedToken(parent, this, fullStart);
+            };
+
+            RealizedToken.prototype.collectTextElements = function (elements) {
+                this.leadingTrivia().collectTextElements(elements);
+                elements.push(this.text());
+                this.trailingTrivia().collectTextElements(elements);
+            };
+
+            RealizedToken.prototype.withLeadingTrivia = function (leadingTrivia) {
+                return new RealizedToken(this.tokenKind, leadingTrivia, this._text, this._value, this._valueText, this._trailingTrivia);
+            };
+
+            RealizedToken.prototype.withTrailingTrivia = function (trailingTrivia) {
+                return new RealizedToken(this.tokenKind, this._leadingTrivia, this._text, this._value, this._valueText, trailingTrivia);
+            };
+
+            RealizedToken.prototype.isExpression = function () {
+                return isExpression(this);
+            };
+
+            RealizedToken.prototype.isPrimaryExpression = function () {
+                return this.isExpression();
+            };
+
+            RealizedToken.prototype.isMemberExpression = function () {
+                return this.isExpression();
+            };
+
+            RealizedToken.prototype.isPostfixExpression = function () {
+                return this.isExpression();
+            };
+
+            RealizedToken.prototype.isUnaryExpression = function () {
+                return this.isExpression();
+            };
+            return RealizedToken;
+        })();
+
+        function token(kind, info) {
+            if (typeof info === "undefined") { info = null; }
+            var text = (info !== null && info.text !== undefined) ? info.text : TypeScript.SyntaxFacts.getText(kind);
+
+            return new RealizedToken(kind, Syntax.triviaList(info === null ? null : info.leadingTrivia), text, value1(kind, text), valueText1(kind, text), Syntax.triviaList(info === null ? null : info.trailingTrivia));
+        }
+        Syntax.token = token;
+
+        function identifier(text, info) {
+            if (typeof info === "undefined") { info = null; }
+            info = info || {};
+            info.text = text;
+            return token(11 /* IdentifierName */, info);
+        }
+        Syntax.identifier = identifier;
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxTokenReplacer = (function (_super) {
+        __extends(SyntaxTokenReplacer, _super);
+        function SyntaxTokenReplacer(token1, token2) {
+            _super.call(this);
+            this.token1 = token1;
+            this.token2 = token2;
+        }
+        SyntaxTokenReplacer.prototype.visitToken = function (token) {
+            if (token === this.token1) {
+                var result = this.token2;
+                this.token1 = null;
+                this.token2 = null;
+
+                return result;
+            }
+
+            return token;
+        };
+
+        SyntaxTokenReplacer.prototype.visitNode = function (node) {
+            if (this.token1 === null) {
+                return node;
+            }
+
+            return _super.prototype.visitNode.call(this, node);
+        };
+
+        SyntaxTokenReplacer.prototype.visitList = function (list) {
+            if (this.token1 === null) {
+                return list;
+            }
+
+            return _super.prototype.visitList.call(this, list);
+        };
+
+        SyntaxTokenReplacer.prototype.visitSeparatedList = function (list) {
+            if (this.token1 === null) {
+                return list;
+            }
+
+            return _super.prototype.visitSeparatedList.call(this, list);
+        };
+        return SyntaxTokenReplacer;
+    })(TypeScript.SyntaxRewriter);
+    TypeScript.SyntaxTokenReplacer = SyntaxTokenReplacer;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        var AbstractTrivia = (function () {
+            function AbstractTrivia(_kind) {
+                this._kind = _kind;
+            }
+            AbstractTrivia.prototype.fullWidth = function () {
+                throw TypeScript.Errors.abstract();
+            };
+
+            AbstractTrivia.prototype.fullText = function () {
+                throw TypeScript.Errors.abstract();
+            };
+
+            AbstractTrivia.prototype.skippedToken = function () {
+                throw TypeScript.Errors.abstract();
+            };
+
+            AbstractTrivia.prototype.toJSON = function (key) {
+                var result = {};
+
+                for (var name in TypeScript.SyntaxKind) {
+                    if (TypeScript.SyntaxKind[name] === this._kind) {
+                        result.kind = name;
+                        break;
+                    }
+                }
+
+                if (this.isSkippedToken()) {
+                    result.skippedToken = this.skippedToken();
+                } else {
+                    result.text = this.fullText();
+                }
+                return result;
+            };
+
+            AbstractTrivia.prototype.kind = function () {
+                return this._kind;
+            };
+
+            AbstractTrivia.prototype.isWhitespace = function () {
+                return this.kind() === 4 /* WhitespaceTrivia */;
+            };
+
+            AbstractTrivia.prototype.isComment = function () {
+                return this.kind() === 7 /* SingleLineCommentTrivia */ || this.kind() === 6 /* MultiLineCommentTrivia */;
+            };
+
+            AbstractTrivia.prototype.isNewLine = function () {
+                return this.kind() === 5 /* NewLineTrivia */;
+            };
+
+            AbstractTrivia.prototype.isSkippedToken = function () {
+                return this.kind() === 8 /* SkippedTokenTrivia */;
+            };
+
+            AbstractTrivia.prototype.collectTextElements = function (elements) {
+                elements.push(this.fullText());
+            };
+            return AbstractTrivia;
+        })();
+
+        var NormalTrivia = (function (_super) {
+            __extends(NormalTrivia, _super);
+            function NormalTrivia(kind, _text) {
+                _super.call(this, kind);
+                this._text = _text;
+            }
+            NormalTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+
+            NormalTrivia.prototype.fullText = function () {
+                return this._text;
+            };
+
+            NormalTrivia.prototype.skippedToken = function () {
+                throw TypeScript.Errors.invalidOperation();
+            };
+            return NormalTrivia;
+        })(AbstractTrivia);
+
+        var SkippedTokenTrivia = (function (_super) {
+            __extends(SkippedTokenTrivia, _super);
+            function SkippedTokenTrivia(_skippedToken) {
+                _super.call(this, 8 /* SkippedTokenTrivia */);
+                this._skippedToken = _skippedToken;
+            }
+            SkippedTokenTrivia.prototype.fullWidth = function () {
+                return this.fullText().length;
+            };
+
+            SkippedTokenTrivia.prototype.fullText = function () {
+                return this.skippedToken().fullText();
+            };
+
+            SkippedTokenTrivia.prototype.skippedToken = function () {
+                return this._skippedToken;
+            };
+            return SkippedTokenTrivia;
+        })(AbstractTrivia);
+
+        var DeferredTrivia = (function (_super) {
+            __extends(DeferredTrivia, _super);
+            function DeferredTrivia(kind, _text, _fullStart, _fullWidth) {
+                _super.call(this, kind);
+                this._text = _text;
+                this._fullStart = _fullStart;
+                this._fullWidth = _fullWidth;
+                this._fullText = null;
+            }
+            DeferredTrivia.prototype.fullWidth = function () {
+                return this._fullWidth;
+            };
+
+            DeferredTrivia.prototype.fullText = function () {
+                if (!this._fullText) {
+                    this._fullText = this._text.substr(this._fullStart, this._fullWidth, false);
+                    this._text = null;
+                }
+
+                return this._fullText;
+            };
+
+            DeferredTrivia.prototype.skippedToken = function () {
+                throw TypeScript.Errors.invalidOperation();
+            };
+            return DeferredTrivia;
+        })(AbstractTrivia);
+
+        function deferredTrivia(kind, text, fullStart, fullWidth) {
+            return new DeferredTrivia(kind, text, fullStart, fullWidth);
+        }
+        Syntax.deferredTrivia = deferredTrivia;
+
+        function trivia(kind, text) {
+            return new NormalTrivia(kind, text);
+        }
+        Syntax.trivia = trivia;
+
+        function skippedTokenTrivia(token) {
+            TypeScript.Debug.assert(!token.hasLeadingTrivia());
+            TypeScript.Debug.assert(!token.hasTrailingTrivia());
+            TypeScript.Debug.assert(token.fullWidth() > 0);
+            return new SkippedTokenTrivia(token);
+        }
+        Syntax.skippedTokenTrivia = skippedTokenTrivia;
+
+        function spaces(count) {
+            return trivia(4 /* WhitespaceTrivia */, TypeScript.StringUtilities.repeat(" ", count));
+        }
+        Syntax.spaces = spaces;
+
+        function whitespace(text) {
+            return trivia(4 /* WhitespaceTrivia */, text);
+        }
+        Syntax.whitespace = whitespace;
+
+        function multiLineComment(text) {
+            return trivia(6 /* MultiLineCommentTrivia */, text);
+        }
+        Syntax.multiLineComment = multiLineComment;
+
+        function singleLineComment(text) {
+            return trivia(7 /* SingleLineCommentTrivia */, text);
+        }
+        Syntax.singleLineComment = singleLineComment;
+
+        Syntax.spaceTrivia = spaces(1);
+        Syntax.lineFeedTrivia = trivia(5 /* NewLineTrivia */, "\n");
+        Syntax.carriageReturnTrivia = trivia(5 /* NewLineTrivia */, "\r");
+        Syntax.carriageReturnLineFeedTrivia = trivia(5 /* NewLineTrivia */, "\r\n");
+
+        function splitMultiLineCommentTriviaIntoMultipleLines(trivia) {
+            var result = [];
+
+            var triviaText = trivia.fullText();
+            var currentIndex = 0;
+
+            for (var i = 0; i < triviaText.length; i++) {
+                var ch = triviaText.charCodeAt(i);
+
+                var isCarriageReturnLineFeed = false;
+                switch (ch) {
+                    case 13 /* carriageReturn */:
+                        if (i < triviaText.length - 1 && triviaText.charCodeAt(i + 1) === 10 /* lineFeed */) {
+                            i++;
+                        }
+
+                    case 10 /* lineFeed */:
+                    case 8233 /* paragraphSeparator */:
+                    case 8232 /* lineSeparator */:
+                        result.push(triviaText.substring(currentIndex, i + 1));
+
+                        currentIndex = i + 1;
+                        continue;
+                }
+            }
+
+            result.push(triviaText.substring(currentIndex));
+            return result;
+        }
+        Syntax.splitMultiLineCommentTriviaIntoMultipleLines = splitMultiLineCommentTriviaIntoMultipleLines;
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    (function (Syntax) {
+        Syntax.emptyTriviaList = {
+            kind: function () {
+                return 3 /* TriviaList */;
+            },
+            count: function () {
+                return 0;
+            },
+            syntaxTriviaAt: function (index) {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            },
+            last: function () {
+                throw TypeScript.Errors.argumentOutOfRange("index");
+            },
+            fullWidth: function () {
+                return 0;
+            },
+            fullText: function () {
+                return "";
+            },
+            hasComment: function () {
+                return false;
+            },
+            hasNewLine: function () {
+                return false;
+            },
+            hasSkippedToken: function () {
+                return false;
+            },
+            toJSON: function (key) {
+                return [];
+            },
+            collectTextElements: function (elements) {
+            },
+            toArray: function () {
+                return [];
+            },
+            concat: function (trivia) {
+                return trivia;
+            }
+        };
+
+        function concatTrivia(list1, list2) {
+            if (list1.count() === 0) {
+                return list2;
+            }
+
+            if (list2.count() === 0) {
+                return list1;
+            }
+
+            var trivia = list1.toArray();
+            trivia.push.apply(trivia, list2.toArray());
+
+            return triviaList(trivia);
+        }
+
+        function isComment(trivia) {
+            return trivia.kind() === 6 /* MultiLineCommentTrivia */ || trivia.kind() === 7 /* SingleLineCommentTrivia */;
+        }
+
+        var SingletonSyntaxTriviaList = (function () {
+            function SingletonSyntaxTriviaList(item) {
+                this.item = item;
+            }
+            SingletonSyntaxTriviaList.prototype.kind = function () {
+                return 3 /* TriviaList */;
+            };
+
+            SingletonSyntaxTriviaList.prototype.count = function () {
+                return 1;
+            };
+
+            SingletonSyntaxTriviaList.prototype.syntaxTriviaAt = function (index) {
+                if (index !== 0) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.item;
+            };
+
+            SingletonSyntaxTriviaList.prototype.last = function () {
+                return this.item;
+            };
+
+            SingletonSyntaxTriviaList.prototype.fullWidth = function () {
+                return this.item.fullWidth();
+            };
+
+            SingletonSyntaxTriviaList.prototype.fullText = function () {
+                return this.item.fullText();
+            };
+
+            SingletonSyntaxTriviaList.prototype.hasComment = function () {
+                return isComment(this.item);
+            };
+
+            SingletonSyntaxTriviaList.prototype.hasNewLine = function () {
+                return this.item.kind() === 5 /* NewLineTrivia */;
+            };
+
+            SingletonSyntaxTriviaList.prototype.hasSkippedToken = function () {
+                return this.item.kind() === 8 /* SkippedTokenTrivia */;
+            };
+
+            SingletonSyntaxTriviaList.prototype.toJSON = function (key) {
+                return [this.item];
+            };
+
+            SingletonSyntaxTriviaList.prototype.collectTextElements = function (elements) {
+                this.item.collectTextElements(elements);
+            };
+
+            SingletonSyntaxTriviaList.prototype.toArray = function () {
+                return [this.item];
+            };
+
+            SingletonSyntaxTriviaList.prototype.concat = function (trivia) {
+                return concatTrivia(this, trivia);
+            };
+            return SingletonSyntaxTriviaList;
+        })();
+
+        var NormalSyntaxTriviaList = (function () {
+            function NormalSyntaxTriviaList(trivia) {
+                this.trivia = trivia;
+            }
+            NormalSyntaxTriviaList.prototype.kind = function () {
+                return 3 /* TriviaList */;
+            };
+
+            NormalSyntaxTriviaList.prototype.count = function () {
+                return this.trivia.length;
+            };
+
+            NormalSyntaxTriviaList.prototype.syntaxTriviaAt = function (index) {
+                if (index < 0 || index >= this.trivia.length) {
+                    throw TypeScript.Errors.argumentOutOfRange("index");
+                }
+
+                return this.trivia[index];
+            };
+
+            NormalSyntaxTriviaList.prototype.last = function () {
+                return this.trivia[this.trivia.length - 1];
+            };
+
+            NormalSyntaxTriviaList.prototype.fullWidth = function () {
+                return TypeScript.ArrayUtilities.sum(this.trivia, function (t) {
+                    return t.fullWidth();
+                });
+            };
+
+            NormalSyntaxTriviaList.prototype.fullText = function () {
+                var result = "";
+
+                for (var i = 0, n = this.trivia.length; i < n; i++) {
+                    result += this.trivia[i].fullText();
+                }
+
+                return result;
+            };
+
+            NormalSyntaxTriviaList.prototype.hasComment = function () {
+                for (var i = 0; i < this.trivia.length; i++) {
+                    if (isComment(this.trivia[i])) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            NormalSyntaxTriviaList.prototype.hasNewLine = function () {
+                for (var i = 0; i < this.trivia.length; i++) {
+                    if (this.trivia[i].kind() === 5 /* NewLineTrivia */) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            NormalSyntaxTriviaList.prototype.hasSkippedToken = function () {
+                for (var i = 0; i < this.trivia.length; i++) {
+                    if (this.trivia[i].kind() === 8 /* SkippedTokenTrivia */) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            NormalSyntaxTriviaList.prototype.toJSON = function (key) {
+                return this.trivia;
+            };
+
+            NormalSyntaxTriviaList.prototype.collectTextElements = function (elements) {
+                for (var i = 0; i < this.trivia.length; i++) {
+                    this.trivia[i].collectTextElements(elements);
+                }
+            };
+
+            NormalSyntaxTriviaList.prototype.toArray = function () {
+                return this.trivia.slice(0);
+            };
+
+            NormalSyntaxTriviaList.prototype.concat = function (trivia) {
+                return concatTrivia(this, trivia);
+            };
+            return NormalSyntaxTriviaList;
+        })();
+
+        function triviaList(trivia) {
+            if (trivia === undefined || trivia === null || trivia.length === 0) {
+                return Syntax.emptyTriviaList;
+            }
+
+            if (trivia.length === 1) {
+                return new SingletonSyntaxTriviaList(trivia[0]);
+            }
+
+            return new NormalSyntaxTriviaList(trivia);
+        }
+        Syntax.triviaList = triviaList;
+
+        Syntax.spaceTriviaList = triviaList([Syntax.spaceTrivia]);
+    })(TypeScript.Syntax || (TypeScript.Syntax = {}));
+    var Syntax = TypeScript.Syntax;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxUtilities = (function () {
+        function SyntaxUtilities() {
+        }
+        SyntaxUtilities.isAngleBracket = function (positionedElement) {
+            var element = positionedElement.element();
+            var parent = positionedElement.parentElement();
+            if (parent !== null && (element.kind() === 80 /* LessThanToken */ || element.kind() === 81 /* GreaterThanToken */)) {
+                switch (parent.kind()) {
+                    case 228 /* TypeArgumentList */:
+                    case 229 /* TypeParameterList */:
+                    case 220 /* CastExpression */:
+                        return true;
+                }
+            }
+
+            return false;
+        };
+
+        SyntaxUtilities.getToken = function (list, kind) {
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var token = list.childAt(i);
+                if (token.tokenKind === kind) {
+                    return token;
+                }
+            }
+
+            return null;
+        };
+
+        SyntaxUtilities.containsToken = function (list, kind) {
+            return SyntaxUtilities.getToken(list, kind) !== null;
+        };
+
+        SyntaxUtilities.hasExportKeyword = function (moduleElement) {
+            return SyntaxUtilities.getExportKeyword(moduleElement) !== null;
+        };
+
+        SyntaxUtilities.getExportKeyword = function (moduleElement) {
+            switch (moduleElement.kind()) {
+                case 130 /* ModuleDeclaration */:
+                case 131 /* ClassDeclaration */:
+                case 129 /* FunctionDeclaration */:
+                case 148 /* VariableStatement */:
+                case 132 /* EnumDeclaration */:
+                case 128 /* InterfaceDeclaration */:
+                case 133 /* ImportDeclaration */:
+                    return SyntaxUtilities.getToken(moduleElement.modifiers, 47 /* ExportKeyword */);
+                default:
+                    return null;
+            }
+        };
+
+        SyntaxUtilities.isAmbientDeclarationSyntax = function (positionNode) {
+            if (!positionNode) {
+                return false;
+            }
+
+            var node = positionNode.node();
+            switch (node.kind()) {
+                case 130 /* ModuleDeclaration */:
+                case 131 /* ClassDeclaration */:
+                case 129 /* FunctionDeclaration */:
+                case 148 /* VariableStatement */:
+                case 132 /* EnumDeclaration */:
+                    if (SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */)) {
+                        return true;
+                    }
+
+                case 133 /* ImportDeclaration */:
+                case 137 /* ConstructorDeclaration */:
+                case 135 /* MemberFunctionDeclaration */:
+                case 139 /* GetAccessor */:
+                case 140 /* SetAccessor */:
+                case 136 /* MemberVariableDeclaration */:
+                    if (node.isClassElement() || node.isModuleElement()) {
+                        return SyntaxUtilities.isAmbientDeclarationSyntax(positionNode.containingNode());
+                    }
+
+                case 243 /* EnumElement */:
+                    return SyntaxUtilities.isAmbientDeclarationSyntax(positionNode.containingNode().containingNode());
+
+                default:
+                    return SyntaxUtilities.isAmbientDeclarationSyntax(positionNode.containingNode());
+            }
+        };
+        return SyntaxUtilities;
+    })();
+    TypeScript.SyntaxUtilities = SyntaxUtilities;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxVisitor = (function () {
+        function SyntaxVisitor() {
+        }
+        SyntaxVisitor.prototype.defaultVisit = function (node) {
+            return null;
+        };
+
+        SyntaxVisitor.prototype.visitToken = function (token) {
+            return this.defaultVisit(token);
+        };
+
+        SyntaxVisitor.prototype.visitSourceUnit = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitExternalModuleReference = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitModuleNameModuleReference = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitImportDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitExportAssignment = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitClassDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitInterfaceDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitHeritageClause = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitModuleDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitFunctionDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitVariableStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitVariableDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitVariableDeclarator = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitEqualsValueClause = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitPrefixUnaryExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitArrayLiteralExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitOmittedExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitParenthesizedExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitSimpleArrowFunctionExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitParenthesizedArrowFunctionExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitQualifiedName = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitTypeArgumentList = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitConstructorType = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitFunctionType = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitObjectType = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitArrayType = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitGenericType = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitTypeQuery = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitTypeAnnotation = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitBlock = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitParameter = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitMemberAccessExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitPostfixUnaryExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitElementAccessExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitInvocationExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitArgumentList = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitBinaryExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitConditionalExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitConstructSignature = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitMethodSignature = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitIndexSignature = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitPropertySignature = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitCallSignature = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitParameterList = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitTypeParameterList = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitTypeParameter = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitConstraint = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitElseClause = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitIfStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitExpressionStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitConstructorDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitMemberFunctionDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitGetAccessor = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitSetAccessor = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitMemberVariableDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitIndexMemberDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitThrowStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitReturnStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitObjectCreationExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitSwitchStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitCaseSwitchClause = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitDefaultSwitchClause = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitBreakStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitContinueStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitForStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitForInStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitWhileStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitWithStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitEnumDeclaration = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitEnumElement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitCastExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitObjectLiteralExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitSimplePropertyAssignment = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitFunctionPropertyAssignment = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitFunctionExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitEmptyStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitTryStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitCatchClause = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitFinallyClause = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitLabeledStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitDoStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitTypeOfExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitDeleteExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitVoidExpression = function (node) {
+            return this.defaultVisit(node);
+        };
+
+        SyntaxVisitor.prototype.visitDebuggerStatement = function (node) {
+            return this.defaultVisit(node);
+        };
+        return SyntaxVisitor;
+    })();
+    TypeScript.SyntaxVisitor = SyntaxVisitor;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxWalker = (function () {
+        function SyntaxWalker() {
+        }
+        SyntaxWalker.prototype.visitToken = function (token) {
+        };
+
+        SyntaxWalker.prototype.visitNode = function (node) {
+            node.accept(this);
+        };
+
+        SyntaxWalker.prototype.visitNodeOrToken = function (nodeOrToken) {
+            if (nodeOrToken.isToken()) {
+                this.visitToken(nodeOrToken);
+            } else {
+                this.visitNode(nodeOrToken);
+            }
+        };
+
+        SyntaxWalker.prototype.visitOptionalToken = function (token) {
+            if (token === null) {
+                return;
+            }
+
+            this.visitToken(token);
+        };
+
+        SyntaxWalker.prototype.visitOptionalNode = function (node) {
+            if (node === null) {
+                return;
+            }
+
+            this.visitNode(node);
+        };
+
+        SyntaxWalker.prototype.visitOptionalNodeOrToken = function (nodeOrToken) {
+            if (nodeOrToken === null) {
+                return;
+            }
+
+            this.visitNodeOrToken(nodeOrToken);
+        };
+
+        SyntaxWalker.prototype.visitList = function (list) {
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                this.visitNodeOrToken(list.childAt(i));
+            }
+        };
+
+        SyntaxWalker.prototype.visitSeparatedList = function (list) {
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var item = list.childAt(i);
+                this.visitNodeOrToken(item);
+            }
+        };
+
+        SyntaxWalker.prototype.visitSourceUnit = function (node) {
+            this.visitList(node.moduleElements);
+            this.visitToken(node.endOfFileToken);
+        };
+
+        SyntaxWalker.prototype.visitExternalModuleReference = function (node) {
+            this.visitToken(node.requireKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitToken(node.stringLiteral);
+            this.visitToken(node.closeParenToken);
+        };
+
+        SyntaxWalker.prototype.visitModuleNameModuleReference = function (node) {
+            this.visitNodeOrToken(node.moduleName);
+        };
+
+        SyntaxWalker.prototype.visitImportDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.importKeyword);
+            this.visitToken(node.identifier);
+            this.visitToken(node.equalsToken);
+            this.visitNodeOrToken(node.moduleReference);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitExportAssignment = function (node) {
+            this.visitToken(node.exportKeyword);
+            this.visitToken(node.equalsToken);
+            this.visitToken(node.identifier);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitClassDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.classKeyword);
+            this.visitToken(node.identifier);
+            this.visitOptionalNode(node.typeParameterList);
+            this.visitList(node.heritageClauses);
+            this.visitToken(node.openBraceToken);
+            this.visitList(node.classElements);
+            this.visitToken(node.closeBraceToken);
+        };
+
+        SyntaxWalker.prototype.visitInterfaceDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.interfaceKeyword);
+            this.visitToken(node.identifier);
+            this.visitOptionalNode(node.typeParameterList);
+            this.visitList(node.heritageClauses);
+            this.visitNode(node.body);
+        };
+
+        SyntaxWalker.prototype.visitHeritageClause = function (node) {
+            this.visitToken(node.extendsOrImplementsKeyword);
+            this.visitSeparatedList(node.typeNames);
+        };
+
+        SyntaxWalker.prototype.visitModuleDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.moduleKeyword);
+            this.visitOptionalNodeOrToken(node.name);
+            this.visitOptionalToken(node.stringLiteral);
+            this.visitToken(node.openBraceToken);
+            this.visitList(node.moduleElements);
+            this.visitToken(node.closeBraceToken);
+        };
+
+        SyntaxWalker.prototype.visitFunctionDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.functionKeyword);
+            this.visitToken(node.identifier);
+            this.visitNode(node.callSignature);
+            this.visitOptionalNode(node.block);
+            this.visitOptionalToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitVariableStatement = function (node) {
+            this.visitList(node.modifiers);
+            this.visitNode(node.variableDeclaration);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitVariableDeclaration = function (node) {
+            this.visitToken(node.varKeyword);
+            this.visitSeparatedList(node.variableDeclarators);
+        };
+
+        SyntaxWalker.prototype.visitVariableDeclarator = function (node) {
+            this.visitToken(node.propertyName);
+            this.visitOptionalNode(node.typeAnnotation);
+            this.visitOptionalNode(node.equalsValueClause);
+        };
+
+        SyntaxWalker.prototype.visitEqualsValueClause = function (node) {
+            this.visitToken(node.equalsToken);
+            this.visitNodeOrToken(node.value);
+        };
+
+        SyntaxWalker.prototype.visitPrefixUnaryExpression = function (node) {
+            this.visitToken(node.operatorToken);
+            this.visitNodeOrToken(node.operand);
+        };
+
+        SyntaxWalker.prototype.visitArrayLiteralExpression = function (node) {
+            this.visitToken(node.openBracketToken);
+            this.visitSeparatedList(node.expressions);
+            this.visitToken(node.closeBracketToken);
+        };
+
+        SyntaxWalker.prototype.visitOmittedExpression = function (node) {
+        };
+
+        SyntaxWalker.prototype.visitParenthesizedExpression = function (node) {
+            this.visitToken(node.openParenToken);
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.closeParenToken);
+        };
+
+        SyntaxWalker.prototype.visitSimpleArrowFunctionExpression = function (node) {
+            this.visitToken(node.identifier);
+            this.visitToken(node.equalsGreaterThanToken);
+            this.visitOptionalNode(node.block);
+            this.visitOptionalNodeOrToken(node.expression);
+        };
+
+        SyntaxWalker.prototype.visitParenthesizedArrowFunctionExpression = function (node) {
+            this.visitNode(node.callSignature);
+            this.visitToken(node.equalsGreaterThanToken);
+            this.visitOptionalNode(node.block);
+            this.visitOptionalNodeOrToken(node.expression);
+        };
+
+        SyntaxWalker.prototype.visitQualifiedName = function (node) {
+            this.visitNodeOrToken(node.left);
+            this.visitToken(node.dotToken);
+            this.visitToken(node.right);
+        };
+
+        SyntaxWalker.prototype.visitTypeArgumentList = function (node) {
+            this.visitToken(node.lessThanToken);
+            this.visitSeparatedList(node.typeArguments);
+            this.visitToken(node.greaterThanToken);
+        };
+
+        SyntaxWalker.prototype.visitConstructorType = function (node) {
+            this.visitToken(node.newKeyword);
+            this.visitOptionalNode(node.typeParameterList);
+            this.visitNode(node.parameterList);
+            this.visitToken(node.equalsGreaterThanToken);
+            this.visitNodeOrToken(node.type);
+        };
+
+        SyntaxWalker.prototype.visitFunctionType = function (node) {
+            this.visitOptionalNode(node.typeParameterList);
+            this.visitNode(node.parameterList);
+            this.visitToken(node.equalsGreaterThanToken);
+            this.visitNodeOrToken(node.type);
+        };
+
+        SyntaxWalker.prototype.visitObjectType = function (node) {
+            this.visitToken(node.openBraceToken);
+            this.visitSeparatedList(node.typeMembers);
+            this.visitToken(node.closeBraceToken);
+        };
+
+        SyntaxWalker.prototype.visitArrayType = function (node) {
+            this.visitNodeOrToken(node.type);
+            this.visitToken(node.openBracketToken);
+            this.visitToken(node.closeBracketToken);
+        };
+
+        SyntaxWalker.prototype.visitGenericType = function (node) {
+            this.visitNodeOrToken(node.name);
+            this.visitNode(node.typeArgumentList);
+        };
+
+        SyntaxWalker.prototype.visitTypeQuery = function (node) {
+            this.visitToken(node.typeOfKeyword);
+            this.visitNodeOrToken(node.name);
+        };
+
+        SyntaxWalker.prototype.visitTypeAnnotation = function (node) {
+            this.visitToken(node.colonToken);
+            this.visitNodeOrToken(node.type);
+        };
+
+        SyntaxWalker.prototype.visitBlock = function (node) {
+            this.visitToken(node.openBraceToken);
+            this.visitList(node.statements);
+            this.visitToken(node.closeBraceToken);
+        };
+
+        SyntaxWalker.prototype.visitParameter = function (node) {
+            this.visitOptionalToken(node.dotDotDotToken);
+            this.visitList(node.modifiers);
+            this.visitToken(node.identifier);
+            this.visitOptionalToken(node.questionToken);
+            this.visitOptionalNode(node.typeAnnotation);
+            this.visitOptionalNode(node.equalsValueClause);
+        };
+
+        SyntaxWalker.prototype.visitMemberAccessExpression = function (node) {
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.dotToken);
+            this.visitToken(node.name);
+        };
+
+        SyntaxWalker.prototype.visitPostfixUnaryExpression = function (node) {
+            this.visitNodeOrToken(node.operand);
+            this.visitToken(node.operatorToken);
+        };
+
+        SyntaxWalker.prototype.visitElementAccessExpression = function (node) {
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.openBracketToken);
+            this.visitNodeOrToken(node.argumentExpression);
+            this.visitToken(node.closeBracketToken);
+        };
+
+        SyntaxWalker.prototype.visitInvocationExpression = function (node) {
+            this.visitNodeOrToken(node.expression);
+            this.visitNode(node.argumentList);
+        };
+
+        SyntaxWalker.prototype.visitArgumentList = function (node) {
+            this.visitOptionalNode(node.typeArgumentList);
+            this.visitToken(node.openParenToken);
+            this.visitSeparatedList(node.arguments);
+            this.visitToken(node.closeParenToken);
+        };
+
+        SyntaxWalker.prototype.visitBinaryExpression = function (node) {
+            this.visitNodeOrToken(node.left);
+            this.visitToken(node.operatorToken);
+            this.visitNodeOrToken(node.right);
+        };
+
+        SyntaxWalker.prototype.visitConditionalExpression = function (node) {
+            this.visitNodeOrToken(node.condition);
+            this.visitToken(node.questionToken);
+            this.visitNodeOrToken(node.whenTrue);
+            this.visitToken(node.colonToken);
+            this.visitNodeOrToken(node.whenFalse);
+        };
+
+        SyntaxWalker.prototype.visitConstructSignature = function (node) {
+            this.visitToken(node.newKeyword);
+            this.visitNode(node.callSignature);
+        };
+
+        SyntaxWalker.prototype.visitMethodSignature = function (node) {
+            this.visitToken(node.propertyName);
+            this.visitOptionalToken(node.questionToken);
+            this.visitNode(node.callSignature);
+        };
+
+        SyntaxWalker.prototype.visitIndexSignature = function (node) {
+            this.visitToken(node.openBracketToken);
+            this.visitNode(node.parameter);
+            this.visitToken(node.closeBracketToken);
+            this.visitOptionalNode(node.typeAnnotation);
+        };
+
+        SyntaxWalker.prototype.visitPropertySignature = function (node) {
+            this.visitToken(node.propertyName);
+            this.visitOptionalToken(node.questionToken);
+            this.visitOptionalNode(node.typeAnnotation);
+        };
+
+        SyntaxWalker.prototype.visitCallSignature = function (node) {
+            this.visitOptionalNode(node.typeParameterList);
+            this.visitNode(node.parameterList);
+            this.visitOptionalNode(node.typeAnnotation);
+        };
+
+        SyntaxWalker.prototype.visitParameterList = function (node) {
+            this.visitToken(node.openParenToken);
+            this.visitSeparatedList(node.parameters);
+            this.visitToken(node.closeParenToken);
+        };
+
+        SyntaxWalker.prototype.visitTypeParameterList = function (node) {
+            this.visitToken(node.lessThanToken);
+            this.visitSeparatedList(node.typeParameters);
+            this.visitToken(node.greaterThanToken);
+        };
+
+        SyntaxWalker.prototype.visitTypeParameter = function (node) {
+            this.visitToken(node.identifier);
+            this.visitOptionalNode(node.constraint);
+        };
+
+        SyntaxWalker.prototype.visitConstraint = function (node) {
+            this.visitToken(node.extendsKeyword);
+            this.visitNodeOrToken(node.type);
+        };
+
+        SyntaxWalker.prototype.visitElseClause = function (node) {
+            this.visitToken(node.elseKeyword);
+            this.visitNodeOrToken(node.statement);
+        };
+
+        SyntaxWalker.prototype.visitIfStatement = function (node) {
+            this.visitToken(node.ifKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitNodeOrToken(node.condition);
+            this.visitToken(node.closeParenToken);
+            this.visitNodeOrToken(node.statement);
+            this.visitOptionalNode(node.elseClause);
+        };
+
+        SyntaxWalker.prototype.visitExpressionStatement = function (node) {
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitConstructorDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.constructorKeyword);
+            this.visitNode(node.callSignature);
+            this.visitOptionalNode(node.block);
+            this.visitOptionalToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitMemberFunctionDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.propertyName);
+            this.visitNode(node.callSignature);
+            this.visitOptionalNode(node.block);
+            this.visitOptionalToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitGetAccessor = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.getKeyword);
+            this.visitToken(node.propertyName);
+            this.visitNode(node.parameterList);
+            this.visitOptionalNode(node.typeAnnotation);
+            this.visitNode(node.block);
+        };
+
+        SyntaxWalker.prototype.visitSetAccessor = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.setKeyword);
+            this.visitToken(node.propertyName);
+            this.visitNode(node.parameterList);
+            this.visitNode(node.block);
+        };
+
+        SyntaxWalker.prototype.visitMemberVariableDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitNode(node.variableDeclarator);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitIndexMemberDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitNode(node.indexSignature);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitThrowStatement = function (node) {
+            this.visitToken(node.throwKeyword);
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitReturnStatement = function (node) {
+            this.visitToken(node.returnKeyword);
+            this.visitOptionalNodeOrToken(node.expression);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitObjectCreationExpression = function (node) {
+            this.visitToken(node.newKeyword);
+            this.visitNodeOrToken(node.expression);
+            this.visitOptionalNode(node.argumentList);
+        };
+
+        SyntaxWalker.prototype.visitSwitchStatement = function (node) {
+            this.visitToken(node.switchKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.closeParenToken);
+            this.visitToken(node.openBraceToken);
+            this.visitList(node.switchClauses);
+            this.visitToken(node.closeBraceToken);
+        };
+
+        SyntaxWalker.prototype.visitCaseSwitchClause = function (node) {
+            this.visitToken(node.caseKeyword);
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.colonToken);
+            this.visitList(node.statements);
+        };
+
+        SyntaxWalker.prototype.visitDefaultSwitchClause = function (node) {
+            this.visitToken(node.defaultKeyword);
+            this.visitToken(node.colonToken);
+            this.visitList(node.statements);
+        };
+
+        SyntaxWalker.prototype.visitBreakStatement = function (node) {
+            this.visitToken(node.breakKeyword);
+            this.visitOptionalToken(node.identifier);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitContinueStatement = function (node) {
+            this.visitToken(node.continueKeyword);
+            this.visitOptionalToken(node.identifier);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitForStatement = function (node) {
+            this.visitToken(node.forKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitOptionalNode(node.variableDeclaration);
+            this.visitOptionalNodeOrToken(node.initializer);
+            this.visitToken(node.firstSemicolonToken);
+            this.visitOptionalNodeOrToken(node.condition);
+            this.visitToken(node.secondSemicolonToken);
+            this.visitOptionalNodeOrToken(node.incrementor);
+            this.visitToken(node.closeParenToken);
+            this.visitNodeOrToken(node.statement);
+        };
+
+        SyntaxWalker.prototype.visitForInStatement = function (node) {
+            this.visitToken(node.forKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitOptionalNode(node.variableDeclaration);
+            this.visitOptionalNodeOrToken(node.left);
+            this.visitToken(node.inKeyword);
+            this.visitNodeOrToken(node.expression);
+            this.visitToken(node.closeParenToken);
+            this.visitNodeOrToken(node.statement);
+        };
+
+        SyntaxWalker.prototype.visitWhileStatement = function (node) {
+            this.visitToken(node.whileKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitNodeOrToken(node.condition);
+            this.visitToken(node.closeParenToken);
+            this.visitNodeOrToken(node.statement);
+        };
+
+        SyntaxWalker.prototype.visitWithStatement = function (node) {
+            this.visitToken(node.withKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitNodeOrToken(node.condition);
+            this.visitToken(node.closeParenToken);
+            this.visitNodeOrToken(node.statement);
+        };
+
+        SyntaxWalker.prototype.visitEnumDeclaration = function (node) {
+            this.visitList(node.modifiers);
+            this.visitToken(node.enumKeyword);
+            this.visitToken(node.identifier);
+            this.visitToken(node.openBraceToken);
+            this.visitSeparatedList(node.enumElements);
+            this.visitToken(node.closeBraceToken);
+        };
+
+        SyntaxWalker.prototype.visitEnumElement = function (node) {
+            this.visitToken(node.propertyName);
+            this.visitOptionalNode(node.equalsValueClause);
+        };
+
+        SyntaxWalker.prototype.visitCastExpression = function (node) {
+            this.visitToken(node.lessThanToken);
+            this.visitNodeOrToken(node.type);
+            this.visitToken(node.greaterThanToken);
+            this.visitNodeOrToken(node.expression);
+        };
+
+        SyntaxWalker.prototype.visitObjectLiteralExpression = function (node) {
+            this.visitToken(node.openBraceToken);
+            this.visitSeparatedList(node.propertyAssignments);
+            this.visitToken(node.closeBraceToken);
+        };
+
+        SyntaxWalker.prototype.visitSimplePropertyAssignment = function (node) {
+            this.visitToken(node.propertyName);
+            this.visitToken(node.colonToken);
+            this.visitNodeOrToken(node.expression);
+        };
+
+        SyntaxWalker.prototype.visitFunctionPropertyAssignment = function (node) {
+            this.visitToken(node.propertyName);
+            this.visitNode(node.callSignature);
+            this.visitNode(node.block);
+        };
+
+        SyntaxWalker.prototype.visitFunctionExpression = function (node) {
+            this.visitToken(node.functionKeyword);
+            this.visitOptionalToken(node.identifier);
+            this.visitNode(node.callSignature);
+            this.visitNode(node.block);
+        };
+
+        SyntaxWalker.prototype.visitEmptyStatement = function (node) {
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitTryStatement = function (node) {
+            this.visitToken(node.tryKeyword);
+            this.visitNode(node.block);
+            this.visitOptionalNode(node.catchClause);
+            this.visitOptionalNode(node.finallyClause);
+        };
+
+        SyntaxWalker.prototype.visitCatchClause = function (node) {
+            this.visitToken(node.catchKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitToken(node.identifier);
+            this.visitOptionalNode(node.typeAnnotation);
+            this.visitToken(node.closeParenToken);
+            this.visitNode(node.block);
+        };
+
+        SyntaxWalker.prototype.visitFinallyClause = function (node) {
+            this.visitToken(node.finallyKeyword);
+            this.visitNode(node.block);
+        };
+
+        SyntaxWalker.prototype.visitLabeledStatement = function (node) {
+            this.visitToken(node.identifier);
+            this.visitToken(node.colonToken);
+            this.visitNodeOrToken(node.statement);
+        };
+
+        SyntaxWalker.prototype.visitDoStatement = function (node) {
+            this.visitToken(node.doKeyword);
+            this.visitNodeOrToken(node.statement);
+            this.visitToken(node.whileKeyword);
+            this.visitToken(node.openParenToken);
+            this.visitNodeOrToken(node.condition);
+            this.visitToken(node.closeParenToken);
+            this.visitToken(node.semicolonToken);
+        };
+
+        SyntaxWalker.prototype.visitTypeOfExpression = function (node) {
+            this.visitToken(node.typeOfKeyword);
+            this.visitNodeOrToken(node.expression);
+        };
+
+        SyntaxWalker.prototype.visitDeleteExpression = function (node) {
+            this.visitToken(node.deleteKeyword);
+            this.visitNodeOrToken(node.expression);
+        };
+
+        SyntaxWalker.prototype.visitVoidExpression = function (node) {
+            this.visitToken(node.voidKeyword);
+            this.visitNodeOrToken(node.expression);
+        };
+
+        SyntaxWalker.prototype.visitDebuggerStatement = function (node) {
+            this.visitToken(node.debuggerKeyword);
+            this.visitToken(node.semicolonToken);
+        };
+        return SyntaxWalker;
+    })();
+    TypeScript.SyntaxWalker = SyntaxWalker;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var PositionTrackingWalker = (function (_super) {
+        __extends(PositionTrackingWalker, _super);
+        function PositionTrackingWalker() {
+            _super.apply(this, arguments);
+            this._position = 0;
+        }
+        PositionTrackingWalker.prototype.visitToken = function (token) {
+            this._position += token.fullWidth();
+        };
+
+        PositionTrackingWalker.prototype.position = function () {
+            return this._position;
+        };
+
+        PositionTrackingWalker.prototype.skip = function (element) {
+            this._position += element.fullWidth();
+        };
+        return PositionTrackingWalker;
+    })(TypeScript.SyntaxWalker);
+    TypeScript.PositionTrackingWalker = PositionTrackingWalker;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxInformationMap = (function (_super) {
+        __extends(SyntaxInformationMap, _super);
+        function SyntaxInformationMap(trackParents, trackPreviousToken) {
+            _super.call(this);
+            this.trackParents = trackParents;
+            this.trackPreviousToken = trackPreviousToken;
+            this.tokenToInformation = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode);
+            this.elementToPosition = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode);
+            this._previousToken = null;
+            this._previousTokenInformation = null;
+            this._currentPosition = 0;
+            this._elementToParent = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode);
+            this._parentStack = [];
+            this._parentStack.push(null);
+        }
+        SyntaxInformationMap.create = function (node, trackParents, trackPreviousToken) {
+            var map = new SyntaxInformationMap(trackParents, trackPreviousToken);
+            map.visitNode(node);
+            return map;
+        };
+
+        SyntaxInformationMap.prototype.visitNode = function (node) {
+            this.trackParents && this._elementToParent.add(node, TypeScript.ArrayUtilities.last(this._parentStack));
+            this.elementToPosition.add(node, this._currentPosition);
+
+            this.trackParents && this._parentStack.push(node);
+            _super.prototype.visitNode.call(this, node);
+            this.trackParents && this._parentStack.pop();
+        };
+
+        SyntaxInformationMap.prototype.visitToken = function (token) {
+            this.trackParents && this._elementToParent.add(token, TypeScript.ArrayUtilities.last(this._parentStack));
+
+            if (this.trackPreviousToken) {
+                var tokenInformation = {
+                    previousToken: this._previousToken,
+                    nextToken: null
+                };
+
+                if (this._previousTokenInformation !== null) {
+                    this._previousTokenInformation.nextToken = token;
+                }
+
+                this._previousToken = token;
+                this._previousTokenInformation = tokenInformation;
+
+                this.tokenToInformation.add(token, tokenInformation);
+            }
+
+            this.elementToPosition.add(token, this._currentPosition);
+            this._currentPosition += token.fullWidth();
+        };
+
+        SyntaxInformationMap.prototype.parent = function (element) {
+            return this._elementToParent.get(element);
+        };
+
+        SyntaxInformationMap.prototype.fullStart = function (element) {
+            return this.elementToPosition.get(element);
+        };
+
+        SyntaxInformationMap.prototype.start = function (element) {
+            return this.fullStart(element) + element.leadingTriviaWidth();
+        };
+
+        SyntaxInformationMap.prototype.end = function (element) {
+            return this.start(element) + element.width();
+        };
+
+        SyntaxInformationMap.prototype.previousToken = function (token) {
+            return this.tokenInformation(token).previousToken;
+        };
+
+        SyntaxInformationMap.prototype.tokenInformation = function (token) {
+            return this.tokenToInformation.get(token);
+        };
+
+        SyntaxInformationMap.prototype.firstTokenInLineContainingToken = function (token) {
+            var current = token;
+            while (true) {
+                var information = this.tokenInformation(current);
+                if (this.isFirstTokenInLineWorker(information)) {
+                    break;
+                }
+
+                current = information.previousToken;
+            }
+
+            return current;
+        };
+
+        SyntaxInformationMap.prototype.isFirstTokenInLine = function (token) {
+            var information = this.tokenInformation(token);
+            return this.isFirstTokenInLineWorker(information);
+        };
+
+        SyntaxInformationMap.prototype.isFirstTokenInLineWorker = function (information) {
+            return information.previousToken === null || information.previousToken.hasTrailingNewLine();
+        };
+        return SyntaxInformationMap;
+    })(TypeScript.SyntaxWalker);
+    TypeScript.SyntaxInformationMap = SyntaxInformationMap;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxNodeInvariantsChecker = (function (_super) {
+        __extends(SyntaxNodeInvariantsChecker, _super);
+        function SyntaxNodeInvariantsChecker() {
+            _super.apply(this, arguments);
+            this.tokenTable = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode);
+        }
+        SyntaxNodeInvariantsChecker.checkInvariants = function (node) {
+            node.accept(new SyntaxNodeInvariantsChecker());
+        };
+
+        SyntaxNodeInvariantsChecker.prototype.visitToken = function (token) {
+            this.tokenTable.add(token, token);
+        };
+        return SyntaxNodeInvariantsChecker;
+    })(TypeScript.SyntaxWalker);
+    TypeScript.SyntaxNodeInvariantsChecker = SyntaxNodeInvariantsChecker;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var DepthLimitedWalker = (function (_super) {
+        __extends(DepthLimitedWalker, _super);
+        function DepthLimitedWalker(maximumDepth) {
+            _super.call(this);
+            this._depth = 0;
+            this._maximumDepth = 0;
+            this._maximumDepth = maximumDepth;
+        }
+        DepthLimitedWalker.prototype.visitNode = function (node) {
+            if (this._depth < this._maximumDepth) {
+                this._depth++;
+                _super.prototype.visitNode.call(this, node);
+                this._depth--;
+            } else {
+                this.skip(node);
+            }
+        };
+        return DepthLimitedWalker;
+    })(TypeScript.PositionTrackingWalker);
+    TypeScript.DepthLimitedWalker = DepthLimitedWalker;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (Parser) {
+        
+
+        var ExpressionPrecedence;
+        (function (ExpressionPrecedence) {
+            ExpressionPrecedence[ExpressionPrecedence["CommaExpressionPrecedence"] = 1] = "CommaExpressionPrecedence";
+
+            ExpressionPrecedence[ExpressionPrecedence["AssignmentExpressionPrecedence"] = 2] = "AssignmentExpressionPrecedence";
+
+            ExpressionPrecedence[ExpressionPrecedence["ConditionalExpressionPrecedence"] = 3] = "ConditionalExpressionPrecedence";
+
+            ExpressionPrecedence[ExpressionPrecedence["ArrowFunctionPrecedence"] = 4] = "ArrowFunctionPrecedence";
+
+            ExpressionPrecedence[ExpressionPrecedence["LogicalOrExpressionPrecedence"] = 5] = "LogicalOrExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["LogicalAndExpressionPrecedence"] = 6] = "LogicalAndExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["BitwiseOrExpressionPrecedence"] = 7] = "BitwiseOrExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["BitwiseExclusiveOrExpressionPrecedence"] = 8] = "BitwiseExclusiveOrExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["BitwiseAndExpressionPrecedence"] = 9] = "BitwiseAndExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["EqualityExpressionPrecedence"] = 10] = "EqualityExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["RelationalExpressionPrecedence"] = 11] = "RelationalExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["ShiftExpressionPrecdence"] = 12] = "ShiftExpressionPrecdence";
+            ExpressionPrecedence[ExpressionPrecedence["AdditiveExpressionPrecedence"] = 13] = "AdditiveExpressionPrecedence";
+            ExpressionPrecedence[ExpressionPrecedence["MultiplicativeExpressionPrecedence"] = 14] = "MultiplicativeExpressionPrecedence";
+
+            ExpressionPrecedence[ExpressionPrecedence["UnaryExpressionPrecedence"] = 15] = "UnaryExpressionPrecedence";
+        })(ExpressionPrecedence || (ExpressionPrecedence = {}));
+
+        var ListParsingState;
+        (function (ListParsingState) {
+            ListParsingState[ListParsingState["SourceUnit_ModuleElements"] = 1 << 0] = "SourceUnit_ModuleElements";
+            ListParsingState[ListParsingState["ClassDeclaration_ClassElements"] = 1 << 1] = "ClassDeclaration_ClassElements";
+            ListParsingState[ListParsingState["ModuleDeclaration_ModuleElements"] = 1 << 2] = "ModuleDeclaration_ModuleElements";
+            ListParsingState[ListParsingState["SwitchStatement_SwitchClauses"] = 1 << 3] = "SwitchStatement_SwitchClauses";
+            ListParsingState[ListParsingState["SwitchClause_Statements"] = 1 << 4] = "SwitchClause_Statements";
+            ListParsingState[ListParsingState["Block_Statements"] = 1 << 5] = "Block_Statements";
+            ListParsingState[ListParsingState["TryBlock_Statements"] = 1 << 6] = "TryBlock_Statements";
+            ListParsingState[ListParsingState["CatchBlock_Statements"] = 1 << 7] = "CatchBlock_Statements";
+            ListParsingState[ListParsingState["EnumDeclaration_EnumElements"] = 1 << 8] = "EnumDeclaration_EnumElements";
+            ListParsingState[ListParsingState["ObjectType_TypeMembers"] = 1 << 9] = "ObjectType_TypeMembers";
+            ListParsingState[ListParsingState["ClassOrInterfaceDeclaration_HeritageClauses"] = 1 << 10] = "ClassOrInterfaceDeclaration_HeritageClauses";
+            ListParsingState[ListParsingState["HeritageClause_TypeNameList"] = 1 << 11] = "HeritageClause_TypeNameList";
+            ListParsingState[ListParsingState["VariableDeclaration_VariableDeclarators_AllowIn"] = 1 << 12] = "VariableDeclaration_VariableDeclarators_AllowIn";
+            ListParsingState[ListParsingState["VariableDeclaration_VariableDeclarators_DisallowIn"] = 1 << 13] = "VariableDeclaration_VariableDeclarators_DisallowIn";
+            ListParsingState[ListParsingState["ArgumentList_AssignmentExpressions"] = 1 << 14] = "ArgumentList_AssignmentExpressions";
+            ListParsingState[ListParsingState["ObjectLiteralExpression_PropertyAssignments"] = 1 << 15] = "ObjectLiteralExpression_PropertyAssignments";
+            ListParsingState[ListParsingState["ArrayLiteralExpression_AssignmentExpressions"] = 1 << 16] = "ArrayLiteralExpression_AssignmentExpressions";
+            ListParsingState[ListParsingState["ParameterList_Parameters"] = 1 << 17] = "ParameterList_Parameters";
+            ListParsingState[ListParsingState["TypeArgumentList_Types"] = 1 << 18] = "TypeArgumentList_Types";
+            ListParsingState[ListParsingState["TypeParameterList_TypeParameters"] = 1 << 19] = "TypeParameterList_TypeParameters";
+
+            ListParsingState[ListParsingState["FirstListParsingState"] = ListParsingState.SourceUnit_ModuleElements] = "FirstListParsingState";
+            ListParsingState[ListParsingState["LastListParsingState"] = ListParsingState.TypeParameterList_TypeParameters] = "LastListParsingState";
+        })(ListParsingState || (ListParsingState = {}));
+
+        var SyntaxCursor = (function () {
+            function SyntaxCursor(sourceUnit) {
+                this._elements = [];
+                this._index = 0;
+                this._pinCount = 0;
+                sourceUnit.insertChildrenInto(this._elements, 0);
+            }
+            SyntaxCursor.prototype.isFinished = function () {
+                return this._index === this._elements.length;
+            };
+
+            SyntaxCursor.prototype.currentElement = function () {
+                if (this.isFinished()) {
+                    return null;
+                }
+
+                return this._elements[this._index];
+            };
+
+            SyntaxCursor.prototype.currentNode = function () {
+                var element = this.currentElement();
+                return element !== null && element.isNode() ? element : null;
+            };
+
+            SyntaxCursor.prototype.moveToFirstChild = function () {
+                if (this.isFinished()) {
+                    return;
+                }
+
+                var element = this._elements[this._index];
+                if (element.isToken()) {
+                    return;
+                }
+
+                var node = element;
+
+                this._elements.splice(this._index, 1);
+
+                node.insertChildrenInto(this._elements, this._index);
+            };
+
+            SyntaxCursor.prototype.moveToNextSibling = function () {
+                if (this.isFinished()) {
+                    return;
+                }
+
+                if (this._pinCount > 0) {
+                    this._index++;
+                    return;
+                }
+
+                this._elements.shift();
+            };
+
+            SyntaxCursor.prototype.getAndPinCursorIndex = function () {
+                this._pinCount++;
+                return this._index;
+            };
+
+            SyntaxCursor.prototype.releaseAndUnpinCursorIndex = function (index) {
+                this._pinCount--;
+                if (this._pinCount === 0) {
+                }
+            };
+
+            SyntaxCursor.prototype.rewindToPinnedCursorIndex = function (index) {
+                this._index = index;
+            };
+
+            SyntaxCursor.prototype.pinCount = function () {
+                return this._pinCount;
+            };
+
+            SyntaxCursor.prototype.moveToFirstToken = function () {
+                var element;
+
+                while (!this.isFinished()) {
+                    element = this.currentElement();
+                    if (element.isNode()) {
+                        this.moveToFirstChild();
+                        continue;
+                    }
+
+                    return;
+                }
+            };
+
+            SyntaxCursor.prototype.currentToken = function () {
+                this.moveToFirstToken();
+                if (this.isFinished()) {
+                    return null;
+                }
+
+                var element = this.currentElement();
+
+                return element;
+            };
+
+            SyntaxCursor.prototype.peekToken = function (n) {
+                this.moveToFirstToken();
+                var pin = this.getAndPinCursorIndex();
+
+                for (var i = 0; i < n; i++) {
+                    this.moveToNextSibling();
+                    this.moveToFirstToken();
+                }
+
+                var result = this.currentToken();
+                this.rewindToPinnedCursorIndex(pin);
+                this.releaseAndUnpinCursorIndex(pin);
+
+                return result;
+            };
+            return SyntaxCursor;
+        })();
+
+        
+
+        var NormalParserSource = (function () {
+            function NormalParserSource(fileName, text, languageVersion) {
+                this._previousToken = null;
+                this._absolutePosition = 0;
+                this._tokenDiagnostics = [];
+                this.rewindPointPool = [];
+                this.rewindPointPoolCount = 0;
+                this.slidingWindow = new TypeScript.SlidingWindow(this, TypeScript.ArrayUtilities.createArray(32, null), null);
+                this.scanner = new TypeScript.Scanner(fileName, text, languageVersion);
+            }
+            NormalParserSource.prototype.currentNode = function () {
+                return null;
+            };
+
+            NormalParserSource.prototype.moveToNextNode = function () {
+                throw TypeScript.Errors.invalidOperation();
+            };
+
+            NormalParserSource.prototype.absolutePosition = function () {
+                return this._absolutePosition;
+            };
+
+            NormalParserSource.prototype.previousToken = function () {
+                return this._previousToken;
+            };
+
+            NormalParserSource.prototype.tokenDiagnostics = function () {
+                return this._tokenDiagnostics;
+            };
+
+            NormalParserSource.prototype.getOrCreateRewindPoint = function () {
+                if (this.rewindPointPoolCount === 0) {
+                    return {};
+                }
+
+                this.rewindPointPoolCount--;
+                var result = this.rewindPointPool[this.rewindPointPoolCount];
+                this.rewindPointPool[this.rewindPointPoolCount] = null;
+                return result;
+            };
+
+            NormalParserSource.prototype.getRewindPoint = function () {
+                var slidingWindowIndex = this.slidingWindow.getAndPinAbsoluteIndex();
+
+                var rewindPoint = this.getOrCreateRewindPoint();
+
+                rewindPoint.slidingWindowIndex = slidingWindowIndex;
+                rewindPoint.previousToken = this._previousToken;
+                rewindPoint.absolutePosition = this._absolutePosition;
+
+                rewindPoint.pinCount = this.slidingWindow.pinCount();
+
+                return rewindPoint;
+            };
+
+            NormalParserSource.prototype.isPinned = function () {
+                return this.slidingWindow.pinCount() > 0;
+            };
+
+            NormalParserSource.prototype.rewind = function (rewindPoint) {
+                this.slidingWindow.rewindToPinnedIndex(rewindPoint.slidingWindowIndex);
+
+                this._previousToken = rewindPoint.previousToken;
+                this._absolutePosition = rewindPoint.absolutePosition;
+            };
+
+            NormalParserSource.prototype.releaseRewindPoint = function (rewindPoint) {
+                this.slidingWindow.releaseAndUnpinAbsoluteIndex(rewindPoint.absoluteIndex);
+
+                this.rewindPointPool[this.rewindPointPoolCount] = rewindPoint;
+                this.rewindPointPoolCount++;
+            };
+
+            NormalParserSource.prototype.fetchMoreItems = function (allowRegularExpression, sourceIndex, window, destinationIndex, spaceAvailable) {
+                window[destinationIndex] = this.scanner.scan(this._tokenDiagnostics, allowRegularExpression);
+                return 1;
+            };
+
+            NormalParserSource.prototype.peekToken = function (n) {
+                return this.slidingWindow.peekItemN(n);
+            };
+
+            NormalParserSource.prototype.moveToNextToken = function () {
+                var currentToken = this.currentToken();
+                this._absolutePosition += currentToken.fullWidth();
+                this._previousToken = currentToken;
+
+                this.slidingWindow.moveToNextItem();
+            };
+
+            NormalParserSource.prototype.currentToken = function () {
+                return this.slidingWindow.currentItem(false);
+            };
+
+            NormalParserSource.prototype.removeDiagnosticsOnOrAfterPosition = function (position) {
+                var tokenDiagnosticsLength = this._tokenDiagnostics.length;
+                while (tokenDiagnosticsLength > 0) {
+                    var diagnostic = this._tokenDiagnostics[tokenDiagnosticsLength - 1];
+                    if (diagnostic.start() >= position) {
+                        tokenDiagnosticsLength--;
+                    } else {
+                        break;
+                    }
+                }
+
+                this._tokenDiagnostics.length = tokenDiagnosticsLength;
+            };
+
+            NormalParserSource.prototype.resetToPosition = function (absolutePosition, previousToken) {
+                this._absolutePosition = absolutePosition;
+                this._previousToken = previousToken;
+
+                this.removeDiagnosticsOnOrAfterPosition(absolutePosition);
+
+                this.slidingWindow.disgardAllItemsFromCurrentIndexOnwards();
+
+                this.scanner.setAbsoluteIndex(absolutePosition);
+            };
+
+            NormalParserSource.prototype.currentTokenAllowingRegularExpression = function () {
+                this.resetToPosition(this._absolutePosition, this._previousToken);
+
+                var token = this.slidingWindow.currentItem(true);
+
+                return token;
+            };
+            return NormalParserSource;
+        })();
+
+        var IncrementalParserSource = (function () {
+            function IncrementalParserSource(oldSyntaxTree, textChangeRange, newText) {
+                this._changeDelta = 0;
+                var oldSourceUnit = oldSyntaxTree.sourceUnit();
+                this._oldSourceUnitCursor = new SyntaxCursor(oldSourceUnit);
+
+                this._changeRange = IncrementalParserSource.extendToAffectedRange(textChangeRange, oldSourceUnit);
+
+                if (TypeScript.Debug.shouldAssert(2 /* Aggressive */)) {
+                    TypeScript.Debug.assert((oldSourceUnit.fullWidth() - this._changeRange.span().length() + this._changeRange.newLength()) === newText.length());
+                }
+
+                this._normalParserSource = new NormalParserSource(oldSyntaxTree.fileName(), newText, oldSyntaxTree.parseOptions().languageVersion());
+            }
+            IncrementalParserSource.extendToAffectedRange = function (changeRange, sourceUnit) {
+                var maxLookahead = 1;
+
+                var start = changeRange.span().start();
+
+                for (var i = 0; start > 0 && i <= maxLookahead; i++) {
+                    var token = sourceUnit.findToken(start);
+
+                    var position = token.fullStart();
+
+                    start = TypeScript.MathPrototype.max(0, position - 1);
+                }
+
+                var finalSpan = TypeScript.TextSpan.fromBounds(start, changeRange.span().end());
+                var finalLength = changeRange.newLength() + (changeRange.span().start() - start);
+
+                return new TypeScript.TextChangeRange(finalSpan, finalLength);
+            };
+
+            IncrementalParserSource.prototype.absolutePosition = function () {
+                return this._normalParserSource.absolutePosition();
+            };
+
+            IncrementalParserSource.prototype.previousToken = function () {
+                return this._normalParserSource.previousToken();
+            };
+
+            IncrementalParserSource.prototype.tokenDiagnostics = function () {
+                return this._normalParserSource.tokenDiagnostics();
+            };
+
+            IncrementalParserSource.prototype.getRewindPoint = function () {
+                var rewindPoint = this._normalParserSource.getRewindPoint();
+                var oldSourceUnitCursorIndex = this._oldSourceUnitCursor.getAndPinCursorIndex();
+
+                rewindPoint.changeDelta = this._changeDelta;
+                rewindPoint.changeRange = this._changeRange;
+                rewindPoint.oldSourceUnitCursorIndex = oldSourceUnitCursorIndex;
+
+                return rewindPoint;
+            };
+
+            IncrementalParserSource.prototype.rewind = function (rewindPoint) {
+                this._changeRange = rewindPoint.changeRange;
+                this._changeDelta = rewindPoint.changeDelta;
+                this._oldSourceUnitCursor.rewindToPinnedCursorIndex(rewindPoint.oldSourceUnitCursorIndex);
+
+                this._normalParserSource.rewind(rewindPoint);
+            };
+
+            IncrementalParserSource.prototype.releaseRewindPoint = function (rewindPoint) {
+                this._oldSourceUnitCursor.releaseAndUnpinCursorIndex(rewindPoint.oldSourceUnitCursorIndex);
+                this._normalParserSource.releaseRewindPoint(rewindPoint);
+            };
+
+            IncrementalParserSource.prototype.canReadFromOldSourceUnit = function () {
+                if (this._normalParserSource.isPinned()) {
+                    return false;
+                }
+
+                if (this._changeRange !== null && this._changeRange.newSpan().intersectsWithPosition(this.absolutePosition())) {
+                    return false;
+                }
+
+                this.syncCursorToNewTextIfBehind();
+
+                return this._changeDelta === 0 && !this._oldSourceUnitCursor.isFinished();
+            };
+
+            IncrementalParserSource.prototype.currentNode = function () {
+                if (this.canReadFromOldSourceUnit()) {
+                    return this.tryGetNodeFromOldSourceUnit();
+                }
+
+                return null;
+            };
+
+            IncrementalParserSource.prototype.currentToken = function () {
+                if (this.canReadFromOldSourceUnit()) {
+                    var token = this.tryGetTokenFromOldSourceUnit();
+                    if (token !== null) {
+                        return token;
+                    }
+                }
+
+                return this._normalParserSource.currentToken();
+            };
+
+            IncrementalParserSource.prototype.currentTokenAllowingRegularExpression = function () {
+                return this._normalParserSource.currentTokenAllowingRegularExpression();
+            };
+
+            IncrementalParserSource.prototype.syncCursorToNewTextIfBehind = function () {
+                while (true) {
+                    if (this._oldSourceUnitCursor.isFinished()) {
+                        break;
+                    }
+
+                    if (this._changeDelta >= 0) {
+                        break;
+                    }
+
+                    var currentElement = this._oldSourceUnitCursor.currentElement();
+
+                    if (currentElement.isNode() && (currentElement.fullWidth() > Math.abs(this._changeDelta))) {
+                        this._oldSourceUnitCursor.moveToFirstChild();
+                    } else {
+                        this._oldSourceUnitCursor.moveToNextSibling();
+
+                        this._changeDelta += currentElement.fullWidth();
+                    }
+                }
+            };
+
+            IncrementalParserSource.prototype.intersectsWithChangeRangeSpanInOriginalText = function (start, length) {
+                return this._changeRange !== null && this._changeRange.span().intersectsWith(start, length);
+            };
+
+            IncrementalParserSource.prototype.tryGetNodeFromOldSourceUnit = function () {
+                while (true) {
+                    var node = this._oldSourceUnitCursor.currentNode();
+                    if (node === null) {
+                        return null;
+                    }
+
+                    if (!this.intersectsWithChangeRangeSpanInOriginalText(this.absolutePosition(), node.fullWidth())) {
+                        if (!node.isIncrementallyUnusable()) {
+                            return node;
+                        }
+                    }
+
+                    this._oldSourceUnitCursor.moveToFirstChild();
+                }
+            };
+
+            IncrementalParserSource.prototype.canReuseTokenFromOldSourceUnit = function (position, token) {
+                if (token !== null) {
+                    if (!this.intersectsWithChangeRangeSpanInOriginalText(position, token.fullWidth())) {
+                        if (!token.isIncrementallyUnusable()) {
+                            return true;
+                        }
+                    }
+                }
+
+                return false;
+            };
+
+            IncrementalParserSource.prototype.tryGetTokenFromOldSourceUnit = function () {
+                var token = this._oldSourceUnitCursor.currentToken();
+
+                return this.canReuseTokenFromOldSourceUnit(this.absolutePosition(), token) ? token : null;
+            };
+
+            IncrementalParserSource.prototype.peekToken = function (n) {
+                if (this.canReadFromOldSourceUnit()) {
+                    var token = this.tryPeekTokenFromOldSourceUnit(n);
+                    if (token !== null) {
+                        return token;
+                    }
+                }
+
+                return this._normalParserSource.peekToken(n);
+            };
+
+            IncrementalParserSource.prototype.tryPeekTokenFromOldSourceUnit = function (n) {
+                var currentPosition = this.absolutePosition();
+                for (var i = 0; i < n; i++) {
+                    var interimToken = this._oldSourceUnitCursor.peekToken(i);
+                    if (!this.canReuseTokenFromOldSourceUnit(currentPosition, interimToken)) {
+                        return null;
+                    }
+
+                    currentPosition += interimToken.fullWidth();
+                }
+
+                var token = this._oldSourceUnitCursor.peekToken(n);
+                return this.canReuseTokenFromOldSourceUnit(currentPosition, token) ? token : null;
+            };
+
+            IncrementalParserSource.prototype.moveToNextNode = function () {
+                var currentElement = this._oldSourceUnitCursor.currentElement();
+                var currentNode = this._oldSourceUnitCursor.currentNode();
+
+                this._oldSourceUnitCursor.moveToNextSibling();
+
+                var absolutePosition = this.absolutePosition() + currentNode.fullWidth();
+                var previousToken = currentNode.lastToken();
+                this._normalParserSource.resetToPosition(absolutePosition, previousToken);
+
+                if (this._changeRange !== null) {
+                }
+            };
+
+            IncrementalParserSource.prototype.moveToNextToken = function () {
+                var currentToken = this.currentToken();
+
+                if (this._oldSourceUnitCursor.currentToken() === currentToken) {
+                    this._oldSourceUnitCursor.moveToNextSibling();
+
+                    var absolutePosition = this.absolutePosition() + currentToken.fullWidth();
+                    var previousToken = currentToken;
+                    this._normalParserSource.resetToPosition(absolutePosition, previousToken);
+
+                    if (this._changeRange !== null) {
+                    }
+                } else {
+                    this._changeDelta -= currentToken.fullWidth();
+
+                    this._normalParserSource.moveToNextToken();
+
+                    if (this._changeRange !== null) {
+                        var changeRangeSpanInNewText = this._changeRange.newSpan();
+                        if (this.absolutePosition() >= changeRangeSpanInNewText.end()) {
+                            this._changeDelta += this._changeRange.newLength() - this._changeRange.span().length();
+                            this._changeRange = null;
+                        }
+                    }
+                }
+            };
+            return IncrementalParserSource;
+        })();
+
+        var ParserImpl = (function () {
+            function ParserImpl(fileName, lineMap, source, parseOptions, newText_forDebuggingPurposesOnly) {
+                this.newText_forDebuggingPurposesOnly = newText_forDebuggingPurposesOnly;
+                this.listParsingState = 0;
+                this.isInStrictMode = false;
+                this.diagnostics = [];
+                this.factory = TypeScript.Syntax.normalModeFactory;
+                this.mergeTokensStorage = [];
+                this.arrayPool = [];
+                this.fileName = fileName;
+                this.lineMap = lineMap;
+                this.source = source;
+                this.parseOptions = parseOptions;
+            }
+            ParserImpl.prototype.getRewindPoint = function () {
+                var rewindPoint = this.source.getRewindPoint();
+
+                rewindPoint.diagnosticsCount = this.diagnostics.length;
+
+                rewindPoint.isInStrictMode = this.isInStrictMode;
+                rewindPoint.listParsingState = this.listParsingState;
+
+                return rewindPoint;
+            };
+
+            ParserImpl.prototype.rewind = function (rewindPoint) {
+                this.source.rewind(rewindPoint);
+
+                this.diagnostics.length = rewindPoint.diagnosticsCount;
+            };
+
+            ParserImpl.prototype.releaseRewindPoint = function (rewindPoint) {
+                this.source.releaseRewindPoint(rewindPoint);
+            };
+
+            ParserImpl.prototype.currentTokenStart = function () {
+                return this.source.absolutePosition() + this.currentToken().leadingTriviaWidth();
+            };
+
+            ParserImpl.prototype.previousTokenStart = function () {
+                if (this.previousToken() === null) {
+                    return 0;
+                }
+
+                return this.source.absolutePosition() - this.previousToken().fullWidth() + this.previousToken().leadingTriviaWidth();
+            };
+
+            ParserImpl.prototype.previousTokenEnd = function () {
+                if (this.previousToken() === null) {
+                    return 0;
+                }
+
+                return this.previousTokenStart() + this.previousToken().width();
+            };
+
+            ParserImpl.prototype.currentNode = function () {
+                var node = this.source.currentNode();
+
+                if (node === null || node.parsedInStrictMode() !== this.isInStrictMode) {
+                    return null;
+                }
+
+                return node;
+            };
+
+            ParserImpl.prototype.currentToken = function () {
+                return this.source.currentToken();
+            };
+
+            ParserImpl.prototype.currentTokenAllowingRegularExpression = function () {
+                return this.source.currentTokenAllowingRegularExpression();
+            };
+
+            ParserImpl.prototype.peekToken = function (n) {
+                return this.source.peekToken(n);
+            };
+
+            ParserImpl.prototype.eatAnyToken = function () {
+                var token = this.currentToken();
+                this.moveToNextToken();
+                return token;
+            };
+
+            ParserImpl.prototype.moveToNextToken = function () {
+                this.source.moveToNextToken();
+            };
+
+            ParserImpl.prototype.previousToken = function () {
+                return this.source.previousToken();
+            };
+
+            ParserImpl.prototype.eatNode = function () {
+                var node = this.source.currentNode();
+                this.source.moveToNextNode();
+                return node;
+            };
+
+            ParserImpl.prototype.eatToken = function (kind) {
+                var token = this.currentToken();
+                if (token.tokenKind === kind) {
+                    this.moveToNextToken();
+                    return token;
+                }
+
+                return this.createMissingToken(kind, token);
+            };
+
+            ParserImpl.prototype.tryEatToken = function (kind) {
+                if (this.currentToken().tokenKind === kind) {
+                    return this.eatToken(kind);
+                }
+
+                return null;
+            };
+
+            ParserImpl.prototype.eatKeyword = function (kind) {
+                var token = this.currentToken();
+                if (token.tokenKind === kind) {
+                    this.moveToNextToken();
+                    return token;
+                }
+
+                return this.createMissingToken(kind, token);
+            };
+
+            ParserImpl.prototype.isIdentifier = function (token) {
+                var tokenKind = token.tokenKind;
+
+                if (tokenKind === 11 /* IdentifierName */) {
+                    return true;
+                }
+
+                if (tokenKind >= 51 /* FirstFutureReservedStrictKeyword */) {
+                    if (tokenKind <= 59 /* LastFutureReservedStrictKeyword */) {
+                        return !this.isInStrictMode;
+                    }
+
+                    return tokenKind <= 69 /* LastTypeScriptKeyword */;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.eatIdentifierNameToken = function () {
+                var token = this.currentToken();
+
+                if (token.tokenKind === 11 /* IdentifierName */) {
+                    this.moveToNextToken();
+                    return token;
+                }
+
+                if (TypeScript.SyntaxFacts.isAnyKeyword(token.tokenKind)) {
+                    this.moveToNextToken();
+                    return TypeScript.Syntax.convertToIdentifierName(token);
+                }
+
+                return this.createMissingToken(11 /* IdentifierName */, token);
+            };
+
+            ParserImpl.prototype.eatIdentifierToken = function () {
+                var token = this.currentToken();
+                if (this.isIdentifier(token)) {
+                    this.moveToNextToken();
+
+                    if (token.tokenKind === 11 /* IdentifierName */) {
+                        return token;
+                    }
+
+                    return TypeScript.Syntax.convertToIdentifierName(token);
+                }
+
+                return this.createMissingToken(11 /* IdentifierName */, token);
+            };
+
+            ParserImpl.prototype.canEatAutomaticSemicolon = function (allowWithoutNewLine) {
+                var token = this.currentToken();
+
+                if (token.tokenKind === 10 /* EndOfFileToken */) {
+                    return true;
+                }
+
+                if (token.tokenKind === 71 /* CloseBraceToken */) {
+                    return true;
+                }
+
+                if (allowWithoutNewLine) {
+                    return true;
+                }
+
+                if (this.previousToken() !== null && this.previousToken().hasTrailingNewLine()) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.canEatExplicitOrAutomaticSemicolon = function (allowWithoutNewline) {
+                var token = this.currentToken();
+
+                if (token.tokenKind === 78 /* SemicolonToken */) {
+                    return true;
+                }
+
+                return this.canEatAutomaticSemicolon(allowWithoutNewline);
+            };
+
+            ParserImpl.prototype.eatExplicitOrAutomaticSemicolon = function (allowWithoutNewline) {
+                var token = this.currentToken();
+
+                if (token.tokenKind === 78 /* SemicolonToken */) {
+                    return this.eatToken(78 /* SemicolonToken */);
+                }
+
+                if (this.canEatAutomaticSemicolon(allowWithoutNewline)) {
+                    var semicolonToken = TypeScript.Syntax.emptyToken(78 /* SemicolonToken */);
+
+                    if (!this.parseOptions.allowAutomaticSemicolonInsertion()) {
+                        this.addDiagnostic(new TypeScript.Diagnostic(this.fileName, this.lineMap, this.previousTokenEnd(), 0, TypeScript.DiagnosticCode.Automatic_semicolon_insertion_not_allowed, null));
+                    }
+
+                    return semicolonToken;
+                }
+
+                return this.eatToken(78 /* SemicolonToken */);
+            };
+
+            ParserImpl.prototype.isKeyword = function (kind) {
+                if (kind >= 15 /* FirstKeyword */) {
+                    if (kind <= 50 /* LastFutureReservedKeyword */) {
+                        return true;
+                    }
+
+                    if (this.isInStrictMode) {
+                        return kind <= 59 /* LastFutureReservedStrictKeyword */;
+                    }
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.createMissingToken = function (expectedKind, actual) {
+                var diagnostic = this.getExpectedTokenDiagnostic(expectedKind, actual);
+                this.addDiagnostic(diagnostic);
+
+                return TypeScript.Syntax.emptyToken(expectedKind);
+            };
+
+            ParserImpl.prototype.getExpectedTokenDiagnostic = function (expectedKind, actual) {
+                var token = this.currentToken();
+
+                if (TypeScript.SyntaxFacts.isAnyKeyword(expectedKind) || TypeScript.SyntaxFacts.isAnyPunctuation(expectedKind)) {
+                    return new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode._0_expected, [TypeScript.SyntaxFacts.getText(expectedKind)]);
+                } else {
+                    if (actual !== null && TypeScript.SyntaxFacts.isAnyKeyword(actual.tokenKind)) {
+                        return new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode.Identifier_expected_0_is_a_keyword, [TypeScript.SyntaxFacts.getText(actual.tokenKind)]);
+                    } else {
+                        return new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode.Identifier_expected, null);
+                    }
+                }
+            };
+
+            ParserImpl.getPrecedence = function (expressionKind) {
+                switch (expressionKind) {
+                    case 173 /* CommaExpression */:
+                        return 1 /* CommaExpressionPrecedence */;
+
+                    case 174 /* AssignmentExpression */:
+                    case 175 /* AddAssignmentExpression */:
+                    case 176 /* SubtractAssignmentExpression */:
+                    case 177 /* MultiplyAssignmentExpression */:
+                    case 178 /* DivideAssignmentExpression */:
+                    case 179 /* ModuloAssignmentExpression */:
+                    case 180 /* AndAssignmentExpression */:
+                    case 181 /* ExclusiveOrAssignmentExpression */:
+                    case 182 /* OrAssignmentExpression */:
+                    case 183 /* LeftShiftAssignmentExpression */:
+                    case 184 /* SignedRightShiftAssignmentExpression */:
+                    case 185 /* UnsignedRightShiftAssignmentExpression */:
+                        return 2 /* AssignmentExpressionPrecedence */;
+
+                    case 186 /* ConditionalExpression */:
+                        return 3 /* ConditionalExpressionPrecedence */;
+
+                    case 187 /* LogicalOrExpression */:
+                        return 5 /* LogicalOrExpressionPrecedence */;
+
+                    case 188 /* LogicalAndExpression */:
+                        return 6 /* LogicalAndExpressionPrecedence */;
+
+                    case 189 /* BitwiseOrExpression */:
+                        return 7 /* BitwiseOrExpressionPrecedence */;
+
+                    case 190 /* BitwiseExclusiveOrExpression */:
+                        return 8 /* BitwiseExclusiveOrExpressionPrecedence */;
+
+                    case 191 /* BitwiseAndExpression */:
+                        return 9 /* BitwiseAndExpressionPrecedence */;
+
+                    case 192 /* EqualsWithTypeConversionExpression */:
+                    case 193 /* NotEqualsWithTypeConversionExpression */:
+                    case 194 /* EqualsExpression */:
+                    case 195 /* NotEqualsExpression */:
+                        return 10 /* EqualityExpressionPrecedence */;
+
+                    case 196 /* LessThanExpression */:
+                    case 197 /* GreaterThanExpression */:
+                    case 198 /* LessThanOrEqualExpression */:
+                    case 199 /* GreaterThanOrEqualExpression */:
+                    case 200 /* InstanceOfExpression */:
+                    case 201 /* InExpression */:
+                        return 11 /* RelationalExpressionPrecedence */;
+
+                    case 202 /* LeftShiftExpression */:
+                    case 203 /* SignedRightShiftExpression */:
+                    case 204 /* UnsignedRightShiftExpression */:
+                        return 12 /* ShiftExpressionPrecdence */;
+
+                    case 208 /* AddExpression */:
+                    case 209 /* SubtractExpression */:
+                        return 13 /* AdditiveExpressionPrecedence */;
+
+                    case 205 /* MultiplyExpression */:
+                    case 206 /* DivideExpression */:
+                    case 207 /* ModuloExpression */:
+                        return 14 /* MultiplicativeExpressionPrecedence */;
+
+                    case 164 /* PlusExpression */:
+                    case 165 /* NegateExpression */:
+                    case 166 /* BitwiseNotExpression */:
+                    case 167 /* LogicalNotExpression */:
+                    case 170 /* DeleteExpression */:
+                    case 171 /* TypeOfExpression */:
+                    case 172 /* VoidExpression */:
+                    case 168 /* PreIncrementExpression */:
+                    case 169 /* PreDecrementExpression */:
+                        return 15 /* UnaryExpressionPrecedence */;
+                }
+
+                throw TypeScript.Errors.invalidOperation();
+            };
+
+            ParserImpl.prototype.addSkippedTokenAfterNodeOrToken = function (nodeOrToken, skippedToken) {
+                if (nodeOrToken.isToken()) {
+                    return this.addSkippedTokenAfterToken(nodeOrToken, skippedToken);
+                } else if (nodeOrToken.isNode()) {
+                    return this.addSkippedTokenAfterNode(nodeOrToken, skippedToken);
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.addSkippedTokenAfterNode = function (node, skippedToken) {
+                var oldToken = node.lastToken();
+                var newToken = this.addSkippedTokenAfterToken(oldToken, skippedToken);
+
+                return node.replaceToken(oldToken, newToken);
+            };
+
+            ParserImpl.prototype.addSkippedTokensBeforeNode = function (node, skippedTokens) {
+                if (skippedTokens.length > 0) {
+                    var oldToken = node.firstToken();
+                    var newToken = this.addSkippedTokensBeforeToken(oldToken, skippedTokens);
+
+                    return node.replaceToken(oldToken, newToken);
+                }
+
+                return node;
+            };
+
+            ParserImpl.prototype.addSkippedTokensBeforeToken = function (token, skippedTokens) {
+                var leadingTrivia = [];
+                for (var i = 0, n = skippedTokens.length; i < n; i++) {
+                    this.addSkippedTokenToTriviaArray(leadingTrivia, skippedTokens[i]);
+                }
+
+                this.addTriviaTo(token.leadingTrivia(), leadingTrivia);
+
+                this.returnArray(skippedTokens);
+                return token.withLeadingTrivia(TypeScript.Syntax.triviaList(leadingTrivia));
+            };
+
+            ParserImpl.prototype.addSkippedTokensAfterToken = function (token, skippedTokens) {
+                if (skippedTokens.length === 0) {
+                    this.returnArray(skippedTokens);
+                    return token;
+                }
+
+                var trailingTrivia = token.trailingTrivia().toArray();
+
+                for (var i = 0, n = skippedTokens.length; i < n; i++) {
+                    this.addSkippedTokenToTriviaArray(trailingTrivia, skippedTokens[i]);
+                }
+
+                this.returnArray(skippedTokens);
+                return token.withTrailingTrivia(TypeScript.Syntax.triviaList(trailingTrivia));
+            };
+
+            ParserImpl.prototype.addSkippedTokenAfterToken = function (token, skippedToken) {
+                var trailingTrivia = token.trailingTrivia().toArray();
+                this.addSkippedTokenToTriviaArray(trailingTrivia, skippedToken);
+
+                return token.withTrailingTrivia(TypeScript.Syntax.triviaList(trailingTrivia));
+            };
+
+            ParserImpl.prototype.addSkippedTokenToTriviaArray = function (array, skippedToken) {
+                this.addTriviaTo(skippedToken.leadingTrivia(), array);
+
+                var trimmedToken = skippedToken.withLeadingTrivia(TypeScript.Syntax.emptyTriviaList).withTrailingTrivia(TypeScript.Syntax.emptyTriviaList);
+                array.push(TypeScript.Syntax.skippedTokenTrivia(trimmedToken));
+
+                this.addTriviaTo(skippedToken.trailingTrivia(), array);
+            };
+
+            ParserImpl.prototype.addTriviaTo = function (list, array) {
+                for (var i = 0, n = list.count(); i < n; i++) {
+                    array.push(list.syntaxTriviaAt(i));
+                }
+            };
+
+            ParserImpl.prototype.parseSyntaxTree = function (isDeclaration) {
+                var sourceUnit = this.parseSourceUnit();
+
+                var allDiagnostics = this.source.tokenDiagnostics().concat(this.diagnostics);
+                allDiagnostics.sort(function (a, b) {
+                    return a.start() - b.start();
+                });
+
+                return new TypeScript.SyntaxTree(sourceUnit, isDeclaration, allDiagnostics, this.fileName, this.lineMap, this.parseOptions);
+            };
+
+            ParserImpl.prototype.setStrictMode = function (isInStrictMode) {
+                this.isInStrictMode = isInStrictMode;
+                this.factory = isInStrictMode ? TypeScript.Syntax.strictModeFactory : TypeScript.Syntax.normalModeFactory;
+            };
+
+            ParserImpl.prototype.parseSourceUnit = function () {
+                var savedIsInStrictMode = this.isInStrictMode;
+
+                var result = this.parseSyntaxList(1 /* SourceUnit_ModuleElements */, ParserImpl.updateStrictModeState);
+                var moduleElements = result.list;
+
+                this.setStrictMode(savedIsInStrictMode);
+
+                var sourceUnit = this.factory.sourceUnit(moduleElements, this.currentToken());
+                sourceUnit = this.addSkippedTokensBeforeNode(sourceUnit, result.skippedTokens);
+
+                if (TypeScript.Debug.shouldAssert(2 /* Aggressive */)) {
+                    TypeScript.Debug.assert(sourceUnit.fullWidth() === this.newText_forDebuggingPurposesOnly.length());
+
+                    if (TypeScript.Debug.shouldAssert(3 /* VeryAggressive */)) {
+                        TypeScript.Debug.assert(sourceUnit.fullText() === this.newText_forDebuggingPurposesOnly.substr(0, this.newText_forDebuggingPurposesOnly.length(), false));
+                    }
+                }
+
+                return sourceUnit;
+            };
+
+            ParserImpl.updateStrictModeState = function (parser, items) {
+                if (!parser.isInStrictMode) {
+                    for (var i = 0; i < items.length; i++) {
+                        var item = items[i];
+                        if (!TypeScript.SyntaxFacts.isDirectivePrologueElement(item)) {
+                            return;
+                        }
+                    }
+
+                    parser.setStrictMode(TypeScript.SyntaxFacts.isUseStrictDirective(items[items.length - 1]));
+                }
+            };
+
+            ParserImpl.prototype.isModuleElement = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isModuleElement()) {
+                    return true;
+                }
+
+                var modifierCount = this.modifierCount();
+                return this.isImportDeclaration(modifierCount) || this.isExportAssignment() || this.isModuleDeclaration(modifierCount) || this.isInterfaceDeclaration(modifierCount) || this.isClassDeclaration(modifierCount) || this.isEnumDeclaration(modifierCount) || this.isStatement(inErrorRecovery);
+            };
+
+            ParserImpl.prototype.parseModuleElement = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isModuleElement()) {
+                    return this.eatNode();
+                }
+
+                var modifierCount = this.modifierCount();
+                if (this.isImportDeclaration(modifierCount)) {
+                    return this.parseImportDeclaration();
+                } else if (this.isExportAssignment()) {
+                    return this.parseExportAssignment();
+                } else if (this.isModuleDeclaration(modifierCount)) {
+                    return this.parseModuleDeclaration();
+                } else if (this.isInterfaceDeclaration(modifierCount)) {
+                    return this.parseInterfaceDeclaration();
+                } else if (this.isClassDeclaration(modifierCount)) {
+                    return this.parseClassDeclaration();
+                } else if (this.isEnumDeclaration(modifierCount)) {
+                    return this.parseEnumDeclaration();
+                } else if (this.isStatement(inErrorRecovery)) {
+                    return this.parseStatement(inErrorRecovery);
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.isImportDeclaration = function (modifierCount) {
+                if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 49 /* ImportKeyword */) {
+                    return true;
+                }
+
+                return this.currentToken().tokenKind === 49 /* ImportKeyword */ && this.isIdentifier(this.peekToken(1));
+            };
+
+            ParserImpl.prototype.parseImportDeclaration = function () {
+                var modifiers = this.parseModifiers();
+                var importKeyword = this.eatKeyword(49 /* ImportKeyword */);
+                var identifier = this.eatIdentifierToken();
+                var equalsToken = this.eatToken(107 /* EqualsToken */);
+                var moduleReference = this.parseModuleReference();
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.importDeclaration(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken);
+            };
+
+            ParserImpl.prototype.isExportAssignment = function () {
+                return this.currentToken().tokenKind === 47 /* ExportKeyword */ && this.peekToken(1).tokenKind === 107 /* EqualsToken */;
+            };
+
+            ParserImpl.prototype.parseExportAssignment = function () {
+                var exportKeyword = this.eatKeyword(47 /* ExportKeyword */);
+                var equalsToken = this.eatToken(107 /* EqualsToken */);
+                var identifier = this.eatIdentifierToken();
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.exportAssignment(exportKeyword, equalsToken, identifier, semicolonToken);
+            };
+
+            ParserImpl.prototype.parseModuleReference = function () {
+                if (this.isExternalModuleReference()) {
+                    return this.parseExternalModuleReference();
+                } else {
+                    return this.parseModuleNameModuleReference();
+                }
+            };
+
+            ParserImpl.prototype.isExternalModuleReference = function () {
+                var token0 = this.currentToken();
+                if (token0.tokenKind === 66 /* RequireKeyword */) {
+                    return this.peekToken(1).tokenKind === 72 /* OpenParenToken */;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.parseExternalModuleReference = function () {
+                var requireKeyword = this.eatKeyword(66 /* RequireKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var stringLiteral = this.eatToken(14 /* StringLiteral */);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+
+                return this.factory.externalModuleReference(requireKeyword, openParenToken, stringLiteral, closeParenToken);
+            };
+
+            ParserImpl.prototype.parseModuleNameModuleReference = function () {
+                var name = this.parseName();
+                return this.factory.moduleNameModuleReference(name);
+            };
+
+            ParserImpl.prototype.parseIdentifierName = function () {
+                var identifierName = this.eatIdentifierNameToken();
+                return identifierName;
+            };
+
+            ParserImpl.prototype.tryParseTypeArgumentList = function (inExpression) {
+                if (this.currentToken().kind() !== 80 /* LessThanToken */) {
+                    return null;
+                }
+
+                var lessThanToken;
+                var greaterThanToken;
+                var result;
+                var typeArguments;
+
+                if (!inExpression) {
+                    lessThanToken = this.eatToken(80 /* LessThanToken */);
+
+                    result = this.parseSeparatedSyntaxList(262144 /* TypeArgumentList_Types */);
+                    typeArguments = result.list;
+                    lessThanToken = this.addSkippedTokensAfterToken(lessThanToken, result.skippedTokens);
+
+                    greaterThanToken = this.eatToken(81 /* GreaterThanToken */);
+
+                    return this.factory.typeArgumentList(lessThanToken, typeArguments, greaterThanToken);
+                }
+
+                var rewindPoint = this.getRewindPoint();
+
+                lessThanToken = this.eatToken(80 /* LessThanToken */);
+
+                result = this.parseSeparatedSyntaxList(262144 /* TypeArgumentList_Types */);
+                typeArguments = result.list;
+                lessThanToken = this.addSkippedTokensAfterToken(lessThanToken, result.skippedTokens);
+
+                greaterThanToken = this.eatToken(81 /* GreaterThanToken */);
+
+                if (greaterThanToken.fullWidth() === 0 || !this.canFollowTypeArgumentListInExpression(this.currentToken().kind())) {
+                    this.rewind(rewindPoint);
+
+                    this.releaseRewindPoint(rewindPoint);
+                    return null;
+                } else {
+                    this.releaseRewindPoint(rewindPoint);
+                    var typeArgumentList = this.factory.typeArgumentList(lessThanToken, typeArguments, greaterThanToken);
+
+                    return typeArgumentList;
+                }
+            };
+
+            ParserImpl.prototype.canFollowTypeArgumentListInExpression = function (kind) {
+                switch (kind) {
+                    case 72 /* OpenParenToken */:
+                    case 76 /* DotToken */:
+
+                    case 73 /* CloseParenToken */:
+                    case 75 /* CloseBracketToken */:
+                    case 106 /* ColonToken */:
+                    case 78 /* SemicolonToken */:
+                    case 79 /* CommaToken */:
+                    case 105 /* QuestionToken */:
+                    case 84 /* EqualsEqualsToken */:
+                    case 87 /* EqualsEqualsEqualsToken */:
+                    case 86 /* ExclamationEqualsToken */:
+                    case 88 /* ExclamationEqualsEqualsToken */:
+                    case 103 /* AmpersandAmpersandToken */:
+                    case 104 /* BarBarToken */:
+                    case 100 /* CaretToken */:
+                    case 98 /* AmpersandToken */:
+                    case 99 /* BarToken */:
+                    case 71 /* CloseBraceToken */:
+                    case 10 /* EndOfFileToken */:
+                        return true;
+
+                    default:
+                        return false;
+                }
+            };
+
+            ParserImpl.prototype.parseName = function () {
+                var shouldContinue = this.isIdentifier(this.currentToken());
+                var current = this.eatIdentifierToken();
+
+                while (shouldContinue && this.currentToken().tokenKind === 76 /* DotToken */) {
+                    var dotToken = this.eatToken(76 /* DotToken */);
+
+                    var currentToken = this.currentToken();
+                    var identifierName;
+
+                    if (TypeScript.SyntaxFacts.isAnyKeyword(currentToken.tokenKind) && this.previousToken().hasTrailingNewLine() && !currentToken.hasTrailingNewLine() && TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(this.peekToken(1))) {
+                        identifierName = this.createMissingToken(11 /* IdentifierName */, currentToken);
+                    } else {
+                        identifierName = this.eatIdentifierNameToken();
+                    }
+
+                    current = this.factory.qualifiedName(current, dotToken, identifierName);
+
+                    shouldContinue = identifierName.fullWidth() > 0;
+                }
+
+                return current;
+            };
+
+            ParserImpl.prototype.isEnumDeclaration = function (modifierCount) {
+                if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 46 /* EnumKeyword */) {
+                    return true;
+                }
+
+                return this.currentToken().tokenKind === 46 /* EnumKeyword */ && this.isIdentifier(this.peekToken(1));
+            };
+
+            ParserImpl.prototype.parseEnumDeclaration = function () {
+                var modifiers = this.parseModifiers();
+                var enumKeyword = this.eatKeyword(46 /* EnumKeyword */);
+                var identifier = this.eatIdentifierToken();
+
+                var openBraceToken = this.eatToken(70 /* OpenBraceToken */);
+                var enumElements = TypeScript.Syntax.emptySeparatedList;
+
+                if (openBraceToken.width() > 0) {
+                    var result = this.parseSeparatedSyntaxList(256 /* EnumDeclaration_EnumElements */);
+                    enumElements = result.list;
+                    openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens);
+                }
+
+                var closeBraceToken = this.eatToken(71 /* CloseBraceToken */);
+
+                return this.factory.enumDeclaration(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken);
+            };
+
+            ParserImpl.prototype.isEnumElement = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().kind() === 243 /* EnumElement */) {
+                    return true;
+                }
+
+                return this.isPropertyName(this.currentToken(), inErrorRecovery);
+            };
+
+            ParserImpl.prototype.parseEnumElement = function () {
+                if (this.currentNode() !== null && this.currentNode().kind() === 243 /* EnumElement */) {
+                    return this.eatNode();
+                }
+
+                var propertyName = this.eatPropertyName();
+                var equalsValueClause = null;
+                if (this.isEqualsValueClause(false)) {
+                    equalsValueClause = this.parseEqualsValueClause(true);
+                }
+
+                return this.factory.enumElement(propertyName, equalsValueClause);
+            };
+
+            ParserImpl.isModifier = function (token) {
+                switch (token.tokenKind) {
+                    case 57 /* PublicKeyword */:
+                    case 55 /* PrivateKeyword */:
+                    case 58 /* StaticKeyword */:
+                    case 47 /* ExportKeyword */:
+                    case 63 /* DeclareKeyword */:
+                        return true;
+
+                    default:
+                        return false;
+                }
+            };
+
+            ParserImpl.prototype.modifierCount = function () {
+                var modifierCount = 0;
+                while (true) {
+                    if (ParserImpl.isModifier(this.peekToken(modifierCount))) {
+                        modifierCount++;
+                        continue;
+                    }
+
+                    break;
+                }
+
+                return modifierCount;
+            };
+
+            ParserImpl.prototype.parseModifiers = function () {
+                var tokens = this.getArray();
+
+                while (true) {
+                    if (ParserImpl.isModifier(this.currentToken())) {
+                        tokens.push(this.eatAnyToken());
+                        continue;
+                    }
+
+                    break;
+                }
+
+                var result = TypeScript.Syntax.list(tokens);
+
+                this.returnZeroOrOneLengthArray(tokens);
+
+                return result;
+            };
+
+            ParserImpl.prototype.isClassDeclaration = function (modifierCount) {
+                if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 44 /* ClassKeyword */) {
+                    return true;
+                }
+
+                return this.currentToken().tokenKind === 44 /* ClassKeyword */ && this.isIdentifier(this.peekToken(1));
+            };
+
+            ParserImpl.prototype.parseHeritageClauses = function () {
+                var heritageClauses = TypeScript.Syntax.emptyList;
+
+                if (this.isHeritageClause()) {
+                    var result = this.parseSyntaxList(1024 /* ClassOrInterfaceDeclaration_HeritageClauses */);
+                    heritageClauses = result.list;
+                    TypeScript.Debug.assert(result.skippedTokens.length === 0);
+                }
+
+                return heritageClauses;
+            };
+
+            ParserImpl.prototype.parseClassDeclaration = function () {
+                var modifiers = this.parseModifiers();
+
+                var classKeyword = this.eatKeyword(44 /* ClassKeyword */);
+                var identifier = this.eatIdentifierToken();
+                var typeParameterList = this.parseOptionalTypeParameterList(false);
+                var heritageClauses = this.parseHeritageClauses();
+                var openBraceToken = this.eatToken(70 /* OpenBraceToken */);
+                var classElements = TypeScript.Syntax.emptyList;
+
+                if (openBraceToken.width() > 0) {
+                    var result = this.parseSyntaxList(2 /* ClassDeclaration_ClassElements */);
+
+                    classElements = result.list;
+                    openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens);
+                }
+
+                var closeBraceToken = this.eatToken(71 /* CloseBraceToken */);
+                return this.factory.classDeclaration(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken);
+            };
+
+            ParserImpl.isPublicOrPrivateKeyword = function (token) {
+                return token.tokenKind === 57 /* PublicKeyword */ || token.tokenKind === 55 /* PrivateKeyword */;
+            };
+
+            ParserImpl.prototype.isAccessor = function (inErrorRecovery) {
+                var index = this.modifierCount();
+
+                if (this.peekToken(index).tokenKind !== 64 /* GetKeyword */ && this.peekToken(index).tokenKind !== 68 /* SetKeyword */) {
+                    return false;
+                }
+
+                index++;
+                return this.isPropertyName(this.peekToken(index), inErrorRecovery);
+            };
+
+            ParserImpl.prototype.parseAccessor = function (checkForStrictMode) {
+                var modifiers = this.parseModifiers();
+
+                if (this.currentToken().tokenKind === 64 /* GetKeyword */) {
+                    return this.parseGetMemberAccessorDeclaration(modifiers, checkForStrictMode);
+                } else if (this.currentToken().tokenKind === 68 /* SetKeyword */) {
+                    return this.parseSetMemberAccessorDeclaration(modifiers, checkForStrictMode);
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.parseGetMemberAccessorDeclaration = function (modifiers, checkForStrictMode) {
+                var getKeyword = this.eatKeyword(64 /* GetKeyword */);
+                var propertyName = this.eatPropertyName();
+                var parameterList = this.parseParameterList();
+                var typeAnnotation = this.parseOptionalTypeAnnotation(false);
+                var block = this.parseBlock(false, checkForStrictMode);
+
+                return this.factory.getAccessor(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block);
+            };
+
+            ParserImpl.prototype.parseSetMemberAccessorDeclaration = function (modifiers, checkForStrictMode) {
+                var setKeyword = this.eatKeyword(68 /* SetKeyword */);
+                var propertyName = this.eatPropertyName();
+                var parameterList = this.parseParameterList();
+                var block = this.parseBlock(false, checkForStrictMode);
+
+                return this.factory.setAccessor(modifiers, setKeyword, propertyName, parameterList, block);
+            };
+
+            ParserImpl.prototype.isClassElement = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isClassElement()) {
+                    return true;
+                }
+
+                return this.isConstructorDeclaration() || this.isMemberFunctionDeclaration(inErrorRecovery) || this.isAccessor(inErrorRecovery) || this.isMemberVariableDeclaration(inErrorRecovery) || this.isIndexMemberDeclaration();
+            };
+
+            ParserImpl.prototype.parseClassElement = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isClassElement()) {
+                    return this.eatNode();
+                }
+
+                if (this.isConstructorDeclaration()) {
+                    return this.parseConstructorDeclaration();
+                } else if (this.isMemberFunctionDeclaration(inErrorRecovery)) {
+                    return this.parseMemberFunctionDeclaration();
+                } else if (this.isAccessor(inErrorRecovery)) {
+                    return this.parseAccessor(false);
+                } else if (this.isMemberVariableDeclaration(inErrorRecovery)) {
+                    return this.parseMemberVariableDeclaration();
+                } else if (this.isIndexMemberDeclaration()) {
+                    return this.parseIndexMemberDeclaration();
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.isConstructorDeclaration = function () {
+                var index = this.modifierCount();
+                return this.peekToken(index).tokenKind === 62 /* ConstructorKeyword */;
+            };
+
+            ParserImpl.prototype.parseConstructorDeclaration = function () {
+                var modifiers = this.parseModifiers();
+                var constructorKeyword = this.eatKeyword(62 /* ConstructorKeyword */);
+                var callSignature = this.parseCallSignature(false);
+
+                var semicolonToken = null;
+                var block = null;
+
+                if (this.isBlock()) {
+                    block = this.parseBlock(false, true);
+                } else {
+                    semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+                }
+
+                return this.factory.constructorDeclaration(modifiers, constructorKeyword, callSignature, block, semicolonToken);
+            };
+
+            ParserImpl.prototype.isMemberFunctionDeclaration = function (inErrorRecovery) {
+                var index = 0;
+
+                while (true) {
+                    var token = this.peekToken(index);
+                    if (this.isPropertyName(token, inErrorRecovery) && this.isCallSignature(index + 1)) {
+                        return true;
+                    }
+
+                    if (ParserImpl.isModifier(token)) {
+                        index++;
+                        continue;
+                    }
+
+                    return false;
+                }
+            };
+
+            ParserImpl.prototype.parseMemberFunctionDeclaration = function () {
+                var modifierArray = this.getArray();
+
+                while (true) {
+                    var currentToken = this.currentToken();
+                    if (this.isPropertyName(currentToken, false) && this.isCallSignature(1)) {
+                        break;
+                    }
+
+                    TypeScript.Debug.assert(ParserImpl.isModifier(currentToken));
+                    modifierArray.push(this.eatAnyToken());
+                }
+
+                var modifiers = TypeScript.Syntax.list(modifierArray);
+                this.returnZeroOrOneLengthArray(modifierArray);
+
+                var propertyName = this.eatPropertyName();
+                var callSignature = this.parseCallSignature(false);
+
+                var parseBlockEvenWithNoOpenBrace = false;
+                var newCallSignature = this.tryAddUnexpectedEqualsGreaterThanToken(callSignature);
+                if (newCallSignature !== callSignature) {
+                    parseBlockEvenWithNoOpenBrace = true;
+                    callSignature = newCallSignature;
+                }
+
+                var block = null;
+                var semicolon = null;
+
+                if (parseBlockEvenWithNoOpenBrace || this.isBlock()) {
+                    block = this.parseBlock(parseBlockEvenWithNoOpenBrace, true);
+                } else {
+                    semicolon = this.eatExplicitOrAutomaticSemicolon(false);
+                }
+
+                return this.factory.memberFunctionDeclaration(modifiers, propertyName, callSignature, block, semicolon);
+            };
+
+            ParserImpl.prototype.isDefinitelyMemberVariablePropertyName = function (index) {
+                if (TypeScript.SyntaxFacts.isAnyKeyword(this.peekToken(index).tokenKind)) {
+                    switch (this.peekToken(index + 1).tokenKind) {
+                        case 78 /* SemicolonToken */:
+                        case 107 /* EqualsToken */:
+                        case 106 /* ColonToken */:
+                        case 71 /* CloseBraceToken */:
+                        case 10 /* EndOfFileToken */:
+                            return true;
+                        default:
+                            return false;
+                    }
+                } else {
+                    return true;
+                }
+            };
+
+            ParserImpl.prototype.isMemberVariableDeclaration = function (inErrorRecovery) {
+                var index = 0;
+
+                while (true) {
+                    var token = this.peekToken(index);
+                    if (this.isPropertyName(token, inErrorRecovery) && this.isDefinitelyMemberVariablePropertyName(index)) {
+                        return true;
+                    }
+
+                    if (ParserImpl.isModifier(this.peekToken(index))) {
+                        index++;
+                        continue;
+                    }
+
+                    return false;
+                }
+            };
+
+            ParserImpl.prototype.parseMemberVariableDeclaration = function () {
+                var modifierArray = this.getArray();
+
+                while (true) {
+                    var currentToken = this.currentToken();
+                    if (this.isPropertyName(currentToken, false) && this.isDefinitelyMemberVariablePropertyName(0)) {
+                        break;
+                    }
+
+                    TypeScript.Debug.assert(ParserImpl.isModifier(currentToken));
+                    modifierArray.push(this.eatAnyToken());
+                }
+
+                var modifiers = TypeScript.Syntax.list(modifierArray);
+                this.returnZeroOrOneLengthArray(modifierArray);
+
+                var variableDeclarator = this.parseVariableDeclarator(true, true);
+                var semicolon = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.memberVariableDeclaration(modifiers, variableDeclarator, semicolon);
+            };
+
+            ParserImpl.prototype.isIndexMemberDeclaration = function () {
+                var index = this.modifierCount();
+                return this.isIndexSignature(index);
+            };
+
+            ParserImpl.prototype.parseIndexMemberDeclaration = function () {
+                var modifiers = this.parseModifiers();
+                var indexSignature = this.parseIndexSignature();
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.indexMemberDeclaration(modifiers, indexSignature, semicolonToken);
+            };
+
+            ParserImpl.prototype.tryAddUnexpectedEqualsGreaterThanToken = function (callSignature) {
+                var token0 = this.currentToken();
+
+                var hasEqualsGreaterThanToken = token0.tokenKind === 85 /* EqualsGreaterThanToken */;
+                if (hasEqualsGreaterThanToken) {
+                    if (callSignature.lastToken()) {
+                        var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token0.width(), TypeScript.DiagnosticCode.Unexpected_token_0_expected, [TypeScript.SyntaxFacts.getText(70 /* OpenBraceToken */)]);
+                        this.addDiagnostic(diagnostic);
+
+                        var token = this.eatAnyToken();
+                        return this.addSkippedTokenAfterNode(callSignature, token0);
+                    }
+                }
+
+                return callSignature;
+            };
+
+            ParserImpl.prototype.isFunctionDeclaration = function () {
+                var index = this.modifierCount();
+                return this.peekToken(index).tokenKind === 27 /* FunctionKeyword */;
+            };
+
+            ParserImpl.prototype.parseFunctionDeclaration = function () {
+                var modifiers = this.parseModifiers();
+                var functionKeyword = this.eatKeyword(27 /* FunctionKeyword */);
+                var identifier = this.eatIdentifierToken();
+                var callSignature = this.parseCallSignature(false);
+
+                var parseBlockEvenWithNoOpenBrace = false;
+                var newCallSignature = this.tryAddUnexpectedEqualsGreaterThanToken(callSignature);
+                if (newCallSignature !== callSignature) {
+                    parseBlockEvenWithNoOpenBrace = true;
+                    callSignature = newCallSignature;
+                }
+
+                var semicolonToken = null;
+                var block = null;
+
+                if (parseBlockEvenWithNoOpenBrace || this.isBlock()) {
+                    block = this.parseBlock(parseBlockEvenWithNoOpenBrace, true);
+                } else {
+                    semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+                }
+
+                return this.factory.functionDeclaration(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken);
+            };
+
+            ParserImpl.prototype.isModuleDeclaration = function (modifierCount) {
+                if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 65 /* ModuleKeyword */) {
+                    return true;
+                }
+
+                if (this.currentToken().tokenKind === 65 /* ModuleKeyword */) {
+                    var token1 = this.peekToken(1);
+                    return this.isIdentifier(token1) || token1.tokenKind === 14 /* StringLiteral */;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.parseModuleDeclaration = function () {
+                var modifiers = this.parseModifiers();
+                var moduleKeyword = this.eatKeyword(65 /* ModuleKeyword */);
+
+                var moduleName = null;
+                var stringLiteral = null;
+
+                if (this.currentToken().tokenKind === 14 /* StringLiteral */) {
+                    stringLiteral = this.eatToken(14 /* StringLiteral */);
+                } else {
+                    moduleName = this.parseName();
+                }
+
+                var openBraceToken = this.eatToken(70 /* OpenBraceToken */);
+
+                var moduleElements = TypeScript.Syntax.emptyList;
+                if (openBraceToken.width() > 0) {
+                    var result = this.parseSyntaxList(4 /* ModuleDeclaration_ModuleElements */);
+                    moduleElements = result.list;
+                    openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens);
+                }
+
+                var closeBraceToken = this.eatToken(71 /* CloseBraceToken */);
+
+                return this.factory.moduleDeclaration(modifiers, moduleKeyword, moduleName, stringLiteral, openBraceToken, moduleElements, closeBraceToken);
+            };
+
+            ParserImpl.prototype.isInterfaceDeclaration = function (modifierCount) {
+                if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 52 /* InterfaceKeyword */) {
+                    return true;
+                }
+
+                return this.currentToken().tokenKind === 52 /* InterfaceKeyword */ && this.isIdentifier(this.peekToken(1));
+            };
+
+            ParserImpl.prototype.parseInterfaceDeclaration = function () {
+                var modifiers = this.parseModifiers();
+                var interfaceKeyword = this.eatKeyword(52 /* InterfaceKeyword */);
+                var identifier = this.eatIdentifierToken();
+                var typeParameterList = this.parseOptionalTypeParameterList(false);
+                var heritageClauses = this.parseHeritageClauses();
+
+                var objectType = this.parseObjectType();
+                return this.factory.interfaceDeclaration(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, objectType);
+            };
+
+            ParserImpl.prototype.parseObjectType = function () {
+                var openBraceToken = this.eatToken(70 /* OpenBraceToken */);
+
+                var typeMembers = TypeScript.Syntax.emptySeparatedList;
+                if (openBraceToken.width() > 0) {
+                    var result = this.parseSeparatedSyntaxList(512 /* ObjectType_TypeMembers */);
+                    typeMembers = result.list;
+                    openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens);
+                }
+
+                var closeBraceToken = this.eatToken(71 /* CloseBraceToken */);
+                return this.factory.objectType(openBraceToken, typeMembers, closeBraceToken);
+            };
+
+            ParserImpl.prototype.isTypeMember = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isTypeMember()) {
+                    return true;
+                }
+
+                return this.isCallSignature(0) || this.isConstructSignature() || this.isIndexSignature(0) || this.isMethodSignature(inErrorRecovery) || this.isPropertySignature(inErrorRecovery);
+            };
+
+            ParserImpl.prototype.parseTypeMember = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isTypeMember()) {
+                    return this.eatNode();
+                }
+
+                if (this.isCallSignature(0)) {
+                    return this.parseCallSignature(false);
+                } else if (this.isConstructSignature()) {
+                    return this.parseConstructSignature();
+                } else if (this.isIndexSignature(0)) {
+                    return this.parseIndexSignature();
+                } else if (this.isMethodSignature(inErrorRecovery)) {
+                    return this.parseMethodSignature();
+                } else if (this.isPropertySignature(inErrorRecovery)) {
+                    return this.parsePropertySignature();
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.parseConstructSignature = function () {
+                var newKeyword = this.eatKeyword(31 /* NewKeyword */);
+                var callSignature = this.parseCallSignature(false);
+
+                return this.factory.constructSignature(newKeyword, callSignature);
+            };
+
+            ParserImpl.prototype.parseIndexSignature = function () {
+                var openBracketToken = this.eatToken(74 /* OpenBracketToken */);
+                var parameter = this.parseParameter();
+                var closeBracketToken = this.eatToken(75 /* CloseBracketToken */);
+                var typeAnnotation = this.parseOptionalTypeAnnotation(false);
+
+                return this.factory.indexSignature(openBracketToken, parameter, closeBracketToken, typeAnnotation);
+            };
+
+            ParserImpl.prototype.parseMethodSignature = function () {
+                var propertyName = this.eatPropertyName();
+                var questionToken = this.tryEatToken(105 /* QuestionToken */);
+                var callSignature = this.parseCallSignature(false);
+
+                return this.factory.methodSignature(propertyName, questionToken, callSignature);
+            };
+
+            ParserImpl.prototype.parsePropertySignature = function () {
+                var propertyName = this.eatPropertyName();
+                var questionToken = this.tryEatToken(105 /* QuestionToken */);
+                var typeAnnotation = this.parseOptionalTypeAnnotation(false);
+
+                return this.factory.propertySignature(propertyName, questionToken, typeAnnotation);
+            };
+
+            ParserImpl.prototype.isCallSignature = function (tokenIndex) {
+                var tokenKind = this.peekToken(tokenIndex).tokenKind;
+                return tokenKind === 72 /* OpenParenToken */ || tokenKind === 80 /* LessThanToken */;
+            };
+
+            ParserImpl.prototype.isConstructSignature = function () {
+                if (this.currentToken().tokenKind !== 31 /* NewKeyword */) {
+                    return false;
+                }
+
+                var token1 = this.peekToken(1);
+                return token1.tokenKind === 80 /* LessThanToken */ || token1.tokenKind === 72 /* OpenParenToken */;
+            };
+
+            ParserImpl.prototype.isIndexSignature = function (tokenIndex) {
+                return this.peekToken(tokenIndex).tokenKind === 74 /* OpenBracketToken */;
+            };
+
+            ParserImpl.prototype.isMethodSignature = function (inErrorRecovery) {
+                if (this.isPropertyName(this.currentToken(), inErrorRecovery)) {
+                    if (this.isCallSignature(1)) {
+                        return true;
+                    }
+
+                    if (this.peekToken(1).tokenKind === 105 /* QuestionToken */ && this.isCallSignature(2)) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isPropertySignature = function (inErrorRecovery) {
+                var currentToken = this.currentToken();
+
+                if (ParserImpl.isModifier(currentToken) && !currentToken.hasTrailingNewLine() && this.isPropertyName(this.peekToken(1), inErrorRecovery)) {
+                    return false;
+                }
+
+                return this.isPropertyName(currentToken, inErrorRecovery);
+            };
+
+            ParserImpl.prototype.isHeritageClause = function () {
+                var token0 = this.currentToken();
+                return token0.tokenKind === 48 /* ExtendsKeyword */ || token0.tokenKind === 51 /* ImplementsKeyword */;
+            };
+
+            ParserImpl.prototype.isNotHeritageClauseTypeName = function () {
+                if (this.currentToken().tokenKind === 51 /* ImplementsKeyword */ || this.currentToken().tokenKind === 48 /* ExtendsKeyword */) {
+                    return this.isIdentifier(this.peekToken(1));
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isHeritageClauseTypeName = function () {
+                if (this.isIdentifier(this.currentToken())) {
+                    return !this.isNotHeritageClauseTypeName();
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.parseHeritageClause = function () {
+                var extendsOrImplementsKeyword = this.eatAnyToken();
+                TypeScript.Debug.assert(extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */ || extendsOrImplementsKeyword.tokenKind === 51 /* ImplementsKeyword */);
+
+                var result = this.parseSeparatedSyntaxList(2048 /* HeritageClause_TypeNameList */);
+                var typeNames = result.list;
+                extendsOrImplementsKeyword = this.addSkippedTokensAfterToken(extendsOrImplementsKeyword, result.skippedTokens);
+
+                return this.factory.heritageClause(extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */ ? 230 /* ExtendsHeritageClause */ : 231 /* ImplementsHeritageClause */, extendsOrImplementsKeyword, typeNames);
+            };
+
+            ParserImpl.prototype.isStatement = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isStatement()) {
+                    return true;
+                }
+
+                var currentToken = this.currentToken();
+                var currentTokenKind = currentToken.tokenKind;
+                switch (currentTokenKind) {
+                    case 57 /* PublicKeyword */:
+                    case 55 /* PrivateKeyword */:
+                    case 58 /* StaticKeyword */:
+                        var token1 = this.peekToken(1);
+                        if (TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token1)) {
+                            return false;
+                        }
+
+                        break;
+
+                    case 28 /* IfKeyword */:
+                    case 70 /* OpenBraceToken */:
+                    case 33 /* ReturnKeyword */:
+                    case 34 /* SwitchKeyword */:
+                    case 36 /* ThrowKeyword */:
+                    case 15 /* BreakKeyword */:
+                    case 18 /* ContinueKeyword */:
+                    case 26 /* ForKeyword */:
+                    case 42 /* WhileKeyword */:
+                    case 43 /* WithKeyword */:
+                    case 22 /* DoKeyword */:
+                    case 38 /* TryKeyword */:
+                    case 19 /* DebuggerKeyword */:
+                        return true;
+                }
+
+                if (this.isInterfaceDeclaration(0) || this.isClassDeclaration(0) || this.isEnumDeclaration(0) || this.isModuleDeclaration(0)) {
+                    return false;
+                }
+
+                return this.isLabeledStatement(currentToken) || this.isVariableStatement() || this.isFunctionDeclaration() || this.isEmptyStatement(currentToken, inErrorRecovery) || this.isExpressionStatement(currentToken);
+            };
+
+            ParserImpl.prototype.parseStatement = function (inErrorRecovery) {
+                if (this.currentNode() !== null && this.currentNode().isStatement()) {
+                    return this.eatNode();
+                }
+
+                var currentToken = this.currentToken();
+                var currentTokenKind = currentToken.tokenKind;
+
+                switch (currentTokenKind) {
+                    case 28 /* IfKeyword */:
+                        return this.parseIfStatement();
+                    case 70 /* OpenBraceToken */:
+                        return this.parseBlock(false, false);
+                    case 33 /* ReturnKeyword */:
+                        return this.parseReturnStatement();
+                    case 34 /* SwitchKeyword */:
+                        return this.parseSwitchStatement();
+                    case 36 /* ThrowKeyword */:
+                        return this.parseThrowStatement();
+                    case 15 /* BreakKeyword */:
+                        return this.parseBreakStatement();
+                    case 18 /* ContinueKeyword */:
+                        return this.parseContinueStatement();
+                    case 26 /* ForKeyword */:
+                        return this.parseForOrForInStatement();
+                    case 42 /* WhileKeyword */:
+                        return this.parseWhileStatement();
+                    case 43 /* WithKeyword */:
+                        return this.parseWithStatement();
+                    case 22 /* DoKeyword */:
+                        return this.parseDoStatement();
+                    case 38 /* TryKeyword */:
+                        return this.parseTryStatement();
+                    case 19 /* DebuggerKeyword */:
+                        return this.parseDebuggerStatement();
+                }
+
+                if (this.isVariableStatement()) {
+                    return this.parseVariableStatement();
+                } else if (this.isLabeledStatement(currentToken)) {
+                    return this.parseLabeledStatement();
+                } else if (this.isFunctionDeclaration()) {
+                    return this.parseFunctionDeclaration();
+                } else if (this.isEmptyStatement(currentToken, inErrorRecovery)) {
+                    return this.parseEmptyStatement();
+                } else {
+                    return this.parseExpressionStatement();
+                }
+            };
+
+            ParserImpl.prototype.parseDebuggerStatement = function () {
+                var debuggerKeyword = this.eatKeyword(19 /* DebuggerKeyword */);
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.debuggerStatement(debuggerKeyword, semicolonToken);
+            };
+
+            ParserImpl.prototype.parseDoStatement = function () {
+                var doKeyword = this.eatKeyword(22 /* DoKeyword */);
+                var statement = this.parseStatement(false);
+                var whileKeyword = this.eatKeyword(42 /* WhileKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var condition = this.parseExpression(true);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(true);
+
+                return this.factory.doStatement(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken);
+            };
+
+            ParserImpl.prototype.isLabeledStatement = function (currentToken) {
+                return this.isIdentifier(currentToken) && this.peekToken(1).tokenKind === 106 /* ColonToken */;
+            };
+
+            ParserImpl.prototype.parseLabeledStatement = function () {
+                var identifier = this.eatIdentifierToken();
+                var colonToken = this.eatToken(106 /* ColonToken */);
+                var statement = this.parseStatement(false);
+
+                return this.factory.labeledStatement(identifier, colonToken, statement);
+            };
+
+            ParserImpl.prototype.parseTryStatement = function () {
+                var tryKeyword = this.eatKeyword(38 /* TryKeyword */);
+
+                var savedListParsingState = this.listParsingState;
+                this.listParsingState |= 64 /* TryBlock_Statements */;
+                var block = this.parseBlock(false, false);
+                this.listParsingState = savedListParsingState;
+
+                var catchClause = null;
+                if (this.isCatchClause()) {
+                    catchClause = this.parseCatchClause();
+                }
+
+                var finallyClause = null;
+                if (catchClause === null || this.isFinallyClause()) {
+                    finallyClause = this.parseFinallyClause();
+                }
+
+                return this.factory.tryStatement(tryKeyword, block, catchClause, finallyClause);
+            };
+
+            ParserImpl.prototype.isCatchClause = function () {
+                return this.currentToken().tokenKind === 17 /* CatchKeyword */;
+            };
+
+            ParserImpl.prototype.parseCatchClause = function () {
+                var catchKeyword = this.eatKeyword(17 /* CatchKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var identifier = this.eatIdentifierToken();
+                var typeAnnotation = this.parseOptionalTypeAnnotation(false);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+
+                var savedListParsingState = this.listParsingState;
+                this.listParsingState |= 128 /* CatchBlock_Statements */;
+                var block = this.parseBlock(false, false);
+                this.listParsingState = savedListParsingState;
+
+                return this.factory.catchClause(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block);
+            };
+
+            ParserImpl.prototype.isFinallyClause = function () {
+                return this.currentToken().tokenKind === 25 /* FinallyKeyword */;
+            };
+
+            ParserImpl.prototype.parseFinallyClause = function () {
+                var finallyKeyword = this.eatKeyword(25 /* FinallyKeyword */);
+                var block = this.parseBlock(false, false);
+
+                return this.factory.finallyClause(finallyKeyword, block);
+            };
+
+            ParserImpl.prototype.parseWithStatement = function () {
+                var withKeyword = this.eatKeyword(43 /* WithKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var condition = this.parseExpression(true);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+                var statement = this.parseStatement(false);
+
+                return this.factory.withStatement(withKeyword, openParenToken, condition, closeParenToken, statement);
+            };
+
+            ParserImpl.prototype.parseWhileStatement = function () {
+                var whileKeyword = this.eatKeyword(42 /* WhileKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var condition = this.parseExpression(true);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+                var statement = this.parseStatement(false);
+
+                return this.factory.whileStatement(whileKeyword, openParenToken, condition, closeParenToken, statement);
+            };
+
+            ParserImpl.prototype.isEmptyStatement = function (currentToken, inErrorRecovery) {
+                if (inErrorRecovery) {
+                    return false;
+                }
+
+                return currentToken.tokenKind === 78 /* SemicolonToken */;
+            };
+
+            ParserImpl.prototype.parseEmptyStatement = function () {
+                var semicolonToken = this.eatToken(78 /* SemicolonToken */);
+                return this.factory.emptyStatement(semicolonToken);
+            };
+
+            ParserImpl.prototype.parseForOrForInStatement = function () {
+                var forKeyword = this.eatKeyword(26 /* ForKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+
+                var currentToken = this.currentToken();
+                if (currentToken.tokenKind === 40 /* VarKeyword */) {
+                    return this.parseForOrForInStatementWithVariableDeclaration(forKeyword, openParenToken);
+                } else if (currentToken.tokenKind === 78 /* SemicolonToken */) {
+                    return this.parseForStatementWithNoVariableDeclarationOrInitializer(forKeyword, openParenToken);
+                } else {
+                    return this.parseForOrForInStatementWithInitializer(forKeyword, openParenToken);
+                }
+            };
+
+            ParserImpl.prototype.parseForOrForInStatementWithVariableDeclaration = function (forKeyword, openParenToken) {
+                var variableDeclaration = this.parseVariableDeclaration(false);
+
+                if (this.currentToken().tokenKind === 29 /* InKeyword */) {
+                    return this.parseForInStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, variableDeclaration, null);
+                }
+
+                return this.parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, variableDeclaration, null);
+            };
+
+            ParserImpl.prototype.parseForInStatementWithVariableDeclarationOrInitializer = function (forKeyword, openParenToken, variableDeclaration, initializer) {
+                var inKeyword = this.eatKeyword(29 /* InKeyword */);
+                var expression = this.parseExpression(true);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+                var statement = this.parseStatement(false);
+
+                return this.factory.forInStatement(forKeyword, openParenToken, variableDeclaration, initializer, inKeyword, expression, closeParenToken, statement);
+            };
+
+            ParserImpl.prototype.parseForOrForInStatementWithInitializer = function (forKeyword, openParenToken) {
+                var initializer = this.parseExpression(false);
+                if (this.currentToken().tokenKind === 29 /* InKeyword */) {
+                    return this.parseForInStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, null, initializer);
+                } else {
+                    return this.parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, null, initializer);
+                }
+            };
+
+            ParserImpl.prototype.parseForStatementWithNoVariableDeclarationOrInitializer = function (forKeyword, openParenToken) {
+                return this.parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, null, null);
+            };
+
+            ParserImpl.prototype.parseForStatementWithVariableDeclarationOrInitializer = function (forKeyword, openParenToken, variableDeclaration, initializer) {
+                var firstSemicolonToken = this.eatToken(78 /* SemicolonToken */);
+
+                var condition = null;
+                if (this.currentToken().tokenKind !== 78 /* SemicolonToken */ && this.currentToken().tokenKind !== 73 /* CloseParenToken */ && this.currentToken().tokenKind !== 10 /* EndOfFileToken */) {
+                    condition = this.parseExpression(true);
+                }
+
+                var secondSemicolonToken = this.eatToken(78 /* SemicolonToken */);
+
+                var incrementor = null;
+                if (this.currentToken().tokenKind !== 73 /* CloseParenToken */ && this.currentToken().tokenKind !== 10 /* EndOfFileToken */) {
+                    incrementor = this.parseExpression(true);
+                }
+
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+                var statement = this.parseStatement(false);
+
+                return this.factory.forStatement(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement);
+            };
+
+            ParserImpl.prototype.parseBreakStatement = function () {
+                var breakKeyword = this.eatKeyword(15 /* BreakKeyword */);
+
+                var identifier = null;
+                if (!this.canEatExplicitOrAutomaticSemicolon(false)) {
+                    if (this.isIdentifier(this.currentToken())) {
+                        identifier = this.eatIdentifierToken();
+                    }
+                }
+
+                var semicolon = this.eatExplicitOrAutomaticSemicolon(false);
+                return this.factory.breakStatement(breakKeyword, identifier, semicolon);
+            };
+
+            ParserImpl.prototype.parseContinueStatement = function () {
+                var continueKeyword = this.eatKeyword(18 /* ContinueKeyword */);
+
+                var identifier = null;
+                if (!this.canEatExplicitOrAutomaticSemicolon(false)) {
+                    if (this.isIdentifier(this.currentToken())) {
+                        identifier = this.eatIdentifierToken();
+                    }
+                }
+
+                var semicolon = this.eatExplicitOrAutomaticSemicolon(false);
+                return this.factory.continueStatement(continueKeyword, identifier, semicolon);
+            };
+
+            ParserImpl.prototype.parseSwitchStatement = function () {
+                var switchKeyword = this.eatKeyword(34 /* SwitchKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var expression = this.parseExpression(true);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+
+                var openBraceToken = this.eatToken(70 /* OpenBraceToken */);
+
+                var switchClauses = TypeScript.Syntax.emptyList;
+                if (openBraceToken.width() > 0) {
+                    var result = this.parseSyntaxList(8 /* SwitchStatement_SwitchClauses */);
+                    switchClauses = result.list;
+                    openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens);
+                }
+
+                var closeBraceToken = this.eatToken(71 /* CloseBraceToken */);
+                return this.factory.switchStatement(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken);
+            };
+
+            ParserImpl.prototype.isCaseSwitchClause = function () {
+                return this.currentToken().tokenKind === 16 /* CaseKeyword */;
+            };
+
+            ParserImpl.prototype.isDefaultSwitchClause = function () {
+                return this.currentToken().tokenKind === 20 /* DefaultKeyword */;
+            };
+
+            ParserImpl.prototype.isSwitchClause = function () {
+                if (this.currentNode() !== null && this.currentNode().isSwitchClause()) {
+                    return true;
+                }
+
+                return this.isCaseSwitchClause() || this.isDefaultSwitchClause();
+            };
+
+            ParserImpl.prototype.parseSwitchClause = function () {
+                if (this.currentNode() !== null && this.currentNode().isSwitchClause()) {
+                    return this.eatNode();
+                }
+
+                if (this.isCaseSwitchClause()) {
+                    return this.parseCaseSwitchClause();
+                } else if (this.isDefaultSwitchClause()) {
+                    return this.parseDefaultSwitchClause();
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.parseCaseSwitchClause = function () {
+                var caseKeyword = this.eatKeyword(16 /* CaseKeyword */);
+                var expression = this.parseExpression(true);
+                var colonToken = this.eatToken(106 /* ColonToken */);
+                var statements = TypeScript.Syntax.emptyList;
+
+                if (colonToken.fullWidth() > 0) {
+                    var result = this.parseSyntaxList(16 /* SwitchClause_Statements */);
+                    statements = result.list;
+                    colonToken = this.addSkippedTokensAfterToken(colonToken, result.skippedTokens);
+                }
+
+                return this.factory.caseSwitchClause(caseKeyword, expression, colonToken, statements);
+            };
+
+            ParserImpl.prototype.parseDefaultSwitchClause = function () {
+                var defaultKeyword = this.eatKeyword(20 /* DefaultKeyword */);
+                var colonToken = this.eatToken(106 /* ColonToken */);
+                var statements = TypeScript.Syntax.emptyList;
+
+                if (colonToken.fullWidth() > 0) {
+                    var result = this.parseSyntaxList(16 /* SwitchClause_Statements */);
+                    statements = result.list;
+                    colonToken = this.addSkippedTokensAfterToken(colonToken, result.skippedTokens);
+                }
+
+                return this.factory.defaultSwitchClause(defaultKeyword, colonToken, statements);
+            };
+
+            ParserImpl.prototype.parseThrowStatement = function () {
+                var throwKeyword = this.eatKeyword(36 /* ThrowKeyword */);
+
+                var expression = null;
+                if (this.canEatExplicitOrAutomaticSemicolon(false)) {
+                    var token = this.createMissingToken(11 /* IdentifierName */, null);
+                    expression = token;
+                } else {
+                    expression = this.parseExpression(true);
+                }
+
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.throwStatement(throwKeyword, expression, semicolonToken);
+            };
+
+            ParserImpl.prototype.parseReturnStatement = function () {
+                var returnKeyword = this.eatKeyword(33 /* ReturnKeyword */);
+
+                var expression = null;
+                if (!this.canEatExplicitOrAutomaticSemicolon(false)) {
+                    expression = this.parseExpression(true);
+                }
+
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.returnStatement(returnKeyword, expression, semicolonToken);
+            };
+
+            ParserImpl.prototype.isExpressionStatement = function (currentToken) {
+                var kind = currentToken.tokenKind;
+                if (kind === 70 /* OpenBraceToken */ || kind === 27 /* FunctionKeyword */) {
+                    return false;
+                }
+
+                return this.isExpression(currentToken);
+            };
+
+            ParserImpl.prototype.isAssignmentOrOmittedExpression = function () {
+                var currentToken = this.currentToken();
+                if (currentToken.tokenKind === 79 /* CommaToken */) {
+                    return true;
+                }
+
+                return this.isExpression(currentToken);
+            };
+
+            ParserImpl.prototype.parseAssignmentOrOmittedExpression = function () {
+                if (this.currentToken().tokenKind === 79 /* CommaToken */) {
+                    return this.factory.omittedExpression();
+                }
+
+                return this.parseAssignmentExpression(true);
+            };
+
+            ParserImpl.prototype.isExpression = function (currentToken) {
+                switch (currentToken.tokenKind) {
+                    case 13 /* NumericLiteral */:
+                    case 14 /* StringLiteral */:
+                    case 12 /* RegularExpressionLiteral */:
+
+                    case 74 /* OpenBracketToken */:
+
+                    case 72 /* OpenParenToken */:
+
+                    case 80 /* LessThanToken */:
+
+                    case 93 /* PlusPlusToken */:
+                    case 94 /* MinusMinusToken */:
+                    case 89 /* PlusToken */:
+                    case 90 /* MinusToken */:
+                    case 102 /* TildeToken */:
+                    case 101 /* ExclamationToken */:
+
+                    case 70 /* OpenBraceToken */:
+
+                    case 85 /* EqualsGreaterThanToken */:
+
+                    case 118 /* SlashToken */:
+                    case 119 /* SlashEqualsToken */:
+
+                    case 50 /* SuperKeyword */:
+                    case 35 /* ThisKeyword */:
+                    case 37 /* TrueKeyword */:
+                    case 24 /* FalseKeyword */:
+                    case 32 /* NullKeyword */:
+
+                    case 31 /* NewKeyword */:
+
+                    case 21 /* DeleteKeyword */:
+                    case 41 /* VoidKeyword */:
+                    case 39 /* TypeOfKeyword */:
+
+                    case 27 /* FunctionKeyword */:
+                        return true;
+                }
+
+                return this.isIdentifier(currentToken);
+            };
+
+            ParserImpl.prototype.parseExpressionStatement = function () {
+                var expression = this.parseExpression(true);
+
+                var semicolon = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.expressionStatement(expression, semicolon);
+            };
+
+            ParserImpl.prototype.parseIfStatement = function () {
+                var ifKeyword = this.eatKeyword(28 /* IfKeyword */);
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var condition = this.parseExpression(true);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+                var statement = this.parseStatement(false);
+
+                var elseClause = null;
+                if (this.isElseClause()) {
+                    elseClause = this.parseElseClause();
+                }
+
+                return this.factory.ifStatement(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause);
+            };
+
+            ParserImpl.prototype.isElseClause = function () {
+                return this.currentToken().tokenKind === 23 /* ElseKeyword */;
+            };
+
+            ParserImpl.prototype.parseElseClause = function () {
+                var elseKeyword = this.eatKeyword(23 /* ElseKeyword */);
+                var statement = this.parseStatement(false);
+
+                return this.factory.elseClause(elseKeyword, statement);
+            };
+
+            ParserImpl.prototype.isVariableStatement = function () {
+                var index = this.modifierCount();
+                return this.peekToken(index).tokenKind === 40 /* VarKeyword */;
+            };
+
+            ParserImpl.prototype.parseVariableStatement = function () {
+                var modifiers = this.parseModifiers();
+                var variableDeclaration = this.parseVariableDeclaration(true);
+                var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false);
+
+                return this.factory.variableStatement(modifiers, variableDeclaration, semicolonToken);
+            };
+
+            ParserImpl.prototype.parseVariableDeclaration = function (allowIn) {
+                var varKeyword = this.eatKeyword(40 /* VarKeyword */);
+
+                var listParsingState = allowIn ? 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */ : 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */;
+
+                var result = this.parseSeparatedSyntaxList(listParsingState);
+                var variableDeclarators = result.list;
+                varKeyword = this.addSkippedTokensAfterToken(varKeyword, result.skippedTokens);
+
+                return this.factory.variableDeclaration(varKeyword, variableDeclarators);
+            };
+
+            ParserImpl.prototype.isVariableDeclarator = function () {
+                if (this.currentNode() !== null && this.currentNode().kind() === 225 /* VariableDeclarator */) {
+                    return true;
+                }
+
+                return this.isIdentifier(this.currentToken());
+            };
+
+            ParserImpl.prototype.canReuseVariableDeclaratorNode = function (node) {
+                if (node === null || node.kind() !== 225 /* VariableDeclarator */) {
+                    return false;
+                }
+
+                var variableDeclarator = node;
+                return variableDeclarator.equalsValueClause === null;
+            };
+
+            ParserImpl.prototype.parseVariableDeclarator = function (allowIn, allowPropertyName) {
+                if (this.canReuseVariableDeclaratorNode(this.currentNode())) {
+                    return this.eatNode();
+                }
+
+                var propertyName = allowPropertyName ? this.eatPropertyName() : this.eatIdentifierToken();
+                var equalsValueClause = null;
+                var typeAnnotation = null;
+
+                if (propertyName.width() > 0) {
+                    typeAnnotation = this.parseOptionalTypeAnnotation(false);
+
+                    if (this.isEqualsValueClause(false)) {
+                        equalsValueClause = this.parseEqualsValueClause(allowIn);
+                    }
+                }
+
+                return this.factory.variableDeclarator(propertyName, typeAnnotation, equalsValueClause);
+            };
+
+            ParserImpl.prototype.isColonValueClause = function () {
+                return this.currentToken().tokenKind === 106 /* ColonToken */;
+            };
+
+            ParserImpl.prototype.isEqualsValueClause = function (inParameter) {
+                var token0 = this.currentToken();
+                if (token0.tokenKind === 107 /* EqualsToken */) {
+                    return true;
+                }
+
+                if (!this.previousToken().hasTrailingNewLine()) {
+                    if (token0.tokenKind === 85 /* EqualsGreaterThanToken */) {
+                        return false;
+                    }
+
+                    if (token0.tokenKind === 70 /* OpenBraceToken */ && inParameter) {
+                        return false;
+                    }
+
+                    return this.isExpression(token0);
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.parseEqualsValueClause = function (allowIn) {
+                var equalsToken = this.eatToken(107 /* EqualsToken */);
+                var value = this.parseAssignmentExpression(allowIn);
+
+                return this.factory.equalsValueClause(equalsToken, value);
+            };
+
+            ParserImpl.prototype.parseExpression = function (allowIn) {
+                return this.parseSubExpression(0, allowIn);
+            };
+
+            ParserImpl.prototype.parseAssignmentExpression = function (allowIn) {
+                return this.parseSubExpression(2 /* AssignmentExpressionPrecedence */, allowIn);
+            };
+
+            ParserImpl.prototype.parseUnaryExpressionOrLower = function () {
+                var currentTokenKind = this.currentToken().tokenKind;
+                if (TypeScript.SyntaxFacts.isPrefixUnaryExpressionOperatorToken(currentTokenKind)) {
+                    var operatorKind = TypeScript.SyntaxFacts.getPrefixUnaryExpressionFromOperatorToken(currentTokenKind);
+
+                    var operatorToken = this.eatAnyToken();
+
+                    var operand = this.parseUnaryExpressionOrLower();
+                    return this.factory.prefixUnaryExpression(operatorKind, operatorToken, operand);
+                } else if (currentTokenKind === 39 /* TypeOfKeyword */) {
+                    return this.parseTypeOfExpression();
+                } else if (currentTokenKind === 41 /* VoidKeyword */) {
+                    return this.parseVoidExpression();
+                } else if (currentTokenKind === 21 /* DeleteKeyword */) {
+                    return this.parseDeleteExpression();
+                } else if (currentTokenKind === 80 /* LessThanToken */) {
+                    return this.parseCastExpression();
+                } else {
+                    return this.parsePostfixExpressionOrLower();
+                }
+            };
+
+            ParserImpl.prototype.parseSubExpression = function (precedence, allowIn) {
+                if (precedence <= 2 /* AssignmentExpressionPrecedence */) {
+                    if (this.isSimpleArrowFunctionExpression()) {
+                        return this.parseSimpleArrowFunctionExpression();
+                    }
+
+                    var parethesizedArrowFunction = this.tryParseParenthesizedArrowFunctionExpression();
+                    if (parethesizedArrowFunction !== null) {
+                        return parethesizedArrowFunction;
+                    }
+                }
+
+                var leftOperand = this.parseUnaryExpressionOrLower();
+                return this.parseBinaryOrConditionalExpressions(precedence, allowIn, leftOperand);
+            };
+
+            ParserImpl.prototype.parseBinaryOrConditionalExpressions = function (precedence, allowIn, leftOperand) {
+                while (true) {
+                    var token0 = this.currentToken();
+                    var token0Kind = token0.tokenKind;
+
+                    if (TypeScript.SyntaxFacts.isBinaryExpressionOperatorToken(token0Kind)) {
+                        if (token0Kind === 29 /* InKeyword */ && !allowIn) {
+                            break;
+                        }
+
+                        var mergedToken = this.tryMergeBinaryExpressionTokens();
+                        var tokenKind = mergedToken === null ? token0Kind : mergedToken.syntaxKind;
+
+                        var binaryExpressionKind = TypeScript.SyntaxFacts.getBinaryExpressionFromOperatorToken(tokenKind);
+                        var newPrecedence = ParserImpl.getPrecedence(binaryExpressionKind);
+
+                        if (newPrecedence < precedence) {
+                            break;
+                        }
+
+                        if (newPrecedence === precedence && !this.isRightAssociative(binaryExpressionKind)) {
+                            break;
+                        }
+
+                        var operatorToken = mergedToken === null ? token0 : TypeScript.Syntax.token(mergedToken.syntaxKind).withLeadingTrivia(token0.leadingTrivia()).withTrailingTrivia(this.peekToken(mergedToken.tokenCount - 1).trailingTrivia());
+
+                        var skipCount = mergedToken === null ? 1 : mergedToken.tokenCount;
+                        for (var i = 0; i < skipCount; i++) {
+                            this.eatAnyToken();
+                        }
+
+                        leftOperand = this.factory.binaryExpression(binaryExpressionKind, leftOperand, operatorToken, this.parseSubExpression(newPrecedence, allowIn));
+                        continue;
+                    }
+
+                    if (token0Kind === 105 /* QuestionToken */ && precedence <= 3 /* ConditionalExpressionPrecedence */) {
+                        var questionToken = this.eatToken(105 /* QuestionToken */);
+
+                        var whenTrueExpression = this.parseAssignmentExpression(allowIn);
+                        var colon = this.eatToken(106 /* ColonToken */);
+
+                        var whenFalseExpression = this.parseAssignmentExpression(allowIn);
+                        leftOperand = this.factory.conditionalExpression(leftOperand, questionToken, whenTrueExpression, colon, whenFalseExpression);
+                        continue;
+                    }
+
+                    break;
+                }
+
+                return leftOperand;
+            };
+
+            ParserImpl.prototype.tryMergeBinaryExpressionTokens = function () {
+                var token0 = this.currentToken();
+
+                if (token0.tokenKind === 81 /* GreaterThanToken */ && !token0.hasTrailingTrivia()) {
+                    var storage = this.mergeTokensStorage;
+                    storage[0] = 0 /* None */;
+                    storage[1] = 0 /* None */;
+                    storage[2] = 0 /* None */;
+
+                    for (var i = 0; i < storage.length; i++) {
+                        var nextToken = this.peekToken(i + 1);
+
+                        if (!nextToken.hasLeadingTrivia()) {
+                            storage[i] = nextToken.tokenKind;
+                        }
+
+                        if (nextToken.hasTrailingTrivia()) {
+                            break;
+                        }
+                    }
+
+                    if (storage[0] === 81 /* GreaterThanToken */) {
+                        if (storage[1] === 81 /* GreaterThanToken */) {
+                            if (storage[2] === 107 /* EqualsToken */) {
+                                return { tokenCount: 4, syntaxKind: 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */ };
+                            } else {
+                                return { tokenCount: 3, syntaxKind: 97 /* GreaterThanGreaterThanGreaterThanToken */ };
+                            }
+                        } else if (storage[1] === 107 /* EqualsToken */) {
+                            return { tokenCount: 3, syntaxKind: 113 /* GreaterThanGreaterThanEqualsToken */ };
+                        } else {
+                            return { tokenCount: 2, syntaxKind: 96 /* GreaterThanGreaterThanToken */ };
+                        }
+                    } else if (storage[0] === 107 /* EqualsToken */) {
+                        return { tokenCount: 2, syntaxKind: 83 /* GreaterThanEqualsToken */ };
+                    }
+                }
+
+                return null;
+            };
+
+            ParserImpl.prototype.isRightAssociative = function (expressionKind) {
+                switch (expressionKind) {
+                    case 174 /* AssignmentExpression */:
+                    case 175 /* AddAssignmentExpression */:
+                    case 176 /* SubtractAssignmentExpression */:
+                    case 177 /* MultiplyAssignmentExpression */:
+                    case 178 /* DivideAssignmentExpression */:
+                    case 179 /* ModuloAssignmentExpression */:
+                    case 180 /* AndAssignmentExpression */:
+                    case 181 /* ExclusiveOrAssignmentExpression */:
+                    case 182 /* OrAssignmentExpression */:
+                    case 183 /* LeftShiftAssignmentExpression */:
+                    case 184 /* SignedRightShiftAssignmentExpression */:
+                    case 185 /* UnsignedRightShiftAssignmentExpression */:
+                        return true;
+                    default:
+                        return false;
+                }
+            };
+
+            ParserImpl.prototype.parseMemberExpressionOrLower = function (inObjectCreation) {
+                if (this.currentToken().tokenKind === 31 /* NewKeyword */) {
+                    return this.parseObjectCreationExpression();
+                }
+
+                var expression = this.parsePrimaryExpression();
+                if (expression === null) {
+                    return this.eatIdentifierToken();
+                }
+
+                return this.parseMemberExpressionRest(expression, false, inObjectCreation);
+            };
+
+            ParserImpl.prototype.parseCallExpressionOrLower = function () {
+                var expression;
+                if (this.currentToken().tokenKind === 50 /* SuperKeyword */) {
+                    expression = this.eatKeyword(50 /* SuperKeyword */);
+
+                    var currentTokenKind = this.currentToken().tokenKind;
+                    if (currentTokenKind !== 72 /* OpenParenToken */ && currentTokenKind !== 76 /* DotToken */) {
+                        expression = this.factory.memberAccessExpression(expression, this.eatToken(76 /* DotToken */), this.eatIdentifierNameToken());
+                    }
+                } else {
+                    expression = this.parseMemberExpressionOrLower(false);
+                }
+
+                return this.parseMemberExpressionRest(expression, true, false);
+            };
+
+            ParserImpl.prototype.parseMemberExpressionRest = function (expression, allowArguments, inObjectCreation) {
+                while (true) {
+                    var currentTokenKind = this.currentToken().tokenKind;
+
+                    switch (currentTokenKind) {
+                        case 72 /* OpenParenToken */:
+                            if (!allowArguments) {
+                                return expression;
+                            }
+
+                            expression = this.factory.invocationExpression(expression, this.parseArgumentList(null));
+                            continue;
+
+                        case 80 /* LessThanToken */:
+                            if (!allowArguments) {
+                                return expression;
+                            }
+
+                            var argumentList = this.tryParseArgumentList();
+                            if (argumentList !== null) {
+                                expression = this.factory.invocationExpression(expression, argumentList);
+                                continue;
+                            }
+
+                            break;
+
+                        case 74 /* OpenBracketToken */:
+                            expression = this.parseElementAccessExpression(expression, inObjectCreation);
+                            continue;
+
+                        case 76 /* DotToken */:
+                            expression = this.factory.memberAccessExpression(expression, this.eatToken(76 /* DotToken */), this.eatIdentifierNameToken());
+                            continue;
+                    }
+
+                    return expression;
+                }
+            };
+
+            ParserImpl.prototype.parseLeftHandSideExpressionOrLower = function () {
+                if (this.currentToken().tokenKind === 31 /* NewKeyword */) {
+                    return this.parseObjectCreationExpression();
+                } else {
+                    return this.parseCallExpressionOrLower();
+                }
+            };
+
+            ParserImpl.prototype.parsePostfixExpressionOrLower = function () {
+                var expression = this.parseLeftHandSideExpressionOrLower();
+                if (expression === null) {
+                    return this.eatIdentifierToken();
+                }
+
+                var currentTokenKind = this.currentToken().tokenKind;
+
+                switch (currentTokenKind) {
+                    case 93 /* PlusPlusToken */:
+                    case 94 /* MinusMinusToken */:
+                        if (this.previousToken() !== null && this.previousToken().hasTrailingNewLine()) {
+                            break;
+                        }
+
+                        return this.factory.postfixUnaryExpression(TypeScript.SyntaxFacts.getPostfixUnaryExpressionFromOperatorToken(currentTokenKind), expression, this.eatAnyToken());
+                }
+
+                return expression;
+            };
+
+            ParserImpl.prototype.tryParseGenericArgumentList = function () {
+                var rewindPoint = this.getRewindPoint();
+
+                var typeArgumentList = this.tryParseTypeArgumentList(true);
+                var token0 = this.currentToken();
+
+                var isOpenParen = token0.tokenKind === 72 /* OpenParenToken */;
+                var isDot = token0.tokenKind === 76 /* DotToken */;
+                var isOpenParenOrDot = isOpenParen || isDot;
+
+                var argumentList = null;
+                if (typeArgumentList === null || !isOpenParenOrDot) {
+                    this.rewind(rewindPoint);
+                    this.releaseRewindPoint(rewindPoint);
+                    return null;
+                } else {
+                    this.releaseRewindPoint(rewindPoint);
+
+                    if (isDot) {
+                        var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token0.width(), TypeScript.DiagnosticCode.A_parameter_list_must_follow_a_generic_type_argument_list_expected, null);
+                        this.addDiagnostic(diagnostic);
+
+                        return this.factory.argumentList(typeArgumentList, TypeScript.Syntax.emptyToken(72 /* OpenParenToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.emptyToken(73 /* CloseParenToken */));
+                    } else {
+                        return this.parseArgumentList(typeArgumentList);
+                    }
+                }
+            };
+
+            ParserImpl.prototype.tryParseArgumentList = function () {
+                if (this.currentToken().tokenKind === 80 /* LessThanToken */) {
+                    return this.tryParseGenericArgumentList();
+                }
+
+                if (this.currentToken().tokenKind === 72 /* OpenParenToken */) {
+                    return this.parseArgumentList(null);
+                }
+
+                return null;
+            };
+
+            ParserImpl.prototype.parseArgumentList = function (typeArgumentList) {
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+
+                var _arguments = TypeScript.Syntax.emptySeparatedList;
+
+                if (openParenToken.fullWidth() > 0) {
+                    var result = this.parseSeparatedSyntaxList(16384 /* ArgumentList_AssignmentExpressions */);
+                    _arguments = result.list;
+                    openParenToken = this.addSkippedTokensAfterToken(openParenToken, result.skippedTokens);
+                }
+
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+
+                return this.factory.argumentList(typeArgumentList, openParenToken, _arguments, closeParenToken);
+            };
+
+            ParserImpl.prototype.parseElementAccessExpression = function (expression, inObjectCreation) {
+                var start = this.currentTokenStart();
+                var openBracketToken = this.eatToken(74 /* OpenBracketToken */);
+                var argumentExpression;
+
+                if (this.currentToken().tokenKind === 75 /* CloseBracketToken */ && inObjectCreation) {
+                    var end = this.currentTokenStart() + this.currentToken().width();
+                    var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, start, end - start, TypeScript.DiagnosticCode.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead, null);
+                    this.addDiagnostic(diagnostic);
+
+                    argumentExpression = TypeScript.Syntax.emptyToken(11 /* IdentifierName */);
+                } else {
+                    argumentExpression = this.parseExpression(true);
+                }
+
+                var closeBracketToken = this.eatToken(75 /* CloseBracketToken */);
+
+                return this.factory.elementAccessExpression(expression, openBracketToken, argumentExpression, closeBracketToken);
+            };
+
+            ParserImpl.prototype.parsePrimaryExpression = function () {
+                var currentToken = this.currentToken();
+
+                if (this.isIdentifier(currentToken)) {
+                    return this.eatIdentifierToken();
+                }
+
+                var currentTokenKind = currentToken.tokenKind;
+                switch (currentTokenKind) {
+                    case 35 /* ThisKeyword */:
+                        return this.parseThisExpression();
+
+                    case 37 /* TrueKeyword */:
+                    case 24 /* FalseKeyword */:
+                        return this.parseLiteralExpression();
+
+                    case 32 /* NullKeyword */:
+                        return this.parseLiteralExpression();
+
+                    case 27 /* FunctionKeyword */:
+                        return this.parseFunctionExpression();
+
+                    case 13 /* NumericLiteral */:
+                        return this.parseLiteralExpression();
+
+                    case 12 /* RegularExpressionLiteral */:
+                        return this.parseLiteralExpression();
+
+                    case 14 /* StringLiteral */:
+                        return this.parseLiteralExpression();
+
+                    case 74 /* OpenBracketToken */:
+                        return this.parseArrayLiteralExpression();
+
+                    case 70 /* OpenBraceToken */:
+                        return this.parseObjectLiteralExpression();
+
+                    case 72 /* OpenParenToken */:
+                        return this.parseParenthesizedExpression();
+
+                    case 118 /* SlashToken */:
+                    case 119 /* SlashEqualsToken */:
+                        var result = this.tryReparseDivideAsRegularExpression();
+                        if (result !== null) {
+                            return result;
+                        }
+                        break;
+                }
+
+                return null;
+            };
+
+            ParserImpl.prototype.tryReparseDivideAsRegularExpression = function () {
+                var currentToken = this.currentToken();
+
+                if (this.previousToken() !== null) {
+                    var previousTokenKind = this.previousToken().tokenKind;
+                    switch (previousTokenKind) {
+                        case 11 /* IdentifierName */:
+                            return null;
+
+                        case 35 /* ThisKeyword */:
+                        case 37 /* TrueKeyword */:
+                        case 24 /* FalseKeyword */:
+                            return null;
+
+                        case 14 /* StringLiteral */:
+                        case 13 /* NumericLiteral */:
+                        case 12 /* RegularExpressionLiteral */:
+                        case 93 /* PlusPlusToken */:
+                        case 94 /* MinusMinusToken */:
+                        case 75 /* CloseBracketToken */:
+                            return null;
+                    }
+                }
+
+                currentToken = this.currentTokenAllowingRegularExpression();
+
+                if (currentToken.tokenKind === 118 /* SlashToken */ || currentToken.tokenKind === 119 /* SlashEqualsToken */) {
+                    return null;
+                } else if (currentToken.tokenKind === 12 /* RegularExpressionLiteral */) {
+                    return this.parseLiteralExpression();
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.parseTypeOfExpression = function () {
+                var typeOfKeyword = this.eatKeyword(39 /* TypeOfKeyword */);
+                var expression = this.parseUnaryExpressionOrLower();
+
+                return this.factory.typeOfExpression(typeOfKeyword, expression);
+            };
+
+            ParserImpl.prototype.parseDeleteExpression = function () {
+                var deleteKeyword = this.eatKeyword(21 /* DeleteKeyword */);
+                var expression = this.parseUnaryExpressionOrLower();
+
+                return this.factory.deleteExpression(deleteKeyword, expression);
+            };
+
+            ParserImpl.prototype.parseVoidExpression = function () {
+                var voidKeyword = this.eatKeyword(41 /* VoidKeyword */);
+                var expression = this.parseUnaryExpressionOrLower();
+
+                return this.factory.voidExpression(voidKeyword, expression);
+            };
+
+            ParserImpl.prototype.parseFunctionExpression = function () {
+                var functionKeyword = this.eatKeyword(27 /* FunctionKeyword */);
+                var identifier = null;
+
+                if (this.isIdentifier(this.currentToken())) {
+                    identifier = this.eatIdentifierToken();
+                }
+
+                var callSignature = this.parseCallSignature(false);
+                var block = this.parseBlock(false, true);
+
+                return this.factory.functionExpression(functionKeyword, identifier, callSignature, block);
+            };
+
+            ParserImpl.prototype.parseObjectCreationExpression = function () {
+                var newKeyword = this.eatKeyword(31 /* NewKeyword */);
+
+                var expression = this.parseObjectCreationExpressionOrLower(true);
+                var argumentList = this.tryParseArgumentList();
+
+                var result = this.factory.objectCreationExpression(newKeyword, expression, argumentList);
+                return this.parseMemberExpressionRest(result, true, false);
+            };
+
+            ParserImpl.prototype.parseObjectCreationExpressionOrLower = function (inObjectCreation) {
+                if (this.currentToken().tokenKind === 31 /* NewKeyword */) {
+                    return this.parseObjectCreationExpression();
+                } else {
+                    return this.parseMemberExpressionOrLower(inObjectCreation);
+                }
+            };
+
+            ParserImpl.prototype.parseCastExpression = function () {
+                var lessThanToken = this.eatToken(80 /* LessThanToken */);
+                var type = this.parseType();
+                var greaterThanToken = this.eatToken(81 /* GreaterThanToken */);
+                var expression = this.parseUnaryExpressionOrLower();
+
+                return this.factory.castExpression(lessThanToken, type, greaterThanToken, expression);
+            };
+
+            ParserImpl.prototype.parseParenthesizedExpression = function () {
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var expression = this.parseExpression(true);
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+
+                return this.factory.parenthesizedExpression(openParenToken, expression, closeParenToken);
+            };
+
+            ParserImpl.prototype.tryParseParenthesizedArrowFunctionExpression = function () {
+                var tokenKind = this.currentToken().tokenKind;
+                if (tokenKind !== 72 /* OpenParenToken */ && tokenKind !== 80 /* LessThanToken */) {
+                    return null;
+                }
+
+                if (this.isDefinitelyArrowFunctionExpression()) {
+                    return this.parseParenthesizedArrowFunctionExpression(false);
+                }
+
+                if (!this.isPossiblyArrowFunctionExpression()) {
+                    return null;
+                }
+
+                var rewindPoint = this.getRewindPoint();
+
+                var arrowFunction = this.parseParenthesizedArrowFunctionExpression(true);
+                if (arrowFunction === null) {
+                    this.rewind(rewindPoint);
+                }
+
+                this.releaseRewindPoint(rewindPoint);
+                return arrowFunction;
+            };
+
+            ParserImpl.prototype.parseParenthesizedArrowFunctionExpression = function (requireArrow) {
+                var currentToken = this.currentToken();
+
+                var callSignature = this.parseCallSignature(true);
+
+                if (requireArrow && this.currentToken().tokenKind !== 85 /* EqualsGreaterThanToken */) {
+                    return null;
+                }
+
+                var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */);
+
+                var block = this.tryParseArrowFunctionBlock();
+                var expression = null;
+                if (block === null) {
+                    expression = this.parseAssignmentExpression(true);
+                }
+
+                return this.factory.parenthesizedArrowFunctionExpression(callSignature, equalsGreaterThanToken, block, expression);
+            };
+
+            ParserImpl.prototype.tryParseArrowFunctionBlock = function () {
+                if (this.isBlock()) {
+                    return this.parseBlock(false, false);
+                } else {
+                    if (this.isStatement(false) && !this.isExpressionStatement(this.currentToken()) && !this.isFunctionDeclaration()) {
+                        return this.parseBlock(true, false);
+                    } else {
+                        return null;
+                    }
+                }
+            };
+
+            ParserImpl.prototype.isSimpleArrowFunctionExpression = function () {
+                if (this.currentToken().tokenKind === 85 /* EqualsGreaterThanToken */) {
+                    return true;
+                }
+
+                return this.isIdentifier(this.currentToken()) && this.peekToken(1).tokenKind === 85 /* EqualsGreaterThanToken */;
+            };
+
+            ParserImpl.prototype.parseSimpleArrowFunctionExpression = function () {
+                var identifier = this.eatIdentifierToken();
+                var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */);
+
+                var block = this.tryParseArrowFunctionBlock();
+                var expression = null;
+                if (block === null) {
+                    expression = this.parseAssignmentExpression(true);
+                }
+
+                return this.factory.simpleArrowFunctionExpression(identifier, equalsGreaterThanToken, block, expression);
+            };
+
+            ParserImpl.prototype.isBlock = function () {
+                return this.currentToken().tokenKind === 70 /* OpenBraceToken */;
+            };
+
+            ParserImpl.prototype.isDefinitelyArrowFunctionExpression = function () {
+                var token0 = this.currentToken();
+                if (token0.tokenKind !== 72 /* OpenParenToken */) {
+                    return false;
+                }
+
+                var token1 = this.peekToken(1);
+                var token2;
+
+                if (token1.tokenKind === 73 /* CloseParenToken */) {
+                    token2 = this.peekToken(2);
+                    return token2.tokenKind === 106 /* ColonToken */ || token2.tokenKind === 85 /* EqualsGreaterThanToken */ || token2.tokenKind === 70 /* OpenBraceToken */;
+                }
+
+                if (token1.tokenKind === 77 /* DotDotDotToken */) {
+                    return true;
+                }
+
+                token2 = this.peekToken(2);
+                if (token1.tokenKind === 57 /* PublicKeyword */ || token1.tokenKind === 55 /* PrivateKeyword */) {
+                    if (this.isIdentifier(token2)) {
+                        return true;
+                    }
+                }
+
+                if (!this.isIdentifier(token1)) {
+                    return false;
+                }
+
+                if (token2.tokenKind === 106 /* ColonToken */) {
+                    return true;
+                }
+
+                var token3 = this.peekToken(3);
+                if (token2.tokenKind === 105 /* QuestionToken */) {
+                    if (token3.tokenKind === 106 /* ColonToken */ || token3.tokenKind === 73 /* CloseParenToken */ || token3.tokenKind === 79 /* CommaToken */) {
+                        return true;
+                    }
+                }
+
+                if (token2.tokenKind === 73 /* CloseParenToken */) {
+                    if (token3.tokenKind === 85 /* EqualsGreaterThanToken */) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isPossiblyArrowFunctionExpression = function () {
+                var token0 = this.currentToken();
+                if (token0.tokenKind !== 72 /* OpenParenToken */) {
+                    return true;
+                }
+
+                var token1 = this.peekToken(1);
+
+                if (!this.isIdentifier(token1)) {
+                    return false;
+                }
+
+                var token2 = this.peekToken(2);
+                if (token2.tokenKind === 107 /* EqualsToken */) {
+                    return true;
+                }
+
+                if (token2.tokenKind === 79 /* CommaToken */) {
+                    return true;
+                }
+
+                if (token2.tokenKind === 73 /* CloseParenToken */) {
+                    var token3 = this.peekToken(3);
+                    if (token3.tokenKind === 106 /* ColonToken */) {
+                        return true;
+                    }
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.parseObjectLiteralExpression = function () {
+                var openBraceToken = this.eatToken(70 /* OpenBraceToken */);
+
+                var result = this.parseSeparatedSyntaxList(32768 /* ObjectLiteralExpression_PropertyAssignments */);
+                var propertyAssignments = result.list;
+                openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens);
+
+                var closeBraceToken = this.eatToken(71 /* CloseBraceToken */);
+
+                return this.factory.objectLiteralExpression(openBraceToken, propertyAssignments, closeBraceToken);
+            };
+
+            ParserImpl.prototype.parsePropertyAssignment = function (inErrorRecovery) {
+                if (this.isAccessor(inErrorRecovery)) {
+                    return this.parseAccessor(true);
+                } else if (this.isFunctionPropertyAssignment(inErrorRecovery)) {
+                    return this.parseFunctionPropertyAssignment();
+                } else if (this.isSimplePropertyAssignment(inErrorRecovery)) {
+                    return this.parseSimplePropertyAssignment();
+                } else {
+                    throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.isPropertyAssignment = function (inErrorRecovery) {
+                return this.isAccessor(inErrorRecovery) || this.isFunctionPropertyAssignment(inErrorRecovery) || this.isSimplePropertyAssignment(inErrorRecovery);
+            };
+
+            ParserImpl.prototype.eatPropertyName = function () {
+                return TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(this.currentToken()) ? this.eatIdentifierNameToken() : this.eatAnyToken();
+            };
+
+            ParserImpl.prototype.isFunctionPropertyAssignment = function (inErrorRecovery) {
+                return this.isPropertyName(this.currentToken(), inErrorRecovery) && this.isCallSignature(1);
+            };
+
+            ParserImpl.prototype.parseFunctionPropertyAssignment = function () {
+                var propertyName = this.eatPropertyName();
+                var callSignature = this.parseCallSignature(false);
+                var block = this.parseBlock(false, true);
+
+                return this.factory.functionPropertyAssignment(propertyName, callSignature, block);
+            };
+
+            ParserImpl.prototype.isSimplePropertyAssignment = function (inErrorRecovery) {
+                return this.isPropertyName(this.currentToken(), inErrorRecovery);
+            };
+
+            ParserImpl.prototype.parseSimplePropertyAssignment = function () {
+                var propertyName = this.eatPropertyName();
+                var colonToken = this.eatToken(106 /* ColonToken */);
+                var expression = this.parseAssignmentExpression(true);
+
+                return this.factory.simplePropertyAssignment(propertyName, colonToken, expression);
+            };
+
+            ParserImpl.prototype.isPropertyName = function (token, inErrorRecovery) {
+                if (TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token)) {
+                    if (inErrorRecovery) {
+                        return this.isIdentifier(token);
+                    } else {
+                        return true;
+                    }
+                }
+
+                switch (token.tokenKind) {
+                    case 14 /* StringLiteral */:
+                    case 13 /* NumericLiteral */:
+                        return true;
+
+                    default:
+                        return false;
+                }
+            };
+
+            ParserImpl.prototype.parseArrayLiteralExpression = function () {
+                var openBracketToken = this.eatToken(74 /* OpenBracketToken */);
+
+                var result = this.parseSeparatedSyntaxList(65536 /* ArrayLiteralExpression_AssignmentExpressions */);
+                var expressions = result.list;
+                openBracketToken = this.addSkippedTokensAfterToken(openBracketToken, result.skippedTokens);
+
+                var closeBracketToken = this.eatToken(75 /* CloseBracketToken */);
+
+                return this.factory.arrayLiteralExpression(openBracketToken, expressions, closeBracketToken);
+            };
+
+            ParserImpl.prototype.parseLiteralExpression = function () {
+                return this.eatAnyToken();
+            };
+
+            ParserImpl.prototype.parseThisExpression = function () {
+                return this.eatKeyword(35 /* ThisKeyword */);
+            };
+
+            ParserImpl.prototype.parseBlock = function (parseBlockEvenWithNoOpenBrace, checkForStrictMode) {
+                var openBraceToken = this.eatToken(70 /* OpenBraceToken */);
+
+                var statements = TypeScript.Syntax.emptyList;
+
+                if (parseBlockEvenWithNoOpenBrace || openBraceToken.width() > 0) {
+                    var savedIsInStrictMode = this.isInStrictMode;
+
+                    var processItems = checkForStrictMode ? ParserImpl.updateStrictModeState : null;
+                    var result = this.parseSyntaxList(32 /* Block_Statements */, processItems);
+                    statements = result.list;
+                    openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens);
+
+                    this.setStrictMode(savedIsInStrictMode);
+                }
+
+                var closeBraceToken = this.eatToken(71 /* CloseBraceToken */);
+
+                return this.factory.block(openBraceToken, statements, closeBraceToken);
+            };
+
+            ParserImpl.prototype.parseCallSignature = function (requireCompleteTypeParameterList) {
+                var typeParameterList = this.parseOptionalTypeParameterList(requireCompleteTypeParameterList);
+                var parameterList = this.parseParameterList();
+                var typeAnnotation = this.parseOptionalTypeAnnotation(false);
+
+                return this.factory.callSignature(typeParameterList, parameterList, typeAnnotation);
+            };
+
+            ParserImpl.prototype.parseOptionalTypeParameterList = function (requireCompleteTypeParameterList) {
+                if (this.currentToken().tokenKind !== 80 /* LessThanToken */) {
+                    return null;
+                }
+
+                var rewindPoint = this.getRewindPoint();
+
+                var lessThanToken = this.eatToken(80 /* LessThanToken */);
+
+                var result = this.parseSeparatedSyntaxList(524288 /* TypeParameterList_TypeParameters */);
+                var typeParameters = result.list;
+                lessThanToken = this.addSkippedTokensAfterToken(lessThanToken, result.skippedTokens);
+
+                var greaterThanToken = this.eatToken(81 /* GreaterThanToken */);
+
+                if (requireCompleteTypeParameterList && greaterThanToken.fullWidth() === 0) {
+                    this.rewind(rewindPoint);
+                    this.releaseRewindPoint(rewindPoint);
+                    return null;
+                } else {
+                    this.releaseRewindPoint(rewindPoint);
+                    var typeParameterList = this.factory.typeParameterList(lessThanToken, typeParameters, greaterThanToken);
+
+                    return typeParameterList;
+                }
+            };
+
+            ParserImpl.prototype.isTypeParameter = function () {
+                return this.isIdentifier(this.currentToken());
+            };
+
+            ParserImpl.prototype.parseTypeParameter = function () {
+                var identifier = this.eatIdentifierToken();
+                var constraint = this.parseOptionalConstraint();
+
+                return this.factory.typeParameter(identifier, constraint);
+            };
+
+            ParserImpl.prototype.parseOptionalConstraint = function () {
+                if (this.currentToken().kind() !== 48 /* ExtendsKeyword */) {
+                    return null;
+                }
+
+                var extendsKeyword = this.eatKeyword(48 /* ExtendsKeyword */);
+                var type = this.parseType();
+
+                return this.factory.constraint(extendsKeyword, type);
+            };
+
+            ParserImpl.prototype.parseParameterList = function () {
+                var openParenToken = this.eatToken(72 /* OpenParenToken */);
+                var parameters = TypeScript.Syntax.emptySeparatedList;
+
+                if (openParenToken.width() > 0) {
+                    var result = this.parseSeparatedSyntaxList(131072 /* ParameterList_Parameters */);
+                    parameters = result.list;
+                    openParenToken = this.addSkippedTokensAfterToken(openParenToken, result.skippedTokens);
+                }
+
+                var closeParenToken = this.eatToken(73 /* CloseParenToken */);
+                return this.factory.parameterList(openParenToken, parameters, closeParenToken);
+            };
+
+            ParserImpl.prototype.isTypeAnnotation = function () {
+                return this.currentToken().tokenKind === 106 /* ColonToken */;
+            };
+
+            ParserImpl.prototype.parseOptionalTypeAnnotation = function (allowStringLiteral) {
+                return this.isTypeAnnotation() ? this.parseTypeAnnotation(allowStringLiteral) : null;
+            };
+
+            ParserImpl.prototype.parseTypeAnnotation = function (allowStringLiteral) {
+                var colonToken = this.eatToken(106 /* ColonToken */);
+                var type = allowStringLiteral && this.currentToken().tokenKind === 14 /* StringLiteral */ ? this.eatToken(14 /* StringLiteral */) : this.parseType();
+
+                return this.factory.typeAnnotation(colonToken, type);
+            };
+
+            ParserImpl.prototype.isType = function () {
+                var currentToken = this.currentToken();
+                var currentTokenKind = currentToken.tokenKind;
+
+                switch (currentTokenKind) {
+                    case 39 /* TypeOfKeyword */:
+
+                    case 60 /* AnyKeyword */:
+                    case 67 /* NumberKeyword */:
+                    case 61 /* BooleanKeyword */:
+                    case 69 /* StringKeyword */:
+                    case 41 /* VoidKeyword */:
+
+                    case 70 /* OpenBraceToken */:
+
+                    case 72 /* OpenParenToken */:
+                    case 80 /* LessThanToken */:
+
+                    case 31 /* NewKeyword */:
+                        return true;
+                }
+
+                return this.isIdentifier(currentToken);
+            };
+
+            ParserImpl.prototype.parseType = function () {
+                var currentToken = this.currentToken();
+                var currentTokenKind = currentToken.tokenKind;
+
+                var type = this.parseNonArrayType(currentToken);
+
+                while (this.currentToken().tokenKind === 74 /* OpenBracketToken */) {
+                    var openBracketToken = this.eatToken(74 /* OpenBracketToken */);
+                    var closeBracketToken = this.eatToken(75 /* CloseBracketToken */);
+
+                    type = this.factory.arrayType(type, openBracketToken, closeBracketToken);
+                }
+
+                return type;
+            };
+
+            ParserImpl.prototype.isTypeQuery = function () {
+                return this.currentToken().tokenKind === 39 /* TypeOfKeyword */;
+            };
+
+            ParserImpl.prototype.parseTypeQuery = function () {
+                var typeOfKeyword = this.eatToken(39 /* TypeOfKeyword */);
+                var name = this.parseName();
+
+                return this.factory.typeQuery(typeOfKeyword, name);
+            };
+
+            ParserImpl.prototype.parseNonArrayType = function (currentToken) {
+                var currentTokenKind = currentToken.tokenKind;
+                switch (currentTokenKind) {
+                    case 60 /* AnyKeyword */:
+                    case 67 /* NumberKeyword */:
+                    case 61 /* BooleanKeyword */:
+                    case 69 /* StringKeyword */:
+                    case 41 /* VoidKeyword */:
+                        return this.eatAnyToken();
+
+                    case 70 /* OpenBraceToken */:
+                        return this.parseObjectType();
+
+                    case 72 /* OpenParenToken */:
+                    case 80 /* LessThanToken */:
+                        return this.parseFunctionType();
+
+                    case 31 /* NewKeyword */:
+                        return this.parseConstructorType();
+
+                    case 39 /* TypeOfKeyword */:
+                        return this.parseTypeQuery();
+                }
+
+                return this.parseNameOrGenericType();
+            };
+
+            ParserImpl.prototype.parseNameOrGenericType = function () {
+                var name = this.parseName();
+                var typeArgumentList = this.tryParseTypeArgumentList(false);
+
+                return typeArgumentList === null ? name : this.factory.genericType(name, typeArgumentList);
+            };
+
+            ParserImpl.prototype.parseFunctionType = function () {
+                var typeParameterList = this.parseOptionalTypeParameterList(false);
+                var parameterList = this.parseParameterList();
+                var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */);
+                var returnType = this.parseType();
+
+                return this.factory.functionType(typeParameterList, parameterList, equalsGreaterThanToken, returnType);
+            };
+
+            ParserImpl.prototype.parseConstructorType = function () {
+                var newKeyword = this.eatKeyword(31 /* NewKeyword */);
+                var typeParameterList = this.parseOptionalTypeParameterList(false);
+                var parameterList = this.parseParameterList();
+                var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */);
+                var type = this.parseType();
+
+                return this.factory.constructorType(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type);
+            };
+
+            ParserImpl.prototype.isParameter = function () {
+                if (this.currentNode() !== null && this.currentNode().kind() === 242 /* Parameter */) {
+                    return true;
+                }
+
+                var token = this.currentToken();
+                var tokenKind = token.tokenKind;
+                if (tokenKind === 77 /* DotDotDotToken */) {
+                    return true;
+                }
+
+                if (ParserImpl.isModifier(token) && !this.isModifierUsedAsParameterIdentifier(token)) {
+                    return true;
+                }
+
+                return this.isIdentifier(token);
+            };
+
+            ParserImpl.prototype.isModifierUsedAsParameterIdentifier = function (token) {
+                if (this.isIdentifier(token)) {
+                    var nextTokenKind = this.peekToken(1).tokenKind;
+                    switch (nextTokenKind) {
+                        case 73 /* CloseParenToken */:
+                        case 106 /* ColonToken */:
+                        case 107 /* EqualsToken */:
+                        case 79 /* CommaToken */:
+                        case 105 /* QuestionToken */:
+                            return true;
+                    }
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.parseParameter = function () {
+                if (this.currentNode() !== null && this.currentNode().kind() === 242 /* Parameter */) {
+                    return this.eatNode();
+                }
+
+                var dotDotDotToken = this.tryEatToken(77 /* DotDotDotToken */);
+
+                var modifierArray = this.getArray();
+
+                while (true) {
+                    var currentToken = this.currentToken();
+                    if (ParserImpl.isModifier(currentToken) && !this.isModifierUsedAsParameterIdentifier(currentToken)) {
+                        modifierArray.push(this.eatAnyToken());
+                        continue;
+                    }
+
+                    break;
+                }
+
+                var modifiers = TypeScript.Syntax.list(modifierArray);
+                this.returnZeroOrOneLengthArray(modifierArray);
+
+                var identifier = this.eatIdentifierToken();
+                var questionToken = this.tryEatToken(105 /* QuestionToken */);
+                var typeAnnotation = this.parseOptionalTypeAnnotation(true);
+
+                var equalsValueClause = null;
+                if (this.isEqualsValueClause(true)) {
+                    equalsValueClause = this.parseEqualsValueClause(true);
+                }
+
+                return this.factory.parameter(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause);
+            };
+
+            ParserImpl.prototype.parseSyntaxList = function (currentListType, processItems) {
+                if (typeof processItems === "undefined") { processItems = null; }
+                var savedListParsingState = this.listParsingState;
+                this.listParsingState |= currentListType;
+
+                var result = this.parseSyntaxListWorker(currentListType, processItems);
+
+                this.listParsingState = savedListParsingState;
+
+                return result;
+            };
+
+            ParserImpl.prototype.parseSeparatedSyntaxList = function (currentListType) {
+                var savedListParsingState = this.listParsingState;
+                this.listParsingState |= currentListType;
+
+                var result = this.parseSeparatedSyntaxListWorker(currentListType);
+
+                this.listParsingState = savedListParsingState;
+
+                return result;
+            };
+
+            ParserImpl.prototype.abortParsingListOrMoveToNextToken = function (currentListType, items, skippedTokens) {
+                this.reportUnexpectedTokenDiagnostic(currentListType);
+
+                for (var state = 524288 /* LastListParsingState */; state >= 1 /* FirstListParsingState */; state >>= 1) {
+                    if ((this.listParsingState & state) !== 0) {
+                        if (this.isExpectedListTerminator(state) || this.isExpectedListItem(state, true)) {
+                            return true;
+                        }
+                    }
+                }
+
+                var skippedToken = this.currentToken();
+
+                this.moveToNextToken();
+
+                this.addSkippedTokenToList(items, skippedTokens, skippedToken);
+
+                return false;
+            };
+
+            ParserImpl.prototype.addSkippedTokenToList = function (items, skippedTokens, skippedToken) {
+                for (var i = items.length - 1; i >= 0; i--) {
+                    var item = items[i];
+                    var lastToken = item.lastToken();
+                    if (lastToken.fullWidth() > 0) {
+                        items[i] = this.addSkippedTokenAfterNodeOrToken(item, skippedToken);
+                        return;
+                    }
+                }
+
+                skippedTokens.push(skippedToken);
+            };
+
+            ParserImpl.prototype.tryParseExpectedListItem = function (currentListType, inErrorRecovery, items, processItems) {
+                if (this.isExpectedListItem(currentListType, inErrorRecovery)) {
+                    var item = this.parseExpectedListItem(currentListType, inErrorRecovery);
+
+                    items.push(item);
+
+                    if (processItems !== null) {
+                        processItems(this, items);
+                    }
+                }
+            };
+
+            ParserImpl.prototype.listIsTerminated = function (currentListType) {
+                return this.isExpectedListTerminator(currentListType) || this.currentToken().tokenKind === 10 /* EndOfFileToken */;
+            };
+
+            ParserImpl.prototype.getArray = function () {
+                if (this.arrayPool.length > 0) {
+                    return this.arrayPool.pop();
+                }
+
+                return [];
+            };
+
+            ParserImpl.prototype.returnZeroOrOneLengthArray = function (array) {
+                if (array.length <= 1) {
+                    this.returnArray(array);
+                }
+            };
+
+            ParserImpl.prototype.returnArray = function (array) {
+                array.length = 0;
+                this.arrayPool.push(array);
+            };
+
+            ParserImpl.prototype.parseSyntaxListWorker = function (currentListType, processItems) {
+                var items = this.getArray();
+                var skippedTokens = this.getArray();
+
+                while (true) {
+                    var oldItemsCount = items.length;
+                    this.tryParseExpectedListItem(currentListType, false, items, processItems);
+
+                    var newItemsCount = items.length;
+                    if (newItemsCount === oldItemsCount) {
+                        if (this.listIsTerminated(currentListType)) {
+                            break;
+                        }
+
+                        var abort = this.abortParsingListOrMoveToNextToken(currentListType, items, skippedTokens);
+                        if (abort) {
+                            break;
+                        }
+                    }
+                }
+
+                var result = TypeScript.Syntax.list(items);
+
+                this.returnZeroOrOneLengthArray(items);
+
+                return { skippedTokens: skippedTokens, list: result };
+            };
+
+            ParserImpl.prototype.parseSeparatedSyntaxListWorker = function (currentListType) {
+                var items = this.getArray();
+                var skippedTokens = this.getArray();
+                TypeScript.Debug.assert(items.length === 0);
+                TypeScript.Debug.assert(skippedTokens.length === 0);
+                TypeScript.Debug.assert(skippedTokens !== items);
+
+                var separatorKind = this.separatorKind(currentListType);
+                var allowAutomaticSemicolonInsertion = separatorKind === 78 /* SemicolonToken */;
+
+                var inErrorRecovery = false;
+                var listWasTerminated = false;
+                while (true) {
+                    var oldItemsCount = items.length;
+
+                    this.tryParseExpectedListItem(currentListType, inErrorRecovery, items, null);
+
+                    var newItemsCount = items.length;
+                    if (newItemsCount === oldItemsCount) {
+                        if (this.listIsTerminated(currentListType)) {
+                            listWasTerminated = true;
+                            break;
+                        }
+
+                        var abort = this.abortParsingListOrMoveToNextToken(currentListType, items, skippedTokens);
+                        if (abort) {
+                            break;
+                        } else {
+                            inErrorRecovery = true;
+                            continue;
+                        }
+                    }
+
+                    inErrorRecovery = false;
+
+                    var currentToken = this.currentToken();
+                    if (currentToken.tokenKind === separatorKind || currentToken.tokenKind === 79 /* CommaToken */) {
+                        items.push(this.eatAnyToken());
+                        continue;
+                    }
+
+                    if (this.listIsTerminated(currentListType)) {
+                        listWasTerminated = true;
+                        break;
+                    }
+
+                    if (allowAutomaticSemicolonInsertion && this.canEatAutomaticSemicolon(false)) {
+                        items.push(this.eatExplicitOrAutomaticSemicolon(false));
+
+                        continue;
+                    }
+
+                    items.push(this.eatToken(separatorKind));
+
+                    inErrorRecovery = true;
+                }
+
+                var result = TypeScript.Syntax.separatedList(items);
+
+                this.returnZeroOrOneLengthArray(items);
+
+                return { skippedTokens: skippedTokens, list: result };
+            };
+
+            ParserImpl.prototype.separatorKind = function (currentListType) {
+                switch (currentListType) {
+                    case 2048 /* HeritageClause_TypeNameList */:
+                    case 16384 /* ArgumentList_AssignmentExpressions */:
+                    case 256 /* EnumDeclaration_EnumElements */:
+                    case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */:
+                    case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */:
+                    case 32768 /* ObjectLiteralExpression_PropertyAssignments */:
+                    case 131072 /* ParameterList_Parameters */:
+                    case 65536 /* ArrayLiteralExpression_AssignmentExpressions */:
+                    case 262144 /* TypeArgumentList_Types */:
+                    case 524288 /* TypeParameterList_TypeParameters */:
+                        return 79 /* CommaToken */;
+
+                    case 512 /* ObjectType_TypeMembers */:
+                        return 78 /* SemicolonToken */;
+
+                    case 1 /* SourceUnit_ModuleElements */:
+                    case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */:
+                    case 2 /* ClassDeclaration_ClassElements */:
+                    case 4 /* ModuleDeclaration_ModuleElements */:
+                    case 8 /* SwitchStatement_SwitchClauses */:
+                    case 16 /* SwitchClause_Statements */:
+                    case 32 /* Block_Statements */:
+                    default:
+                        throw TypeScript.Errors.notYetImplemented();
+                }
+            };
+
+            ParserImpl.prototype.reportUnexpectedTokenDiagnostic = function (listType) {
+                var token = this.currentToken();
+
+                var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode.Unexpected_token_0_expected, [this.getExpectedListElementType(listType)]);
+                this.addDiagnostic(diagnostic);
+            };
+
+            ParserImpl.prototype.addDiagnostic = function (diagnostic) {
+                if (this.diagnostics.length > 0 && this.diagnostics[this.diagnostics.length - 1].start() === diagnostic.start()) {
+                    return;
+                }
+
+                this.diagnostics.push(diagnostic);
+            };
+
+            ParserImpl.prototype.isExpectedListTerminator = function (currentListType) {
+                switch (currentListType) {
+                    case 1 /* SourceUnit_ModuleElements */:
+                        return this.isExpectedSourceUnit_ModuleElementsTerminator();
+
+                    case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */:
+                        return this.isExpectedClassOrInterfaceDeclaration_HeritageClausesTerminator();
+
+                    case 2 /* ClassDeclaration_ClassElements */:
+                        return this.isExpectedClassDeclaration_ClassElementsTerminator();
+
+                    case 4 /* ModuleDeclaration_ModuleElements */:
+                        return this.isExpectedModuleDeclaration_ModuleElementsTerminator();
+
+                    case 8 /* SwitchStatement_SwitchClauses */:
+                        return this.isExpectedSwitchStatement_SwitchClausesTerminator();
+
+                    case 16 /* SwitchClause_Statements */:
+                        return this.isExpectedSwitchClause_StatementsTerminator();
+
+                    case 32 /* Block_Statements */:
+                        return this.isExpectedBlock_StatementsTerminator();
+
+                    case 64 /* TryBlock_Statements */:
+                        return this.isExpectedTryBlock_StatementsTerminator();
+
+                    case 128 /* CatchBlock_Statements */:
+                        return this.isExpectedCatchBlock_StatementsTerminator();
+
+                    case 256 /* EnumDeclaration_EnumElements */:
+                        return this.isExpectedEnumDeclaration_EnumElementsTerminator();
+
+                    case 512 /* ObjectType_TypeMembers */:
+                        return this.isExpectedObjectType_TypeMembersTerminator();
+
+                    case 16384 /* ArgumentList_AssignmentExpressions */:
+                        return this.isExpectedArgumentList_AssignmentExpressionsTerminator();
+
+                    case 2048 /* HeritageClause_TypeNameList */:
+                        return this.isExpectedHeritageClause_TypeNameListTerminator();
+
+                    case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */:
+                        return this.isExpectedVariableDeclaration_VariableDeclarators_AllowInTerminator();
+
+                    case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */:
+                        return this.isExpectedVariableDeclaration_VariableDeclarators_DisallowInTerminator();
+
+                    case 32768 /* ObjectLiteralExpression_PropertyAssignments */:
+                        return this.isExpectedObjectLiteralExpression_PropertyAssignmentsTerminator();
+
+                    case 131072 /* ParameterList_Parameters */:
+                        return this.isExpectedParameterList_ParametersTerminator();
+
+                    case 262144 /* TypeArgumentList_Types */:
+                        return this.isExpectedTypeArgumentList_TypesTerminator();
+
+                    case 524288 /* TypeParameterList_TypeParameters */:
+                        return this.isExpectedTypeParameterList_TypeParametersTerminator();
+
+                    case 65536 /* ArrayLiteralExpression_AssignmentExpressions */:
+                        return this.isExpectedLiteralExpression_AssignmentExpressionsTerminator();
+
+                    default:
+                        throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.isExpectedSourceUnit_ModuleElementsTerminator = function () {
+                return this.currentToken().tokenKind === 10 /* EndOfFileToken */;
+            };
+
+            ParserImpl.prototype.isExpectedEnumDeclaration_EnumElementsTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */;
+            };
+
+            ParserImpl.prototype.isExpectedModuleDeclaration_ModuleElementsTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */;
+            };
+
+            ParserImpl.prototype.isExpectedObjectType_TypeMembersTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */;
+            };
+
+            ParserImpl.prototype.isExpectedObjectLiteralExpression_PropertyAssignmentsTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */;
+            };
+
+            ParserImpl.prototype.isExpectedLiteralExpression_AssignmentExpressionsTerminator = function () {
+                return this.currentToken().tokenKind === 75 /* CloseBracketToken */;
+            };
+
+            ParserImpl.prototype.isExpectedTypeArgumentList_TypesTerminator = function () {
+                var token = this.currentToken();
+                if (token.tokenKind === 81 /* GreaterThanToken */) {
+                    return true;
+                }
+
+                if (this.canFollowTypeArgumentListInExpression(token.tokenKind)) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isExpectedTypeParameterList_TypeParametersTerminator = function () {
+                var token = this.currentToken();
+                if (token.tokenKind === 81 /* GreaterThanToken */) {
+                    return true;
+                }
+
+                if (token.tokenKind === 72 /* OpenParenToken */ || token.tokenKind === 70 /* OpenBraceToken */ || token.tokenKind === 48 /* ExtendsKeyword */ || token.tokenKind === 51 /* ImplementsKeyword */) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isExpectedParameterList_ParametersTerminator = function () {
+                var token = this.currentToken();
+                if (token.tokenKind === 73 /* CloseParenToken */) {
+                    return true;
+                }
+
+                if (token.tokenKind === 70 /* OpenBraceToken */) {
+                    return true;
+                }
+
+                if (token.tokenKind === 85 /* EqualsGreaterThanToken */) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isExpectedVariableDeclaration_VariableDeclarators_DisallowInTerminator = function () {
+                if (this.currentToken().tokenKind === 78 /* SemicolonToken */ || this.currentToken().tokenKind === 73 /* CloseParenToken */) {
+                    return true;
+                }
+
+                if (this.currentToken().tokenKind === 29 /* InKeyword */) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isExpectedVariableDeclaration_VariableDeclarators_AllowInTerminator = function () {
+                if (this.previousToken().tokenKind === 79 /* CommaToken */) {
+                    return false;
+                }
+
+                if (this.currentToken().tokenKind === 85 /* EqualsGreaterThanToken */) {
+                    return true;
+                }
+
+                return this.canEatExplicitOrAutomaticSemicolon(false);
+            };
+
+            ParserImpl.prototype.isExpectedClassOrInterfaceDeclaration_HeritageClausesTerminator = function () {
+                var token0 = this.currentToken();
+                if (token0.tokenKind === 70 /* OpenBraceToken */ || token0.tokenKind === 71 /* CloseBraceToken */) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isExpectedHeritageClause_TypeNameListTerminator = function () {
+                var token0 = this.currentToken();
+                if (token0.tokenKind === 48 /* ExtendsKeyword */ || token0.tokenKind === 51 /* ImplementsKeyword */) {
+                    return true;
+                }
+
+                if (this.isExpectedClassOrInterfaceDeclaration_HeritageClausesTerminator()) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.isExpectedArgumentList_AssignmentExpressionsTerminator = function () {
+                var token0 = this.currentToken();
+                return token0.tokenKind === 73 /* CloseParenToken */ || token0.tokenKind === 78 /* SemicolonToken */;
+            };
+
+            ParserImpl.prototype.isExpectedClassDeclaration_ClassElementsTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */;
+            };
+
+            ParserImpl.prototype.isExpectedSwitchStatement_SwitchClausesTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */;
+            };
+
+            ParserImpl.prototype.isExpectedSwitchClause_StatementsTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */ || this.isSwitchClause();
+            };
+
+            ParserImpl.prototype.isExpectedBlock_StatementsTerminator = function () {
+                return this.currentToken().tokenKind === 71 /* CloseBraceToken */;
+            };
+
+            ParserImpl.prototype.isExpectedTryBlock_StatementsTerminator = function () {
+                return this.currentToken().tokenKind === 17 /* CatchKeyword */ || this.currentToken().tokenKind === 25 /* FinallyKeyword */;
+            };
+
+            ParserImpl.prototype.isExpectedCatchBlock_StatementsTerminator = function () {
+                return this.currentToken().tokenKind === 25 /* FinallyKeyword */;
+            };
+
+            ParserImpl.prototype.isExpectedListItem = function (currentListType, inErrorRecovery) {
+                switch (currentListType) {
+                    case 1 /* SourceUnit_ModuleElements */:
+                        return this.isModuleElement(inErrorRecovery);
+
+                    case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */:
+                        return this.isHeritageClause();
+
+                    case 2 /* ClassDeclaration_ClassElements */:
+                        return this.isClassElement(inErrorRecovery);
+
+                    case 4 /* ModuleDeclaration_ModuleElements */:
+                        return this.isModuleElement(inErrorRecovery);
+
+                    case 8 /* SwitchStatement_SwitchClauses */:
+                        return this.isSwitchClause();
+
+                    case 16 /* SwitchClause_Statements */:
+                        return this.isStatement(inErrorRecovery);
+
+                    case 32 /* Block_Statements */:
+                        return this.isStatement(inErrorRecovery);
+
+                    case 64 /* TryBlock_Statements */:
+                    case 128 /* CatchBlock_Statements */:
+                        return false;
+
+                    case 256 /* EnumDeclaration_EnumElements */:
+                        return this.isEnumElement(inErrorRecovery);
+
+                    case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */:
+                    case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */:
+                        return this.isVariableDeclarator();
+
+                    case 512 /* ObjectType_TypeMembers */:
+                        return this.isTypeMember(inErrorRecovery);
+
+                    case 16384 /* ArgumentList_AssignmentExpressions */:
+                        return this.isExpectedArgumentList_AssignmentExpression();
+
+                    case 2048 /* HeritageClause_TypeNameList */:
+                        return this.isHeritageClauseTypeName();
+
+                    case 32768 /* ObjectLiteralExpression_PropertyAssignments */:
+                        return this.isPropertyAssignment(inErrorRecovery);
+
+                    case 131072 /* ParameterList_Parameters */:
+                        return this.isParameter();
+
+                    case 262144 /* TypeArgumentList_Types */:
+                        return this.isType();
+
+                    case 524288 /* TypeParameterList_TypeParameters */:
+                        return this.isTypeParameter();
+
+                    case 65536 /* ArrayLiteralExpression_AssignmentExpressions */:
+                        return this.isAssignmentOrOmittedExpression();
+
+                    default:
+                        throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.isExpectedArgumentList_AssignmentExpression = function () {
+                var currentToken = this.currentToken();
+                if (this.isExpression(currentToken)) {
+                    return true;
+                }
+
+                if (currentToken.tokenKind === 79 /* CommaToken */) {
+                    return true;
+                }
+
+                return false;
+            };
+
+            ParserImpl.prototype.parseExpectedListItem = function (currentListType, inErrorRecovery) {
+                switch (currentListType) {
+                    case 1 /* SourceUnit_ModuleElements */:
+                        return this.parseModuleElement(inErrorRecovery);
+
+                    case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */:
+                        return this.parseHeritageClause();
+
+                    case 2 /* ClassDeclaration_ClassElements */:
+                        return this.parseClassElement(inErrorRecovery);
+
+                    case 4 /* ModuleDeclaration_ModuleElements */:
+                        return this.parseModuleElement(inErrorRecovery);
+
+                    case 8 /* SwitchStatement_SwitchClauses */:
+                        return this.parseSwitchClause();
+
+                    case 16 /* SwitchClause_Statements */:
+                        return this.parseStatement(inErrorRecovery);
+
+                    case 32 /* Block_Statements */:
+                        return this.parseStatement(inErrorRecovery);
+
+                    case 256 /* EnumDeclaration_EnumElements */:
+                        return this.parseEnumElement();
+
+                    case 512 /* ObjectType_TypeMembers */:
+                        return this.parseTypeMember(inErrorRecovery);
+
+                    case 16384 /* ArgumentList_AssignmentExpressions */:
+                        return this.parseAssignmentExpression(true);
+
+                    case 2048 /* HeritageClause_TypeNameList */:
+                        return this.parseNameOrGenericType();
+
+                    case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */:
+                        return this.parseVariableDeclarator(true, false);
+
+                    case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */:
+                        return this.parseVariableDeclarator(false, false);
+
+                    case 32768 /* ObjectLiteralExpression_PropertyAssignments */:
+                        return this.parsePropertyAssignment(inErrorRecovery);
+
+                    case 65536 /* ArrayLiteralExpression_AssignmentExpressions */:
+                        return this.parseAssignmentOrOmittedExpression();
+
+                    case 131072 /* ParameterList_Parameters */:
+                        return this.parseParameter();
+
+                    case 262144 /* TypeArgumentList_Types */:
+                        return this.parseType();
+
+                    case 524288 /* TypeParameterList_TypeParameters */:
+                        return this.parseTypeParameter();
+
+                    default:
+                        throw TypeScript.Errors.invalidOperation();
+                }
+            };
+
+            ParserImpl.prototype.getExpectedListElementType = function (currentListType) {
+                switch (currentListType) {
+                    case 1 /* SourceUnit_ModuleElements */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.module_class_interface_enum_import_or_statement, null);
+
+                    case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */:
+                        return '{';
+
+                    case 2 /* ClassDeclaration_ClassElements */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.constructor_function_accessor_or_variable, null);
+
+                    case 4 /* ModuleDeclaration_ModuleElements */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.module_class_interface_enum_import_or_statement, null);
+
+                    case 8 /* SwitchStatement_SwitchClauses */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.case_or_default_clause, null);
+
+                    case 16 /* SwitchClause_Statements */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.statement, null);
+
+                    case 32 /* Block_Statements */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.statement, null);
+
+                    case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */:
+                    case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null);
+
+                    case 256 /* EnumDeclaration_EnumElements */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null);
+
+                    case 512 /* ObjectType_TypeMembers */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.call_construct_index_property_or_function_signature, null);
+
+                    case 16384 /* ArgumentList_AssignmentExpressions */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.expression, null);
+
+                    case 2048 /* HeritageClause_TypeNameList */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type_name, null);
+
+                    case 32768 /* ObjectLiteralExpression_PropertyAssignments */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.property_or_accessor, null);
+
+                    case 131072 /* ParameterList_Parameters */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.parameter, null);
+
+                    case 262144 /* TypeArgumentList_Types */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type, null);
+
+                    case 524288 /* TypeParameterList_TypeParameters */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type_parameter, null);
+
+                    case 65536 /* ArrayLiteralExpression_AssignmentExpressions */:
+                        return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.expression, null);
+
+                    default:
+                        throw TypeScript.Errors.invalidOperation();
+                }
+            };
+            return ParserImpl;
+        })();
+
+        function parse(fileName, text, isDeclaration, options) {
+            var source = new NormalParserSource(fileName, text, options.languageVersion());
+
+            return new ParserImpl(fileName, text.lineMap(), source, options, text).parseSyntaxTree(isDeclaration);
+        }
+        Parser.parse = parse;
+
+        function incrementalParse(oldSyntaxTree, textChangeRange, newText) {
+            if (textChangeRange.isUnchanged()) {
+                return oldSyntaxTree;
+            }
+
+            var source = new IncrementalParserSource(oldSyntaxTree, textChangeRange, newText);
+
+            return new ParserImpl(oldSyntaxTree.fileName(), newText.lineMap(), source, oldSyntaxTree.parseOptions(), newText).parseSyntaxTree(oldSyntaxTree.isDeclaration());
+        }
+        Parser.incrementalParse = incrementalParse;
+    })(TypeScript.Parser || (TypeScript.Parser = {}));
+    var Parser = TypeScript.Parser;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxTree = (function () {
+        function SyntaxTree(sourceUnit, isDeclaration, diagnostics, fileName, lineMap, parseOtions) {
+            this._allDiagnostics = null;
+            this._sourceUnit = sourceUnit;
+            this._isDeclaration = isDeclaration;
+            this._parserDiagnostics = diagnostics;
+            this._fileName = fileName;
+            this._lineMap = lineMap;
+            this._parseOptions = parseOtions;
+        }
+        SyntaxTree.prototype.toJSON = function (key) {
+            var result = {};
+
+            result.isDeclaration = this._isDeclaration;
+            result.languageVersion = TypeScript.LanguageVersion[this._parseOptions.languageVersion()];
+            result.parseOptions = this._parseOptions;
+
+            if (this.diagnostics().length > 0) {
+                result.diagnostics = this.diagnostics();
+            }
+
+            result.sourceUnit = this._sourceUnit;
+            result.lineMap = this._lineMap;
+
+            return result;
+        };
+
+        SyntaxTree.prototype.sourceUnit = function () {
+            return this._sourceUnit;
+        };
+
+        SyntaxTree.prototype.isDeclaration = function () {
+            return this._isDeclaration;
+        };
+
+        SyntaxTree.prototype.computeDiagnostics = function () {
+            if (this._parserDiagnostics.length > 0) {
+                return this._parserDiagnostics;
+            }
+
+            var diagnostics = [];
+            this.sourceUnit().accept(new GrammarCheckerWalker(this, diagnostics));
+
+            return diagnostics;
+        };
+
+        SyntaxTree.prototype.diagnostics = function () {
+            if (this._allDiagnostics === null) {
+                this._allDiagnostics = this.computeDiagnostics();
+            }
+
+            return this._allDiagnostics;
+        };
+
+        SyntaxTree.prototype.fileName = function () {
+            return this._fileName;
+        };
+
+        SyntaxTree.prototype.lineMap = function () {
+            return this._lineMap;
+        };
+
+        SyntaxTree.prototype.parseOptions = function () {
+            return this._parseOptions;
+        };
+
+        SyntaxTree.prototype.structuralEquals = function (tree) {
+            return TypeScript.ArrayUtilities.sequenceEquals(this.diagnostics(), tree.diagnostics(), TypeScript.Diagnostic.equals) && this.sourceUnit().structuralEquals(tree.sourceUnit());
+        };
+        return SyntaxTree;
+    })();
+    TypeScript.SyntaxTree = SyntaxTree;
+
+    var GrammarCheckerWalker = (function (_super) {
+        __extends(GrammarCheckerWalker, _super);
+        function GrammarCheckerWalker(syntaxTree, diagnostics) {
+            _super.call(this);
+            this.syntaxTree = syntaxTree;
+            this.diagnostics = diagnostics;
+            this.inAmbientDeclaration = false;
+            this.inBlock = false;
+            this.inObjectLiteralExpression = false;
+            this.currentConstructor = null;
+        }
+        GrammarCheckerWalker.prototype.childFullStart = function (parent, child) {
+            return this.position() + TypeScript.Syntax.childOffset(parent, child);
+        };
+
+        GrammarCheckerWalker.prototype.childStart = function (parent, child) {
+            return this.childFullStart(parent, child) + child.leadingTriviaWidth();
+        };
+
+        GrammarCheckerWalker.prototype.pushDiagnostic = function (start, length, diagnosticKey, args) {
+            if (typeof args === "undefined") { args = null; }
+            this.diagnostics.push(new TypeScript.Diagnostic(this.syntaxTree.fileName(), this.syntaxTree.lineMap(), start, length, diagnosticKey, args));
+        };
+
+        GrammarCheckerWalker.prototype.pushDiagnostic1 = function (elementFullStart, element, diagnosticKey, args) {
+            if (typeof args === "undefined") { args = null; }
+            this.diagnostics.push(new TypeScript.Diagnostic(this.syntaxTree.fileName(), this.syntaxTree.lineMap(), elementFullStart + element.leadingTriviaWidth(), element.width(), diagnosticKey, args));
+        };
+
+        GrammarCheckerWalker.prototype.visitCatchClause = function (node) {
+            if (node.typeAnnotation) {
+                this.pushDiagnostic(this.childStart(node, node.typeAnnotation), node.typeAnnotation.width(), TypeScript.DiagnosticCode.Catch_clause_parameter_cannot_have_a_type_annotation);
+            }
+
+            _super.prototype.visitCatchClause.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkParameterListOrder = function (node) {
+            var parameterFullStart = this.childFullStart(node, node.parameters);
+
+            var seenOptionalParameter = false;
+            var parameterCount = node.parameters.nonSeparatorCount();
+
+            for (var i = 0, n = node.parameters.childCount(); i < n; i++) {
+                var nodeOrToken = node.parameters.childAt(i);
+                if (i % 2 === 0) {
+                    var parameterIndex = i / 2;
+                    var parameter = node.parameters.childAt(i);
+
+                    if (parameter.dotDotDotToken) {
+                        if (parameterIndex !== (parameterCount - 1)) {
+                            this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Rest_parameter_must_be_last_in_list);
+                            return true;
+                        }
+
+                        if (parameter.questionToken) {
+                            this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Rest_parameter_cannot_be_optional);
+                            return true;
+                        }
+
+                        if (parameter.equalsValueClause) {
+                            this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Rest_parameter_cannot_have_an_initializer);
+                            return true;
+                        }
+                    } else if (parameter.questionToken || parameter.equalsValueClause) {
+                        seenOptionalParameter = true;
+
+                        if (parameter.questionToken && parameter.equalsValueClause) {
+                            this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Parameter_cannot_have_question_mark_and_initializer);
+                            return true;
+                        }
+                    } else {
+                        if (seenOptionalParameter) {
+                            this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Required_parameter_cannot_follow_optional_parameter);
+                            return true;
+                        }
+                    }
+                }
+
+                parameterFullStart += nodeOrToken.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkParameterListAcessibilityModifiers = function (node) {
+            var parameterFullStart = this.childFullStart(node, node.parameters);
+
+            for (var i = 0, n = node.parameters.childCount(); i < n; i++) {
+                var nodeOrToken = node.parameters.childAt(i);
+                if (i % 2 === 0) {
+                    var parameter = node.parameters.childAt(i);
+
+                    if (this.checkParameterAccessibilityModifiers(node, parameter, parameterFullStart)) {
+                        return true;
+                    }
+                }
+
+                parameterFullStart += nodeOrToken.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkParameterAccessibilityModifiers = function (parameterList, parameter, parameterFullStart) {
+            if (parameter.modifiers.childCount() > 0) {
+                var modifiers = parameter.modifiers;
+                var modifierFullStart = parameterFullStart + TypeScript.Syntax.childOffset(parameter, modifiers);
+
+                for (var i = 0, n = modifiers.childCount(); i < n; i++) {
+                    var modifier = modifiers.childAt(i);
+
+                    if (this.checkParameterAccessibilityModifier(parameterList, modifier, modifierFullStart, i)) {
+                        return true;
+                    }
+
+                    modifierFullStart += modifier.fullWidth();
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkParameterAccessibilityModifier = function (parameterList, modifier, modifierFullStart, modifierIndex) {
+            if (modifier.tokenKind !== 57 /* PublicKeyword */ && modifier.tokenKind !== 55 /* PrivateKeyword */) {
+                this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_parameter, [modifier.text()]);
+                return true;
+            } else {
+                if (modifierIndex > 0) {
+                    this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Accessibility_modifier_already_seen);
+                    return true;
+                }
+
+                if (!this.inAmbientDeclaration && this.currentConstructor && !this.currentConstructor.block && this.currentConstructor.callSignature.parameterList === parameterList) {
+                    this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Parameter_property_declarations_cannot_be_used_in_a_constructor_overload);
+                    return true;
+                } else if (this.inAmbientDeclaration || this.currentConstructor === null || this.currentConstructor.callSignature.parameterList !== parameterList) {
+                    this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Parameter_property_declarations_can_only_be_used_in_a_non_ambient_constructor_declaration);
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkForTrailingSeparator = function (parent, list) {
+            if (list.childCount() === 0 || list.childCount() % 2 === 1) {
+                return false;
+            }
+
+            var currentElementFullStart = this.childFullStart(parent, list);
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var child = list.childAt(i);
+                if (i === n - 1) {
+                    this.pushDiagnostic1(currentElementFullStart, child, TypeScript.DiagnosticCode.Trailing_separator_not_allowed);
+                }
+
+                currentElementFullStart += child.fullWidth();
+            }
+
+            return true;
+        };
+
+        GrammarCheckerWalker.prototype.checkForAtLeastOneElement = function (parent, list, expected) {
+            if (list.childCount() > 0) {
+                return false;
+            }
+
+            var listFullStart = this.childFullStart(parent, list);
+            var tokenAtStart = this.syntaxTree.sourceUnit().findToken(listFullStart);
+
+            this.pushDiagnostic1(listFullStart, tokenAtStart.token(), TypeScript.DiagnosticCode.Unexpected_token_0_expected, [expected]);
+
+            return true;
+        };
+
+        GrammarCheckerWalker.prototype.visitParameterList = function (node) {
+            if (this.checkParameterListAcessibilityModifiers(node) || this.checkParameterListOrder(node) || this.checkForTrailingSeparator(node, node.parameters)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitParameterList.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitHeritageClause = function (node) {
+            if (this.checkForTrailingSeparator(node, node.typeNames) || this.checkForAtLeastOneElement(node, node.typeNames, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type_name, null))) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitHeritageClause.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitArgumentList = function (node) {
+            if (this.checkForTrailingSeparator(node, node.arguments)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitArgumentList.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitVariableDeclaration = function (node) {
+            if (this.checkForTrailingSeparator(node, node.variableDeclarators) || this.checkForAtLeastOneElement(node, node.variableDeclarators, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null))) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitVariableDeclaration.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitTypeArgumentList = function (node) {
+            if (this.checkForTrailingSeparator(node, node.typeArguments) || this.checkForAtLeastOneElement(node, node.typeArguments, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null))) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitTypeArgumentList.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitTypeParameterList = function (node) {
+            if (this.checkForTrailingSeparator(node, node.typeParameters) || this.checkForAtLeastOneElement(node, node.typeParameters, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null))) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitTypeParameterList.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkIndexSignatureParameter = function (node) {
+            var parameterFullStart = this.childFullStart(node, node.parameter);
+            var parameter = node.parameter;
+
+            if (parameter.dotDotDotToken) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signatures_cannot_have_rest_parameters);
+                return true;
+            } else if (parameter.modifiers.childCount() > 0) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_cannot_have_accessibility_modifiers);
+                return true;
+            } else if (parameter.questionToken) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_cannot_have_a_question_mark);
+                return true;
+            } else if (parameter.equalsValueClause) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_cannot_have_an_initializer);
+                return true;
+            } else if (!parameter.typeAnnotation) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_must_have_a_type_annotation);
+                return true;
+            } else if (parameter.typeAnnotation.type.kind() !== 69 /* StringKeyword */ && parameter.typeAnnotation.type.kind() !== 67 /* NumberKeyword */) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_type_must_be_string_or_number);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitIndexSignature = function (node) {
+            if (this.checkIndexSignatureParameter(node)) {
+                this.skip(node);
+                return;
+            }
+
+            if (!node.typeAnnotation) {
+                this.pushDiagnostic1(this.position(), node, TypeScript.DiagnosticCode.Index_signature_must_have_a_type_annotation);
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitIndexSignature.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkClassDeclarationHeritageClauses = function (node) {
+            var heritageClauseFullStart = this.childFullStart(node, node.heritageClauses);
+
+            var seenExtendsClause = false;
+            var seenImplementsClause = false;
+
+            for (var i = 0, n = node.heritageClauses.childCount(); i < n; i++) {
+                TypeScript.Debug.assert(i <= 2);
+                var heritageClause = node.heritageClauses.childAt(i);
+
+                if (heritageClause.extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */) {
+                    if (seenExtendsClause) {
+                        this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.extends_clause_already_seen);
+                        return true;
+                    }
+
+                    if (seenImplementsClause) {
+                        this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.extends_clause_must_precede_implements_clause);
+                        return true;
+                    }
+
+                    if (heritageClause.typeNames.nonSeparatorCount() > 1) {
+                        this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.Classes_can_only_extend_a_single_class);
+                        return true;
+                    }
+
+                    seenExtendsClause = true;
+                } else {
+                    TypeScript.Debug.assert(heritageClause.extendsOrImplementsKeyword.tokenKind === 51 /* ImplementsKeyword */);
+                    if (seenImplementsClause) {
+                        this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.implements_clause_already_seen);
+                        return true;
+                    }
+
+                    seenImplementsClause = true;
+                }
+
+                heritageClauseFullStart += heritageClause.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkForDisallowedDeclareModifier = function (modifiers) {
+            if (this.inAmbientDeclaration) {
+                var declareToken = TypeScript.SyntaxUtilities.getToken(modifiers, 63 /* DeclareKeyword */);
+
+                if (declareToken) {
+                    this.pushDiagnostic1(this.childFullStart(modifiers, declareToken), declareToken, TypeScript.DiagnosticCode.declare_modifier_not_allowed_for_code_already_in_an_ambient_context);
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkForRequiredDeclareModifier = function (moduleElement, typeKeyword, modifiers) {
+            if (!this.inAmbientDeclaration && this.syntaxTree.isDeclaration()) {
+                if (!TypeScript.SyntaxUtilities.containsToken(modifiers, 63 /* DeclareKeyword */)) {
+                    this.pushDiagnostic1(this.childFullStart(moduleElement, typeKeyword), typeKeyword.firstToken(), TypeScript.DiagnosticCode.declare_modifier_required_for_top_level_element);
+                    return true;
+                }
+            }
+        };
+
+        GrammarCheckerWalker.prototype.checkFunctionOverloads = function (node, moduleElements) {
+            if (!this.inAmbientDeclaration && !this.syntaxTree.isDeclaration()) {
+                var moduleElementFullStart = this.childFullStart(node, moduleElements);
+
+                var inFunctionOverloadChain = false;
+                var functionOverloadChainName = null;
+
+                for (var i = 0, n = moduleElements.childCount(); i < n; i++) {
+                    var moduleElement = moduleElements.childAt(i);
+                    var lastElement = i === (n - 1);
+
+                    if (inFunctionOverloadChain) {
+                        if (moduleElement.kind() !== 129 /* FunctionDeclaration */) {
+                            this.pushDiagnostic1(moduleElementFullStart, moduleElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected);
+                            return true;
+                        }
+
+                        var functionDeclaration = moduleElement;
+                        if (functionDeclaration.identifier.valueText() !== functionOverloadChainName) {
+                            var identifierFullStart = moduleElementFullStart + TypeScript.Syntax.childOffset(moduleElement, functionDeclaration.identifier);
+                            this.pushDiagnostic1(identifierFullStart, functionDeclaration.identifier, TypeScript.DiagnosticCode.Function_overload_name_must_be_0, [functionOverloadChainName]);
+                            return true;
+                        }
+                    }
+
+                    if (moduleElement.kind() === 129 /* FunctionDeclaration */) {
+                        functionDeclaration = moduleElement;
+                        if (!TypeScript.SyntaxUtilities.containsToken(functionDeclaration.modifiers, 63 /* DeclareKeyword */)) {
+                            inFunctionOverloadChain = functionDeclaration.block === null;
+                            functionOverloadChainName = functionDeclaration.identifier.valueText();
+
+                            if (inFunctionOverloadChain) {
+                                if (lastElement) {
+                                    this.pushDiagnostic1(moduleElementFullStart, moduleElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected);
+                                    return true;
+                                } else {
+                                    var nextElement = moduleElements.childAt(i + 1);
+                                    if (nextElement.kind() === 129 /* FunctionDeclaration */) {
+                                        var nextFunction = nextElement;
+
+                                        if (nextFunction.identifier.valueText() !== functionOverloadChainName && nextFunction.block === null) {
+                                            var identifierFullStart = moduleElementFullStart + TypeScript.Syntax.childOffset(moduleElement, functionDeclaration.identifier);
+                                            this.pushDiagnostic1(identifierFullStart, functionDeclaration.identifier, TypeScript.DiagnosticCode.Function_implementation_expected);
+                                            return true;
+                                        }
+                                    }
+                                }
+                            }
+                        } else {
+                            inFunctionOverloadChain = false;
+                            functionOverloadChainName = "";
+                        }
+                    }
+
+                    moduleElementFullStart += moduleElement.fullWidth();
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkClassOverloads = function (node) {
+            if (!this.inAmbientDeclaration && !TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */)) {
+                var classElementFullStart = this.childFullStart(node, node.classElements);
+
+                var inFunctionOverloadChain = false;
+                var inConstructorOverloadChain = false;
+
+                var functionOverloadChainName = null;
+                var isInStaticOverloadChain = null;
+                var memberFunctionDeclaration = null;
+
+                for (var i = 0, n = node.classElements.childCount(); i < n; i++) {
+                    var classElement = node.classElements.childAt(i);
+                    var lastElement = i === (n - 1);
+                    var isStaticOverload = null;
+
+                    if (inFunctionOverloadChain) {
+                        if (classElement.kind() !== 135 /* MemberFunctionDeclaration */) {
+                            this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected);
+                            return true;
+                        }
+
+                        memberFunctionDeclaration = classElement;
+                        if (memberFunctionDeclaration.propertyName.valueText() !== functionOverloadChainName) {
+                            var propertyNameFullStart = classElementFullStart + TypeScript.Syntax.childOffset(classElement, memberFunctionDeclaration.propertyName);
+                            this.pushDiagnostic1(propertyNameFullStart, memberFunctionDeclaration.propertyName, TypeScript.DiagnosticCode.Function_overload_name_must_be_0, [functionOverloadChainName]);
+                            return true;
+                        }
+
+                        isStaticOverload = TypeScript.SyntaxUtilities.containsToken(memberFunctionDeclaration.modifiers, 58 /* StaticKeyword */);
+                        if (isStaticOverload !== isInStaticOverloadChain) {
+                            var propertyNameFullStart = classElementFullStart + TypeScript.Syntax.childOffset(classElement, memberFunctionDeclaration.propertyName);
+                            var diagnostic = isInStaticOverloadChain ? TypeScript.DiagnosticCode.Function_overload_must_be_static : TypeScript.DiagnosticCode.Function_overload_must_not_be_static;
+                            this.pushDiagnostic1(propertyNameFullStart, memberFunctionDeclaration.propertyName, diagnostic, null);
+                            return true;
+                        }
+                    } else if (inConstructorOverloadChain) {
+                        if (classElement.kind() !== 137 /* ConstructorDeclaration */) {
+                            this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Constructor_implementation_expected);
+                            return true;
+                        }
+                    }
+
+                    if (classElement.kind() === 135 /* MemberFunctionDeclaration */) {
+                        memberFunctionDeclaration = classElement;
+
+                        inFunctionOverloadChain = memberFunctionDeclaration.block === null;
+                        functionOverloadChainName = memberFunctionDeclaration.propertyName.valueText();
+                        isInStaticOverloadChain = TypeScript.SyntaxUtilities.containsToken(memberFunctionDeclaration.modifiers, 58 /* StaticKeyword */);
+
+                        if (inFunctionOverloadChain) {
+                            if (lastElement) {
+                                this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected);
+                                return true;
+                            } else {
+                                var nextElement = node.classElements.childAt(i + 1);
+                                if (nextElement.kind() === 135 /* MemberFunctionDeclaration */) {
+                                    var nextMemberFunction = nextElement;
+
+                                    if (nextMemberFunction.propertyName.valueText() !== functionOverloadChainName && nextMemberFunction.block === null) {
+                                        var propertyNameFullStart = classElementFullStart + TypeScript.Syntax.childOffset(classElement, memberFunctionDeclaration.propertyName);
+                                        this.pushDiagnostic1(propertyNameFullStart, memberFunctionDeclaration.propertyName, TypeScript.DiagnosticCode.Function_implementation_expected);
+                                        return true;
+                                    }
+                                }
+                            }
+                        }
+                    } else if (classElement.kind() === 137 /* ConstructorDeclaration */) {
+                        var constructorDeclaration = classElement;
+
+                        inConstructorOverloadChain = constructorDeclaration.block === null;
+                        if (lastElement && inConstructorOverloadChain) {
+                            this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Constructor_implementation_expected);
+                            return true;
+                        }
+                    }
+
+                    classElementFullStart += classElement.fullWidth();
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkForReservedName = function (parent, name, diagnosticKey) {
+            var nameFullStart = this.childFullStart(parent, name);
+            var token;
+            var tokenFullStart;
+
+            var current = name;
+            while (current !== null) {
+                if (current.kind() === 121 /* QualifiedName */) {
+                    var qualifiedName = current;
+                    token = qualifiedName.right;
+                    tokenFullStart = nameFullStart + this.childFullStart(qualifiedName, token);
+                    current = qualifiedName.left;
+                } else {
+                    TypeScript.Debug.assert(current.kind() === 11 /* IdentifierName */);
+                    token = current;
+                    tokenFullStart = nameFullStart;
+                    current = null;
+                }
+
+                switch (token.valueText()) {
+                    case "any":
+                    case "number":
+                    case "boolean":
+                    case "string":
+                    case "void":
+                        this.pushDiagnostic(tokenFullStart + token.leadingTriviaWidth(), token.width(), diagnosticKey, [token.valueText()]);
+                        return true;
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitClassDeclaration = function (node) {
+            if (this.checkForReservedName(node, node.identifier, TypeScript.DiagnosticCode.Class_name_cannot_be_0) || this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForRequiredDeclareModifier(node, node.classKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers) || this.checkClassDeclarationHeritageClauses(node) || this.checkClassOverloads(node)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */);
+            _super.prototype.visitClassDeclaration.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.checkInterfaceDeclarationHeritageClauses = function (node) {
+            var heritageClauseFullStart = this.childFullStart(node, node.heritageClauses);
+
+            var seenExtendsClause = false;
+
+            for (var i = 0, n = node.heritageClauses.childCount(); i < n; i++) {
+                TypeScript.Debug.assert(i <= 1);
+                var heritageClause = node.heritageClauses.childAt(i);
+
+                if (heritageClause.extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */) {
+                    if (seenExtendsClause) {
+                        this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.extends_clause_already_seen);
+                        return true;
+                    }
+
+                    seenExtendsClause = true;
+                } else {
+                    TypeScript.Debug.assert(heritageClause.extendsOrImplementsKeyword.tokenKind === 51 /* ImplementsKeyword */);
+                    this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.Interface_declaration_cannot_have_implements_clause);
+                    return true;
+                }
+
+                heritageClauseFullStart += heritageClause.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkInterfaceModifiers = function (modifiers) {
+            var modifierFullStart = this.position();
+
+            for (var i = 0, n = modifiers.childCount(); i < n; i++) {
+                var modifier = modifiers.childAt(i);
+                if (modifier.tokenKind === 63 /* DeclareKeyword */) {
+                    this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.declare_modifier_cannot_appear_on_an_interface_declaration);
+                    return true;
+                }
+
+                modifierFullStart += modifier.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitInterfaceDeclaration = function (node) {
+            if (this.checkForReservedName(node, node.identifier, TypeScript.DiagnosticCode.Interface_name_cannot_be_0) || this.checkInterfaceModifiers(node.modifiers) || this.checkModuleElementModifiers(node.modifiers) || this.checkInterfaceDeclarationHeritageClauses(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitInterfaceDeclaration.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkClassElementModifiers = function (list) {
+            var modifierFullStart = this.position();
+
+            var seenAccessibilityModifier = false;
+            var seenStaticModifier = false;
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var modifier = list.childAt(i);
+                if (modifier.tokenKind === 57 /* PublicKeyword */ || modifier.tokenKind === 55 /* PrivateKeyword */) {
+                    if (seenAccessibilityModifier) {
+                        this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Accessibility_modifier_already_seen);
+                        return true;
+                    }
+
+                    if (seenStaticModifier) {
+                        var previousToken = list.childAt(i - 1);
+                        this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_must_precede_1_modifier, [modifier.text(), previousToken.text()]);
+                        return true;
+                    }
+
+                    seenAccessibilityModifier = true;
+                } else if (modifier.tokenKind === 58 /* StaticKeyword */) {
+                    if (seenStaticModifier) {
+                        this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_already_seen, [modifier.text()]);
+                        return true;
+                    }
+
+                    seenStaticModifier = true;
+                } else {
+                    this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_class_element, [modifier.text()]);
+                    return true;
+                }
+
+                modifierFullStart += modifier.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitMemberVariableDeclaration = function (node) {
+            if (this.checkClassElementModifiers(node.modifiers)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitMemberVariableDeclaration.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitMemberFunctionDeclaration = function (node) {
+            if (this.checkClassElementModifiers(node.modifiers)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitMemberFunctionDeclaration.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkGetAccessorParameter = function (node, getKeyword, parameterList) {
+            var getKeywordFullStart = this.childFullStart(node, getKeyword);
+            if (parameterList.parameters.childCount() !== 0) {
+                this.pushDiagnostic1(getKeywordFullStart, getKeyword, TypeScript.DiagnosticCode.get_accessor_cannot_have_parameters);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitIndexMemberDeclaration = function (node) {
+            if (this.checkIndexMemberModifiers(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitIndexMemberDeclaration.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkIndexMemberModifiers = function (node) {
+            if (node.modifiers.childCount() > 0) {
+                var modifierFullStart = this.childFullStart(node, node.modifiers);
+                this.pushDiagnostic1(modifierFullStart, node.modifiers.childAt(0), TypeScript.DiagnosticCode.Modifiers_cannot_appear_here);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkEcmaScriptVersionIsAtLeast = function (parent, node, languageVersion, diagnosticKey) {
+            if (this.syntaxTree.parseOptions().languageVersion() < languageVersion) {
+                var nodeFullStart = this.childFullStart(parent, node);
+                this.pushDiagnostic1(nodeFullStart, node, diagnosticKey);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitObjectLiteralExpression = function (node) {
+            var savedInObjectLiteralExpression = this.inObjectLiteralExpression;
+            this.inObjectLiteralExpression = true;
+            _super.prototype.visitObjectLiteralExpression.call(this, node);
+            this.inObjectLiteralExpression = savedInObjectLiteralExpression;
+        };
+
+        GrammarCheckerWalker.prototype.visitGetAccessor = function (node) {
+            if (this.checkForAccessorDeclarationInAmbientContext(node) || this.checkEcmaScriptVersionIsAtLeast(node, node.getKeyword, 1 /* EcmaScript5 */, TypeScript.DiagnosticCode.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkClassElementModifiers(node.modifiers) || this.checkGetAccessorParameter(node, node.getKeyword, node.parameterList)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitGetAccessor.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkForAccessorDeclarationInAmbientContext = function (accessor) {
+            if (this.inAmbientDeclaration) {
+                this.pushDiagnostic1(this.position(), accessor, TypeScript.DiagnosticCode.Accessors_are_not_allowed_in_ambient_contexts, null);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkSetAccessorParameter = function (node, setKeyword, parameterList) {
+            var setKeywordFullStart = this.childFullStart(node, setKeyword);
+            if (parameterList.parameters.childCount() !== 1) {
+                this.pushDiagnostic1(setKeywordFullStart, setKeyword, TypeScript.DiagnosticCode.set_accessor_must_have_one_and_only_one_parameter);
+                return true;
+            }
+
+            var parameterListFullStart = this.childFullStart(node, parameterList);
+            var parameterFullStart = parameterListFullStart + TypeScript.Syntax.childOffset(parameterList, parameterList.openParenToken);
+            var parameter = parameterList.parameters.childAt(0);
+
+            if (parameter.questionToken) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.set_accessor_parameter_cannot_be_optional);
+                return true;
+            }
+
+            if (parameter.equalsValueClause) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.set_accessor_parameter_cannot_have_an_initializer);
+                return true;
+            }
+
+            if (parameter.dotDotDotToken) {
+                this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.set_accessor_cannot_have_rest_parameter);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitSetAccessor = function (node) {
+            if (this.checkForAccessorDeclarationInAmbientContext(node) || this.checkEcmaScriptVersionIsAtLeast(node, node.setKeyword, 1 /* EcmaScript5 */, TypeScript.DiagnosticCode.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkClassElementModifiers(node.modifiers) || this.checkSetAccessorParameter(node, node.setKeyword, node.parameterList)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitSetAccessor.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitEnumDeclaration = function (node) {
+            if (this.checkForReservedName(node, node.identifier, TypeScript.DiagnosticCode.Enum_name_cannot_be_0) || this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForRequiredDeclareModifier(node, node.enumKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers), this.checkEnumElements(node)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */);
+            _super.prototype.visitEnumDeclaration.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.checkEnumElements = function (node) {
+            var enumElementFullStart = this.childFullStart(node, node.enumElements);
+
+            var previousValueWasComputed = false;
+            for (var i = 0, n = node.enumElements.childCount(); i < n; i++) {
+                var child = node.enumElements.childAt(i);
+
+                if (i % 2 === 0) {
+                    var enumElement = child;
+
+                    if (!enumElement.equalsValueClause && previousValueWasComputed) {
+                        this.pushDiagnostic1(enumElementFullStart, enumElement, TypeScript.DiagnosticCode.Enum_member_must_have_initializer, null);
+                        return true;
+                    }
+
+                    if (enumElement.equalsValueClause) {
+                        var value = enumElement.equalsValueClause.value;
+                        previousValueWasComputed = !TypeScript.Syntax.isIntegerLiteral(value);
+                    }
+                }
+
+                enumElementFullStart += child.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitEnumElement = function (node) {
+            if (this.inAmbientDeclaration && node.equalsValueClause) {
+                var expression = node.equalsValueClause.value;
+                if (!TypeScript.Syntax.isIntegerLiteral(expression)) {
+                    this.pushDiagnostic1(this.childFullStart(node, node.equalsValueClause), node.equalsValueClause.firstToken(), TypeScript.DiagnosticCode.Ambient_enum_elements_can_only_have_integer_literal_initializers);
+                    this.skip(node);
+                    return;
+                }
+            }
+
+            _super.prototype.visitEnumElement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitInvocationExpression = function (node) {
+            if (node.expression.kind() === 50 /* SuperKeyword */ && node.argumentList.typeArgumentList !== null) {
+                this.pushDiagnostic1(this.position(), node, TypeScript.DiagnosticCode.super_invocation_cannot_have_type_arguments);
+            }
+
+            _super.prototype.visitInvocationExpression.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkModuleElementModifiers = function (modifiers) {
+            var modifierFullStart = this.position();
+            var seenExportModifier = false;
+            var seenDeclareModifier = false;
+
+            for (var i = 0, n = modifiers.childCount(); i < n; i++) {
+                var modifier = modifiers.childAt(i);
+                if (modifier.tokenKind === 57 /* PublicKeyword */ || modifier.tokenKind === 55 /* PrivateKeyword */ || modifier.tokenKind === 58 /* StaticKeyword */) {
+                    this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_module_element, [modifier.text()]);
+                    return true;
+                }
+
+                if (modifier.tokenKind === 63 /* DeclareKeyword */) {
+                    if (seenDeclareModifier) {
+                        this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Accessibility_modifier_already_seen);
+                        return;
+                    }
+
+                    seenDeclareModifier = true;
+                } else if (modifier.tokenKind === 47 /* ExportKeyword */) {
+                    if (seenExportModifier) {
+                        this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_already_seen, [modifier.text()]);
+                        return;
+                    }
+
+                    if (seenDeclareModifier) {
+                        this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_must_precede_1_modifier, [TypeScript.SyntaxFacts.getText(47 /* ExportKeyword */), TypeScript.SyntaxFacts.getText(63 /* DeclareKeyword */)]);
+                        return;
+                    }
+
+                    seenExportModifier = true;
+                }
+
+                modifierFullStart += modifier.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkForDisallowedImportDeclaration = function (node) {
+            var currentElementFullStart = this.childFullStart(node, node.moduleElements);
+
+            for (var i = 0, n = node.moduleElements.childCount(); i < n; i++) {
+                var child = node.moduleElements.childAt(i);
+                if (child.kind() === 133 /* ImportDeclaration */) {
+                    var importDeclaration = child;
+                    if (importDeclaration.moduleReference.kind() === 245 /* ExternalModuleReference */) {
+                        if (node.stringLiteral === null) {
+                            this.pushDiagnostic1(currentElementFullStart, importDeclaration, TypeScript.DiagnosticCode.Import_declarations_in_an_internal_module_cannot_reference_an_external_module, null);
+                        }
+                    }
+                }
+
+                currentElementFullStart += child.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkForDisallowedDeclareModifierOnImportDeclaration = function (modifiers) {
+            var declareToken = TypeScript.SyntaxUtilities.getToken(modifiers, 63 /* DeclareKeyword */);
+
+            if (declareToken) {
+                this.pushDiagnostic1(this.childFullStart(modifiers, declareToken), declareToken, TypeScript.DiagnosticCode.declare_modifier_not_allowed_on_import_declaration);
+                return true;
+            }
+        };
+
+        GrammarCheckerWalker.prototype.visitImportDeclaration = function (node) {
+            if (this.checkForDisallowedDeclareModifierOnImportDeclaration(node.modifiers) || this.checkModuleElementModifiers(node.modifiers)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitImportDeclaration.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitModuleDeclaration = function (node) {
+            if (this.checkForReservedName(node, node.name, TypeScript.DiagnosticCode.Module_name_cannot_be_0) || this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForRequiredDeclareModifier(node, node.moduleKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers) || this.checkForDisallowedImportDeclaration(node) || this.checkForDisallowedExports(node, node.moduleElements) || this.checkForMultipleExportAssignments(node, node.moduleElements)) {
+                this.skip(node);
+                return;
+            }
+
+            if (!TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */) && this.checkFunctionOverloads(node, node.moduleElements)) {
+                this.skip(node);
+                return;
+            }
+
+            if (node.stringLiteral) {
+                if (!this.inAmbientDeclaration && !TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */)) {
+                    var stringLiteralFullStart = this.childFullStart(node, node.stringLiteral);
+                    this.pushDiagnostic1(stringLiteralFullStart, node.stringLiteral, TypeScript.DiagnosticCode.Only_ambient_modules_can_use_quoted_names);
+                    this.skip(node);
+                    return;
+                }
+            }
+
+            if (!node.stringLiteral && this.checkForDisallowedExportAssignment(node)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */);
+            _super.prototype.visitModuleDeclaration.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.checkForDisallowedExports = function (node, moduleElements) {
+            var seenExportedElement = false;
+            for (var i = 0, n = moduleElements.childCount(); i < n; i++) {
+                var child = moduleElements.childAt(i);
+
+                if (TypeScript.SyntaxUtilities.hasExportKeyword(child)) {
+                    seenExportedElement = true;
+                    break;
+                }
+            }
+
+            var moduleElementFullStart = this.childFullStart(node, moduleElements);
+            if (seenExportedElement) {
+                for (var i = 0, n = moduleElements.childCount(); i < n; i++) {
+                    var child = moduleElements.childAt(i);
+
+                    if (child.kind() === 134 /* ExportAssignment */) {
+                        this.pushDiagnostic1(moduleElementFullStart, child, TypeScript.DiagnosticCode.Export_assignment_not_allowed_in_module_with_exported_element);
+                        return true;
+                    }
+
+                    moduleElementFullStart += child.fullWidth();
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkForMultipleExportAssignments = function (node, moduleElements) {
+            var moduleElementFullStart = this.childFullStart(node, moduleElements);
+            var seenExportAssignment = false;
+            var errorFound = false;
+            for (var i = 0, n = moduleElements.childCount(); i < n; i++) {
+                var child = moduleElements.childAt(i);
+                if (child.kind() === 134 /* ExportAssignment */) {
+                    if (seenExportAssignment) {
+                        this.pushDiagnostic1(moduleElementFullStart, child, TypeScript.DiagnosticCode.Module_cannot_have_multiple_export_assignments);
+                        errorFound = true;
+                    }
+                    seenExportAssignment = true;
+                }
+
+                moduleElementFullStart += child.fullWidth();
+            }
+
+            return errorFound;
+        };
+
+        GrammarCheckerWalker.prototype.checkForDisallowedExportAssignment = function (node) {
+            var moduleElementFullStart = this.childFullStart(node, node.moduleElements);
+
+            for (var i = 0, n = node.moduleElements.childCount(); i < n; i++) {
+                var child = node.moduleElements.childAt(i);
+
+                if (child.kind() === 134 /* ExportAssignment */) {
+                    this.pushDiagnostic1(moduleElementFullStart, child, TypeScript.DiagnosticCode.Export_assignment_cannot_be_used_in_internal_modules);
+
+                    return true;
+                }
+
+                moduleElementFullStart += child.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitBlock = function (node) {
+            if (this.inAmbientDeclaration || this.syntaxTree.isDeclaration()) {
+                this.pushDiagnostic1(this.position(), node.firstToken(), TypeScript.DiagnosticCode.Implementations_are_not_allowed_in_ambient_contexts);
+                this.skip(node);
+                return;
+            }
+
+            if (this.checkFunctionOverloads(node, node.statements)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedInBlock = this.inBlock;
+            this.inBlock = true;
+            _super.prototype.visitBlock.call(this, node);
+            this.inBlock = savedInBlock;
+        };
+
+        GrammarCheckerWalker.prototype.checkForStatementInAmbientContxt = function (node) {
+            if (this.inAmbientDeclaration || this.syntaxTree.isDeclaration()) {
+                this.pushDiagnostic1(this.position(), node.firstToken(), TypeScript.DiagnosticCode.Statements_are_not_allowed_in_ambient_contexts);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitBreakStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitBreakStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitContinueStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitContinueStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitDebuggerStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitDebuggerStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitDoStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitDoStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitEmptyStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitEmptyStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitExpressionStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitExpressionStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitForInStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node) || this.checkForInStatementVariableDeclaration(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitForInStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkForInStatementVariableDeclaration = function (node) {
+            if (node.variableDeclaration && node.variableDeclaration.variableDeclarators.nonSeparatorCount() > 1) {
+                var variableDeclarationFullStart = this.childFullStart(node, node.variableDeclaration);
+
+                this.pushDiagnostic1(variableDeclarationFullStart, node.variableDeclaration, TypeScript.DiagnosticCode.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitForStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitForStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitIfStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitIfStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitLabeledStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitLabeledStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitReturnStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitReturnStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitSwitchStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitSwitchStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitThrowStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitThrowStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitTryStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitTryStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitWhileStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitWhileStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitWithStatement = function (node) {
+            if (this.checkForStatementInAmbientContxt(node)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitWithStatement.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.checkForDisallowedModifiers = function (parent, modifiers) {
+            if (this.inBlock || this.inObjectLiteralExpression) {
+                if (modifiers.childCount() > 0) {
+                    var modifierFullStart = this.childFullStart(parent, modifiers);
+                    this.pushDiagnostic1(modifierFullStart, modifiers.childAt(0), TypeScript.DiagnosticCode.Modifiers_cannot_appear_here);
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitFunctionDeclaration = function (node) {
+            if (this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkForRequiredDeclareModifier(node, node.functionKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */);
+            _super.prototype.visitFunctionDeclaration.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.visitVariableStatement = function (node) {
+            if (this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkForRequiredDeclareModifier(node, node.variableDeclaration, node.modifiers) || this.checkModuleElementModifiers(node.modifiers)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */);
+            _super.prototype.visitVariableStatement.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.checkListSeparators = function (parent, list, kind) {
+            var currentElementFullStart = this.childFullStart(parent, list);
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var child = list.childAt(i);
+                if (i % 2 === 1 && child.kind() !== kind) {
+                    this.pushDiagnostic1(currentElementFullStart, child, TypeScript.DiagnosticCode._0_expected, [TypeScript.SyntaxFacts.getText(kind)]);
+                }
+
+                currentElementFullStart += child.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitObjectType = function (node) {
+            if (this.checkListSeparators(node, node.typeMembers, 78 /* SemicolonToken */)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = true;
+            _super.prototype.visitObjectType.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.visitArrayType = function (node) {
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = true;
+            _super.prototype.visitArrayType.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.visitFunctionType = function (node) {
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = true;
+            _super.prototype.visitFunctionType.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.visitConstructorType = function (node) {
+            var savedInAmbientDeclaration = this.inAmbientDeclaration;
+            this.inAmbientDeclaration = true;
+            _super.prototype.visitConstructorType.call(this, node);
+            this.inAmbientDeclaration = savedInAmbientDeclaration;
+        };
+
+        GrammarCheckerWalker.prototype.visitVariableDeclarator = function (node) {
+            if (this.inAmbientDeclaration && node.equalsValueClause) {
+                this.pushDiagnostic1(this.childFullStart(node, node.equalsValueClause), node.equalsValueClause.firstToken(), TypeScript.DiagnosticCode.Initializers_are_not_allowed_in_ambient_contexts);
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitVariableDeclarator.call(this, node);
+        };
+
+        GrammarCheckerWalker.prototype.visitConstructorDeclaration = function (node) {
+            if (this.checkClassElementModifiers(node.modifiers) || this.checkConstructorModifiers(node.modifiers) || this.checkConstructorTypeParameterList(node) || this.checkConstructorTypeAnnotation(node)) {
+                this.skip(node);
+                return;
+            }
+
+            var savedCurrentConstructor = this.currentConstructor;
+            this.currentConstructor = node;
+            _super.prototype.visitConstructorDeclaration.call(this, node);
+            this.currentConstructor = savedCurrentConstructor;
+        };
+
+        GrammarCheckerWalker.prototype.checkConstructorModifiers = function (modifiers) {
+            var currentElementFullStart = this.position();
+
+            for (var i = 0, n = modifiers.childCount(); i < n; i++) {
+                var child = modifiers.childAt(i);
+                if (child.kind() !== 57 /* PublicKeyword */) {
+                    this.pushDiagnostic1(currentElementFullStart, child, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_constructor_declaration, [TypeScript.SyntaxFacts.getText(child.kind())]);
+                    return true;
+                }
+
+                currentElementFullStart += child.fullWidth();
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkConstructorTypeParameterList = function (node) {
+            var currentElementFullStart = this.position();
+
+            if (node.callSignature.typeParameterList) {
+                var callSignatureFullStart = this.childFullStart(node, node.callSignature);
+                var typeParameterListFullStart = callSignatureFullStart + TypeScript.Syntax.childOffset(node.callSignature, node.callSignature.typeAnnotation);
+                this.pushDiagnostic1(callSignatureFullStart, node.callSignature.typeParameterList, TypeScript.DiagnosticCode.Type_parameters_cannot_appear_on_a_constructor_declaration);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.checkConstructorTypeAnnotation = function (node) {
+            var currentElementFullStart = this.position();
+
+            if (node.callSignature.typeAnnotation) {
+                var callSignatureFullStart = this.childFullStart(node, node.callSignature);
+                var typeAnnotationFullStart = callSignatureFullStart + TypeScript.Syntax.childOffset(node.callSignature, node.callSignature.typeAnnotation);
+                this.pushDiagnostic1(typeAnnotationFullStart, node.callSignature.typeAnnotation, TypeScript.DiagnosticCode.Type_annotation_cannot_appear_on_a_constructor_declaration);
+                return true;
+            }
+
+            return false;
+        };
+
+        GrammarCheckerWalker.prototype.visitSourceUnit = function (node) {
+            if (this.checkFunctionOverloads(node, node.moduleElements) || this.checkForDisallowedExports(node, node.moduleElements) || this.checkForMultipleExportAssignments(node, node.moduleElements)) {
+                this.skip(node);
+                return;
+            }
+
+            _super.prototype.visitSourceUnit.call(this, node);
+        };
+        return GrammarCheckerWalker;
+    })(TypeScript.PositionTrackingWalker);
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var Unicode = (function () {
+        function Unicode() {
+        }
+        Unicode.lookupInUnicodeMap = function (code, map) {
+            if (code < map[0]) {
+                return false;
+            }
+
+            var lo = 0;
+            var hi = map.length;
+            var mid;
+
+            while (lo + 1 < hi) {
+                mid = lo + (hi - lo) / 2;
+
+                mid -= mid % 2;
+                if (map[mid] <= code && code <= map[mid + 1]) {
+                    return true;
+                }
+
+                if (code < map[mid]) {
+                    hi = mid;
+                } else {
+                    lo = mid + 2;
+                }
+            }
+
+            return false;
+        };
+
+        Unicode.isIdentifierStart = function (code, languageVersion) {
+            if (languageVersion === 0 /* EcmaScript3 */) {
+                return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES3IdentifierStart);
+            } else if (languageVersion === 1 /* EcmaScript5 */) {
+                return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES5IdentifierStart);
+            } else {
+                throw TypeScript.Errors.argumentOutOfRange("languageVersion");
+            }
+        };
+
+        Unicode.isIdentifierPart = function (code, languageVersion) {
+            if (languageVersion === 0 /* EcmaScript3 */) {
+                return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES3IdentifierPart);
+            } else if (languageVersion === 1 /* EcmaScript5 */) {
+                return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES5IdentifierPart);
+            } else {
+                throw TypeScript.Errors.argumentOutOfRange("languageVersion");
+            }
+        };
+        Unicode.unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
+        Unicode.unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
+
+        Unicode.unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
+        Unicode.unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
+        return Unicode;
+    })();
+    TypeScript.Unicode = Unicode;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (CompilerDiagnostics) {
+        CompilerDiagnostics.debug = false;
+
+        CompilerDiagnostics.diagnosticWriter = null;
+
+        CompilerDiagnostics.analysisPass = 0;
+
+        function Alert(output) {
+            if (CompilerDiagnostics.diagnosticWriter) {
+                CompilerDiagnostics.diagnosticWriter.Alert(output);
+            }
+        }
+        CompilerDiagnostics.Alert = Alert;
+
+        function debugPrint(s) {
+            if (CompilerDiagnostics.debug) {
+                Alert(s);
+            }
+        }
+        CompilerDiagnostics.debugPrint = debugPrint;
+
+        function assert(condition, s) {
+            if (CompilerDiagnostics.debug) {
+                if (!condition) {
+                    Alert(s);
+                }
+            }
+        }
+        CompilerDiagnostics.assert = assert;
+    })(TypeScript.CompilerDiagnostics || (TypeScript.CompilerDiagnostics = {}));
+    var CompilerDiagnostics = TypeScript.CompilerDiagnostics;
+
+    var NullLogger = (function () {
+        function NullLogger() {
+        }
+        NullLogger.prototype.information = function () {
+            return false;
+        };
+        NullLogger.prototype.debug = function () {
+            return false;
+        };
+        NullLogger.prototype.warning = function () {
+            return false;
+        };
+        NullLogger.prototype.error = function () {
+            return false;
+        };
+        NullLogger.prototype.fatal = function () {
+            return false;
+        };
+        NullLogger.prototype.log = function (s) {
+        };
+        return NullLogger;
+    })();
+    TypeScript.NullLogger = NullLogger;
+
+    function timeFunction(logger, funcDescription, func) {
+        var start = (new Date()).getTime();
+        var result = func();
+        var end = (new Date()).getTime();
+        if (logger.information()) {
+            logger.log(funcDescription + " completed in " + (end - start) + " msec");
+        }
+        return result;
+    }
+    TypeScript.timeFunction = timeFunction;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var Document = (function () {
+        function Document(_compiler, _semanticInfoChain, fileName, referencedFiles, _scriptSnapshot, byteOrderMark, version, isOpen, _syntaxTree, _topLevelDecl) {
+            this._compiler = _compiler;
+            this._semanticInfoChain = _semanticInfoChain;
+            this.fileName = fileName;
+            this.referencedFiles = referencedFiles;
+            this._scriptSnapshot = _scriptSnapshot;
+            this.byteOrderMark = byteOrderMark;
+            this.version = version;
+            this.isOpen = isOpen;
+            this._syntaxTree = _syntaxTree;
+            this._topLevelDecl = _topLevelDecl;
+            this._diagnostics = null;
+            this._bloomFilter = null;
+            this._sourceUnit = null;
+            this._lineMap = null;
+            this._declASTMap = [];
+            this._astDeclMap = [];
+            this._amdDependencies = undefined;
+            this._externalModuleIndicatorSpan = undefined;
+        }
+        Document.prototype.invalidate = function () {
+            this._declASTMap.length = 0;
+            this._astDeclMap.length = 0;
+            this._topLevelDecl = null;
+
+            this._syntaxTree = null;
+            this._sourceUnit = null;
+            this._diagnostics = null;
+            this._bloomFilter = null;
+        };
+
+        Document.prototype.isDeclareFile = function () {
+            return TypeScript.isDTSFile(this.fileName);
+        };
+
+        Document.prototype.cacheSyntaxTreeInfo = function (syntaxTree) {
+            var start = new Date().getTime();
+            this._diagnostics = syntaxTree.diagnostics();
+            TypeScript.syntaxDiagnosticsTime += new Date().getTime() - start;
+
+            this._lineMap = syntaxTree.lineMap();
+
+            var sourceUnit = syntaxTree.sourceUnit();
+            var leadingTrivia = sourceUnit.leadingTrivia();
+
+            this._externalModuleIndicatorSpan = this.getImplicitImportSpan(leadingTrivia) || this.getTopLevelImportOrExportSpan(sourceUnit);
+
+            var amdDependencies = [];
+            for (var i = 0, n = leadingTrivia.count(); i < n; i++) {
+                var trivia = leadingTrivia.syntaxTriviaAt(i);
+                if (trivia.isComment()) {
+                    var amdDependency = this.getAmdDependency(trivia.fullText());
+                    if (amdDependency) {
+                        amdDependencies.push(amdDependency);
+                    }
+                }
+            }
+
+            this._amdDependencies = amdDependencies;
+        };
+
+        Document.prototype.getAmdDependency = function (comment) {
+            var amdDependencyRegEx = /^\/\/\/\s*<amd-dependency\s+path=('|")(.+?)\1/gim;
+            var match = amdDependencyRegEx.exec(comment);
+            return match ? match[2] : null;
+        };
+
+        Document.prototype.getImplicitImportSpan = function (sourceUnitLeadingTrivia) {
+            var position = 0;
+
+            for (var i = 0, n = sourceUnitLeadingTrivia.count(); i < n; i++) {
+                var trivia = sourceUnitLeadingTrivia.syntaxTriviaAt(i);
+
+                if (trivia.isComment()) {
+                    var span = this.getImplicitImportSpanWorker(trivia, position);
+                    if (span) {
+                        return span;
+                    }
+                }
+
+                position += trivia.fullWidth();
+            }
+
+            return null;
+        };
+
+        Document.prototype.getImplicitImportSpanWorker = function (trivia, position) {
+            var implicitImportRegEx = /^(\/\/\/\s*<implicit-import\s*)*\/>/gim;
+            var match = implicitImportRegEx.exec(trivia.fullText());
+
+            if (match) {
+                return new TypeScript.TextSpan(position, trivia.fullWidth());
+            }
+
+            return null;
+        };
+
+        Document.prototype.getTopLevelImportOrExportSpan = function (node) {
+            var firstToken;
+            var position = 0;
+
+            for (var i = 0, n = node.moduleElements.childCount(); i < n; i++) {
+                var moduleElement = node.moduleElements.childAt(i);
+
+                firstToken = moduleElement.firstToken();
+                if (firstToken !== null && firstToken.tokenKind === 47 /* ExportKeyword */) {
+                    return new TypeScript.TextSpan(position + firstToken.leadingTriviaWidth(), firstToken.width());
+                }
+
+                if (moduleElement.kind() === 133 /* ImportDeclaration */) {
+                    var importDecl = moduleElement;
+                    if (importDecl.moduleReference.kind() === 245 /* ExternalModuleReference */) {
+                        return new TypeScript.TextSpan(position + importDecl.leadingTriviaWidth(), importDecl.width());
+                    }
+                }
+
+                position += moduleElement.fullWidth();
+            }
+
+            return null;
+            ;
+        };
+
+        Document.prototype.sourceUnit = function () {
+            if (!this._sourceUnit) {
+                var start = new Date().getTime();
+                var syntaxTree = this.syntaxTree();
+                this._sourceUnit = TypeScript.SyntaxTreeToAstVisitor.visit(syntaxTree, this.fileName, this._compiler.compilationSettings(), this.isOpen);
+                TypeScript.astTranslationTime += new Date().getTime() - start;
+
+                if (!this.isOpen) {
+                    this._syntaxTree = null;
+                }
+            }
+
+            return this._sourceUnit;
+        };
+
+        Document.prototype.diagnostics = function () {
+            if (this._diagnostics === null) {
+                this.syntaxTree();
+                TypeScript.Debug.assert(this._diagnostics);
+            }
+
+            return this._diagnostics;
+        };
+
+        Document.prototype.lineMap = function () {
+            if (this._lineMap === null) {
+                this.syntaxTree();
+                TypeScript.Debug.assert(this._lineMap);
+            }
+
+            return this._lineMap;
+        };
+
+        Document.prototype.isExternalModule = function () {
+            return this.externalModuleIndicatorSpan() !== null;
+        };
+
+        Document.prototype.externalModuleIndicatorSpan = function () {
+            if (this._externalModuleIndicatorSpan === undefined) {
+                this.syntaxTree();
+                TypeScript.Debug.assert(this._externalModuleIndicatorSpan !== undefined);
+            }
+
+            return this._externalModuleIndicatorSpan;
+        };
+
+        Document.prototype.amdDependencies = function () {
+            if (this._amdDependencies === undefined) {
+                this.syntaxTree();
+                TypeScript.Debug.assert(this._amdDependencies !== undefined);
+            }
+
+            return this._amdDependencies;
+        };
+
+        Document.prototype.syntaxTree = function () {
+            var result = this._syntaxTree;
+            if (!result) {
+                var start = new Date().getTime();
+
+                result = TypeScript.Parser.parse(this.fileName, TypeScript.SimpleText.fromScriptSnapshot(this._scriptSnapshot), TypeScript.isDTSFile(this.fileName), TypeScript.getParseOptions(this._compiler.compilationSettings()));
+
+                TypeScript.syntaxTreeParseTime += new Date().getTime() - start;
+
+                if (this.isOpen || !this._sourceUnit) {
+                    this._syntaxTree = result;
+                }
+            }
+
+            this.cacheSyntaxTreeInfo(result);
+            return result;
+        };
+
+        Document.prototype.bloomFilter = function () {
+            if (!this._bloomFilter) {
+                var identifiers = TypeScript.createIntrinsicsObject();
+                var pre = function (cur) {
+                    if (TypeScript.ASTHelpers.isValidAstNode(cur)) {
+                        if (cur.kind() === 11 /* IdentifierName */) {
+                            var nodeText = cur.valueText();
+
+                            identifiers[nodeText] = true;
+                        }
+                    }
+                };
+
+                TypeScript.getAstWalkerFactory().simpleWalk(this.sourceUnit(), pre, null, identifiers);
+
+                var identifierCount = 0;
+                for (var name in identifiers) {
+                    if (identifiers[name]) {
+                        identifierCount++;
+                    }
+                }
+
+                this._bloomFilter = new TypeScript.BloomFilter(identifierCount);
+                this._bloomFilter.addKeys(identifiers);
+            }
+            return this._bloomFilter;
+        };
+
+        Document.prototype.emitToOwnOutputFile = function () {
+            return !this._compiler.compilationSettings().outFileOption() || this.isExternalModule();
+        };
+
+        Document.prototype.update = function (scriptSnapshot, version, isOpen, textChangeRange) {
+            var oldSyntaxTree = this._syntaxTree;
+
+            if (textChangeRange !== null && TypeScript.Debug.shouldAssert(1 /* Normal */)) {
+                var oldText = this._scriptSnapshot;
+                var newText = scriptSnapshot;
+
+                TypeScript.Debug.assert((oldText.getLength() - textChangeRange.span().length() + textChangeRange.newLength()) === newText.getLength());
+
+                if (TypeScript.Debug.shouldAssert(3 /* VeryAggressive */)) {
+                    var oldTextPrefix = oldText.getText(0, textChangeRange.span().start());
+                    var newTextPrefix = newText.getText(0, textChangeRange.span().start());
+                    TypeScript.Debug.assert(oldTextPrefix === newTextPrefix);
+
+                    var oldTextSuffix = oldText.getText(textChangeRange.span().end(), oldText.getLength());
+                    var newTextSuffix = newText.getText(textChangeRange.newSpan().end(), newText.getLength());
+                    TypeScript.Debug.assert(oldTextSuffix === newTextSuffix);
+                }
+            }
+
+            var text = TypeScript.SimpleText.fromScriptSnapshot(scriptSnapshot);
+
+            var newSyntaxTree = textChangeRange === null || oldSyntaxTree === null ? TypeScript.Parser.parse(this.fileName, text, TypeScript.isDTSFile(this.fileName), TypeScript.getParseOptions(this._compiler.compilationSettings())) : TypeScript.Parser.incrementalParse(oldSyntaxTree, textChangeRange, text);
+
+            return new Document(this._compiler, this._semanticInfoChain, this.fileName, this.referencedFiles, scriptSnapshot, this.byteOrderMark, version, isOpen, newSyntaxTree, null);
+        };
+
+        Document.create = function (compiler, semanticInfoChain, fileName, scriptSnapshot, byteOrderMark, version, isOpen, referencedFiles) {
+            return new Document(compiler, semanticInfoChain, fileName, referencedFiles, scriptSnapshot, byteOrderMark, version, isOpen, null, null);
+        };
+
+        Document.prototype.topLevelDecl = function () {
+            if (this._topLevelDecl === null) {
+                this._topLevelDecl = TypeScript.DeclarationCreator.create(this, this._semanticInfoChain, this._compiler.compilationSettings());
+            }
+
+            return this._topLevelDecl;
+        };
+
+        Document.prototype._getDeclForAST = function (ast) {
+            this.topLevelDecl();
+            return this._astDeclMap[ast.syntaxID()];
+        };
+
+        Document.prototype.getEnclosingDecl = function (ast) {
+            if (ast.kind() === 120 /* SourceUnit */) {
+                return this._getDeclForAST(ast);
+            }
+
+            ast = ast.parent;
+            var decl = null;
+            while (ast) {
+                decl = this._getDeclForAST(ast);
+
+                if (decl) {
+                    break;
+                }
+
+                ast = ast.parent;
+            }
+
+            return decl._getEnclosingDeclFromParentDecl();
+        };
+
+        Document.prototype._setDeclForAST = function (ast, decl) {
+            TypeScript.Debug.assert(decl.fileName() === this.fileName);
+            this._astDeclMap[ast.syntaxID()] = decl;
+        };
+
+        Document.prototype._getASTForDecl = function (decl) {
+            return this._declASTMap[decl.declID];
+        };
+
+        Document.prototype._setASTForDecl = function (decl, ast) {
+            TypeScript.Debug.assert(decl.fileName() === this.fileName);
+            this._declASTMap[decl.declID] = ast;
+        };
+        return Document;
+    })();
+    TypeScript.Document = Document;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    function hasFlag(val, flag) {
+        return (val & flag) !== 0;
+    }
+    TypeScript.hasFlag = hasFlag;
+
+    (function (TypeRelationshipFlags) {
+        TypeRelationshipFlags[TypeRelationshipFlags["SuccessfulComparison"] = 0] = "SuccessfulComparison";
+        TypeRelationshipFlags[TypeRelationshipFlags["RequiredPropertyIsMissing"] = 1 << 1] = "RequiredPropertyIsMissing";
+        TypeRelationshipFlags[TypeRelationshipFlags["IncompatibleSignatures"] = 1 << 2] = "IncompatibleSignatures";
+        TypeRelationshipFlags[TypeRelationshipFlags["SourceSignatureHasTooManyParameters"] = 3] = "SourceSignatureHasTooManyParameters";
+        TypeRelationshipFlags[TypeRelationshipFlags["IncompatibleReturnTypes"] = 1 << 4] = "IncompatibleReturnTypes";
+        TypeRelationshipFlags[TypeRelationshipFlags["IncompatiblePropertyTypes"] = 1 << 5] = "IncompatiblePropertyTypes";
+        TypeRelationshipFlags[TypeRelationshipFlags["IncompatibleParameterTypes"] = 1 << 6] = "IncompatibleParameterTypes";
+        TypeRelationshipFlags[TypeRelationshipFlags["InconsistantPropertyAccesibility"] = 1 << 7] = "InconsistantPropertyAccesibility";
+    })(TypeScript.TypeRelationshipFlags || (TypeScript.TypeRelationshipFlags = {}));
+    var TypeRelationshipFlags = TypeScript.TypeRelationshipFlags;
+
+    (function (ModuleGenTarget) {
+        ModuleGenTarget[ModuleGenTarget["Unspecified"] = 0] = "Unspecified";
+        ModuleGenTarget[ModuleGenTarget["Synchronous"] = 1] = "Synchronous";
+        ModuleGenTarget[ModuleGenTarget["Asynchronous"] = 2] = "Asynchronous";
+    })(TypeScript.ModuleGenTarget || (TypeScript.ModuleGenTarget = {}));
+    var ModuleGenTarget = TypeScript.ModuleGenTarget;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var proto = "__proto__";
+
+    var BlockIntrinsics = (function () {
+        function BlockIntrinsics() {
+            this.prototype = undefined;
+            this.toString = undefined;
+            this.toLocaleString = undefined;
+            this.valueOf = undefined;
+            this.hasOwnProperty = undefined;
+            this.propertyIsEnumerable = undefined;
+            this.isPrototypeOf = undefined;
+            this["constructor"] = undefined;
+
+            this[proto] = null;
+            this[proto] = undefined;
+        }
+        return BlockIntrinsics;
+    })();
+
+    function createIntrinsicsObject() {
+        return new BlockIntrinsics();
+    }
+    TypeScript.createIntrinsicsObject = createIntrinsicsObject;
+
+    var StringHashTable = (function () {
+        function StringHashTable() {
+            this.itemCount = 0;
+            this.table = createIntrinsicsObject();
+        }
+        StringHashTable.prototype.getAllKeys = function () {
+            var result = [];
+
+            for (var k in this.table) {
+                if (this.table[k] !== undefined) {
+                    result.push(k);
+                }
+            }
+
+            return result;
+        };
+
+        StringHashTable.prototype.add = function (key, data) {
+            if (this.table[key] !== undefined) {
+                return false;
+            }
+
+            this.table[key] = data;
+            this.itemCount++;
+            return true;
+        };
+
+        StringHashTable.prototype.addOrUpdate = function (key, data) {
+            if (this.table[key] !== undefined) {
+                this.table[key] = data;
+                return false;
+            }
+
+            this.table[key] = data;
+            this.itemCount++;
+            return true;
+        };
+
+        StringHashTable.prototype.map = function (fn, context) {
+            for (var k in this.table) {
+                var data = this.table[k];
+
+                if (data !== undefined) {
+                    fn(k, this.table[k], context);
+                }
+            }
+        };
+
+        StringHashTable.prototype.every = function (fn, context) {
+            for (var k in this.table) {
+                var data = this.table[k];
+
+                if (data !== undefined) {
+                    if (!fn(k, this.table[k], context)) {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        };
+
+        StringHashTable.prototype.some = function (fn, context) {
+            for (var k in this.table) {
+                var data = this.table[k];
+
+                if (data !== undefined) {
+                    if (fn(k, this.table[k], context)) {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        StringHashTable.prototype.count = function () {
+            return this.itemCount;
+        };
+
+        StringHashTable.prototype.lookup = function (key) {
+            var data = this.table[key];
+            return data === undefined ? null : data;
+        };
+
+        StringHashTable.prototype.remove = function (key) {
+            if (this.table[key] !== undefined) {
+                this.table[key] = undefined;
+                this.itemCount--;
+            }
+        };
+        return StringHashTable;
+    })();
+    TypeScript.StringHashTable = StringHashTable;
+
+    var IdentiferNameHashTable = (function (_super) {
+        __extends(IdentiferNameHashTable, _super);
+        function IdentiferNameHashTable() {
+            _super.apply(this, arguments);
+        }
+        IdentiferNameHashTable.prototype.getAllKeys = function () {
+            var result = [];
+
+            _super.prototype.map.call(this, function (k, v, c) {
+                if (v !== undefined) {
+                    result.push(k.substring(1));
+                }
+            }, null);
+
+            return result;
+        };
+
+        IdentiferNameHashTable.prototype.add = function (key, data) {
+            return _super.prototype.add.call(this, "#" + key, data);
+        };
+
+        IdentiferNameHashTable.prototype.addOrUpdate = function (key, data) {
+            return _super.prototype.addOrUpdate.call(this, "#" + key, data);
+        };
+
+        IdentiferNameHashTable.prototype.map = function (fn, context) {
+            return _super.prototype.map.call(this, function (k, v, c) {
+                return fn(k.substring(1), v, c);
+            }, context);
+        };
+
+        IdentiferNameHashTable.prototype.every = function (fn, context) {
+            return _super.prototype.every.call(this, function (k, v, c) {
+                return fn(k.substring(1), v, c);
+            }, context);
+        };
+
+        IdentiferNameHashTable.prototype.some = function (fn, context) {
+            return _super.prototype.some.call(this, function (k, v, c) {
+                return fn(k.substring(1), v, c);
+            }, context);
+        };
+
+        IdentiferNameHashTable.prototype.lookup = function (key) {
+            return _super.prototype.lookup.call(this, "#" + key);
+        };
+        return IdentiferNameHashTable;
+    })(StringHashTable);
+    TypeScript.IdentiferNameHashTable = IdentiferNameHashTable;
+})(TypeScript || (TypeScript = {}));
+
+var TypeScript;
+(function (TypeScript) {
+    (function (ASTHelpers) {
+        function scriptIsElided(sourceUnit) {
+            return TypeScript.isDTSFile(sourceUnit.fileName()) || moduleMembersAreElided(sourceUnit.moduleElements);
+        }
+        ASTHelpers.scriptIsElided = scriptIsElided;
+
+        function moduleIsElided(declaration) {
+            return TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */) || moduleMembersAreElided(declaration.moduleElements);
+        }
+        ASTHelpers.moduleIsElided = moduleIsElided;
+
+        function moduleMembersAreElided(members) {
+            for (var i = 0, n = members.childCount(); i < n; i++) {
+                var member = members.childAt(i);
+
+                if (member.kind() === 130 /* ModuleDeclaration */) {
+                    if (!moduleIsElided(member)) {
+                        return false;
+                    }
+                } else if (member.kind() !== 128 /* InterfaceDeclaration */) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        function enumIsElided(declaration) {
+            if (TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */)) {
+                return true;
+            }
+
+            return false;
+        }
+        ASTHelpers.enumIsElided = enumIsElided;
+
+        function isValidAstNode(ast) {
+            if (!ast)
+                return false;
+
+            if (ast.start() === -1 || ast.end() === -1)
+                return false;
+
+            return true;
+        }
+        ASTHelpers.isValidAstNode = isValidAstNode;
+
+        function getAstAtPosition(script, pos, useTrailingTriviaAsLimChar, forceInclusive) {
+            if (typeof useTrailingTriviaAsLimChar === "undefined") { useTrailingTriviaAsLimChar = true; }
+            if (typeof forceInclusive === "undefined") { forceInclusive = false; }
+            var top = null;
+
+            var pre = function (cur, walker) {
+                if (isValidAstNode(cur)) {
+                    var isInvalid1 = cur.kind() === 149 /* ExpressionStatement */ && cur.width() === 0;
+
+                    if (isInvalid1) {
+                        walker.options.goChildren = false;
+                    } else {
+                        var inclusive = forceInclusive || cur.kind() === 11 /* IdentifierName */ || cur.kind() === 212 /* MemberAccessExpression */ || cur.kind() === 121 /* QualifiedName */ || cur.kind() === 224 /* VariableDeclaration */ || cur.kind() === 225 /* VariableDeclarator */ || cur.kind() === 213 /* InvocationExpression */ || pos === script.end() + script.trailingTriviaWidth();
+
+                        var minChar = cur.start();
+                        var limChar = cur.end() + (useTrailingTriviaAsLimChar ? cur.trailingTriviaWidth() : 0) + (inclusive ? 1 : 0);
+                        if (pos >= minChar && pos < limChar) {
+                            if ((cur.kind() !== 1 /* List */ && cur.kind() !== 2 /* SeparatedList */) || cur.end() > cur.start()) {
+                                if (top === null) {
+                                    top = cur;
+                                } else if (cur.start() >= top.start() && (cur.end() + (useTrailingTriviaAsLimChar ? cur.trailingTriviaWidth() : 0)) <= (top.end() + (useTrailingTriviaAsLimChar ? top.trailingTriviaWidth() : 0))) {
+                                    if (top.width() !== 0 || cur.width() !== 0) {
+                                        top = cur;
+                                    }
+                                }
+                            }
+                        }
+
+                        walker.options.goChildren = (minChar <= pos && pos <= limChar);
+                    }
+                }
+            };
+
+            TypeScript.getAstWalkerFactory().walk(script, pre);
+            return top;
+        }
+        ASTHelpers.getAstAtPosition = getAstAtPosition;
+
+        function getExtendsHeritageClause(clauses) {
+            if (!clauses) {
+                return null;
+            }
+
+            return clauses.firstOrDefault(function (c) {
+                return c.typeNames.nonSeparatorCount() > 0 && c.kind() === 230 /* ExtendsHeritageClause */;
+            });
+        }
+        ASTHelpers.getExtendsHeritageClause = getExtendsHeritageClause;
+
+        function getImplementsHeritageClause(clauses) {
+            if (!clauses) {
+                return null;
+            }
+
+            return clauses.firstOrDefault(function (c) {
+                return c.typeNames.nonSeparatorCount() > 0 && c.kind() === 231 /* ImplementsHeritageClause */;
+            });
+        }
+        ASTHelpers.getImplementsHeritageClause = getImplementsHeritageClause;
+
+        function isCallExpression(ast) {
+            return (ast && ast.kind() === 213 /* InvocationExpression */) || (ast && ast.kind() === 216 /* ObjectCreationExpression */);
+        }
+        ASTHelpers.isCallExpression = isCallExpression;
+
+        function isCallExpressionTarget(ast) {
+            if (!ast) {
+                return false;
+            }
+
+            var current = ast;
+
+            while (current && current.parent) {
+                if (current.parent.kind() === 212 /* MemberAccessExpression */ && current.parent.name === current) {
+                    current = current.parent;
+                    continue;
+                }
+
+                break;
+            }
+
+            if (current && current.parent) {
+                if (current.parent.kind() === 213 /* InvocationExpression */ || current.parent.kind() === 216 /* ObjectCreationExpression */) {
+                    return current === current.parent.expression;
+                }
+            }
+
+            return false;
+        }
+        ASTHelpers.isCallExpressionTarget = isCallExpressionTarget;
+
+        function isNameOfSomeDeclaration(ast) {
+            if (ast === null || ast.parent === null) {
+                return false;
+            }
+            if (ast.kind() !== 11 /* IdentifierName */) {
+                return false;
+            }
+
+            switch (ast.parent.kind()) {
+                case 131 /* ClassDeclaration */:
+                    return ast.parent.identifier === ast;
+                case 128 /* InterfaceDeclaration */:
+                    return ast.parent.identifier === ast;
+                case 132 /* EnumDeclaration */:
+                    return ast.parent.identifier === ast;
+                case 130 /* ModuleDeclaration */:
+                    return ast.parent.name === ast || ast.parent.stringLiteral === ast;
+                case 225 /* VariableDeclarator */:
+                    return ast.parent.propertyName === ast;
+                case 129 /* FunctionDeclaration */:
+                    return ast.parent.identifier === ast;
+                case 135 /* MemberFunctionDeclaration */:
+                    return ast.parent.propertyName === ast;
+                case 242 /* Parameter */:
+                    return ast.parent.identifier === ast;
+                case 238 /* TypeParameter */:
+                    return ast.parent.identifier === ast;
+                case 240 /* SimplePropertyAssignment */:
+                    return ast.parent.propertyName === ast;
+                case 241 /* FunctionPropertyAssignment */:
+                    return ast.parent.propertyName === ast;
+                case 243 /* EnumElement */:
+                    return ast.parent.propertyName === ast;
+                case 133 /* ImportDeclaration */:
+                    return ast.parent.identifier === ast;
+            }
+
+            return false;
+        }
+
+        function isDeclarationASTOrDeclarationNameAST(ast) {
+            return isNameOfSomeDeclaration(ast) || isDeclarationAST(ast);
+        }
+        ASTHelpers.isDeclarationASTOrDeclarationNameAST = isDeclarationASTOrDeclarationNameAST;
+
+        function getEnclosingParameterForInitializer(ast) {
+            var current = ast;
+            while (current) {
+                switch (current.kind()) {
+                    case 232 /* EqualsValueClause */:
+                        if (current.parent && current.parent.kind() === 242 /* Parameter */) {
+                            return current.parent;
+                        }
+                        break;
+                    case 131 /* ClassDeclaration */:
+                    case 128 /* InterfaceDeclaration */:
+                    case 130 /* ModuleDeclaration */:
+                        return null;
+                }
+
+                current = current.parent;
+            }
+            return null;
+        }
+        ASTHelpers.getEnclosingParameterForInitializer = getEnclosingParameterForInitializer;
+
+        function getEnclosingMemberVariableDeclaration(ast) {
+            var current = ast;
+
+            while (current) {
+                switch (current.kind()) {
+                    case 136 /* MemberVariableDeclaration */:
+                        return current;
+                    case 131 /* ClassDeclaration */:
+                    case 128 /* InterfaceDeclaration */:
+                    case 130 /* ModuleDeclaration */:
+                        return null;
+                }
+                current = current.parent;
+            }
+
+            return null;
+        }
+        ASTHelpers.getEnclosingMemberVariableDeclaration = getEnclosingMemberVariableDeclaration;
+
+        function isNameOfFunction(ast) {
+            return ast && ast.parent && ast.kind() === 11 /* IdentifierName */ && ast.parent.kind() === 129 /* FunctionDeclaration */ && ast.parent.identifier === ast;
+        }
+        ASTHelpers.isNameOfFunction = isNameOfFunction;
+
+        function isNameOfMemberFunction(ast) {
+            return ast && ast.parent && ast.kind() === 11 /* IdentifierName */ && ast.parent.kind() === 135 /* MemberFunctionDeclaration */ && ast.parent.propertyName === ast;
+        }
+        ASTHelpers.isNameOfMemberFunction = isNameOfMemberFunction;
+
+        function isNameOfMemberAccessExpression(ast) {
+            if (ast && ast.parent && ast.parent.kind() === 212 /* MemberAccessExpression */ && ast.parent.name === ast) {
+                return true;
+            }
+
+            return false;
+        }
+        ASTHelpers.isNameOfMemberAccessExpression = isNameOfMemberAccessExpression;
+
+        function isRightSideOfQualifiedName(ast) {
+            if (ast && ast.parent && ast.parent.kind() === 121 /* QualifiedName */ && ast.parent.right === ast) {
+                return true;
+            }
+
+            return false;
+        }
+        ASTHelpers.isRightSideOfQualifiedName = isRightSideOfQualifiedName;
+
+        function parametersFromIdentifier(id) {
+            return {
+                length: 1,
+                lastParameterIsRest: function () {
+                    return false;
+                },
+                ast: id,
+                astAt: function (index) {
+                    return id;
+                },
+                identifierAt: function (index) {
+                    return id;
+                },
+                typeAt: function (index) {
+                    return null;
+                },
+                initializerAt: function (index) {
+                    return null;
+                },
+                isOptionalAt: function (index) {
+                    return false;
+                }
+            };
+        }
+        ASTHelpers.parametersFromIdentifier = parametersFromIdentifier;
+
+        function parametersFromParameter(parameter) {
+            return {
+                length: 1,
+                lastParameterIsRest: function () {
+                    return parameter.dotDotDotToken !== null;
+                },
+                ast: parameter,
+                astAt: function (index) {
+                    return parameter;
+                },
+                identifierAt: function (index) {
+                    return parameter.identifier;
+                },
+                typeAt: function (index) {
+                    return getType(parameter);
+                },
+                initializerAt: function (index) {
+                    return parameter.equalsValueClause;
+                },
+                isOptionalAt: function (index) {
+                    return parameterIsOptional(parameter);
+                }
+            };
+        }
+        ASTHelpers.parametersFromParameter = parametersFromParameter;
+
+        function parameterIsOptional(parameter) {
+            return parameter.questionToken !== null || parameter.equalsValueClause !== null;
+        }
+
+        function parametersFromParameterList(list) {
+            return {
+                length: list.parameters.nonSeparatorCount(),
+                lastParameterIsRest: function () {
+                    return TypeScript.lastParameterIsRest(list);
+                },
+                ast: list.parameters,
+                astAt: function (index) {
+                    return list.parameters.nonSeparatorAt(index);
+                },
+                identifierAt: function (index) {
+                    return list.parameters.nonSeparatorAt(index).identifier;
+                },
+                typeAt: function (index) {
+                    return getType(list.parameters.nonSeparatorAt(index));
+                },
+                initializerAt: function (index) {
+                    return list.parameters.nonSeparatorAt(index).equalsValueClause;
+                },
+                isOptionalAt: function (index) {
+                    return parameterIsOptional(list.parameters.nonSeparatorAt(index));
+                }
+            };
+        }
+        ASTHelpers.parametersFromParameterList = parametersFromParameterList;
+
+        function isDeclarationAST(ast) {
+            switch (ast.kind()) {
+                case 225 /* VariableDeclarator */:
+                    return getVariableStatement(ast) !== null;
+
+                case 133 /* ImportDeclaration */:
+                case 131 /* ClassDeclaration */:
+                case 128 /* InterfaceDeclaration */:
+                case 242 /* Parameter */:
+                case 219 /* SimpleArrowFunctionExpression */:
+                case 218 /* ParenthesizedArrowFunctionExpression */:
+                case 144 /* IndexSignature */:
+                case 129 /* FunctionDeclaration */:
+                case 130 /* ModuleDeclaration */:
+                case 124 /* ArrayType */:
+                case 122 /* ObjectType */:
+                case 238 /* TypeParameter */:
+                case 137 /* ConstructorDeclaration */:
+                case 135 /* MemberFunctionDeclaration */:
+                case 139 /* GetAccessor */:
+                case 140 /* SetAccessor */:
+                case 136 /* MemberVariableDeclaration */:
+                case 138 /* IndexMemberDeclaration */:
+                case 132 /* EnumDeclaration */:
+                case 243 /* EnumElement */:
+                case 240 /* SimplePropertyAssignment */:
+                case 241 /* FunctionPropertyAssignment */:
+                case 222 /* FunctionExpression */:
+                case 142 /* CallSignature */:
+                case 143 /* ConstructSignature */:
+                case 145 /* MethodSignature */:
+                case 141 /* PropertySignature */:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        ASTHelpers.isDeclarationAST = isDeclarationAST;
+
+        function docComments(ast) {
+            if (isDeclarationAST(ast)) {
+                var preComments = ast.kind() === 225 /* VariableDeclarator */ ? getVariableStatement(ast).preComments() : ast.preComments();
+
+                if (preComments && preComments.length > 0) {
+                    var preCommentsLength = preComments.length;
+                    var docComments = new Array();
+                    for (var i = preCommentsLength - 1; i >= 0; i--) {
+                        if (isDocComment(preComments[i])) {
+                            docComments.push(preComments[i]);
+                            continue;
+                        }
+
+                        break;
+                    }
+
+                    return docComments.reverse();
+                }
+            }
+
+            return TypeScript.sentinelEmptyArray;
+        }
+        ASTHelpers.docComments = docComments;
+
+        function isDocComment(comment) {
+            if (comment.kind() === 6 /* MultiLineCommentTrivia */) {
+                var fullText = comment.fullText();
+                return fullText.charAt(2) === "*" && fullText.charAt(3) !== "/";
+            }
+
+            return false;
+        }
+
+        function getParameterList(ast) {
+            if (ast) {
+                switch (ast.kind()) {
+                    case 137 /* ConstructorDeclaration */:
+                        return getParameterList(ast.callSignature);
+                    case 129 /* FunctionDeclaration */:
+                        return getParameterList(ast.callSignature);
+                    case 218 /* ParenthesizedArrowFunctionExpression */:
+                        return getParameterList(ast.callSignature);
+                    case 143 /* ConstructSignature */:
+                        return getParameterList(ast.callSignature);
+                    case 135 /* MemberFunctionDeclaration */:
+                        return getParameterList(ast.callSignature);
+                    case 241 /* FunctionPropertyAssignment */:
+                        return getParameterList(ast.callSignature);
+                    case 222 /* FunctionExpression */:
+                        return getParameterList(ast.callSignature);
+                    case 145 /* MethodSignature */:
+                        return getParameterList(ast.callSignature);
+                    case 125 /* ConstructorType */:
+                        return ast.parameterList;
+                    case 123 /* FunctionType */:
+                        return ast.parameterList;
+                    case 142 /* CallSignature */:
+                        return ast.parameterList;
+                    case 139 /* GetAccessor */:
+                        return ast.parameterList;
+                    case 140 /* SetAccessor */:
+                        return ast.parameterList;
+                }
+            }
+
+            return null;
+        }
+        ASTHelpers.getParameterList = getParameterList;
+
+        function getType(ast) {
+            if (ast) {
+                switch (ast.kind()) {
+                    case 129 /* FunctionDeclaration */:
+                        return getType(ast.callSignature);
+                    case 218 /* ParenthesizedArrowFunctionExpression */:
+                        return getType(ast.callSignature);
+                    case 143 /* ConstructSignature */:
+                        return getType(ast.callSignature);
+                    case 135 /* MemberFunctionDeclaration */:
+                        return getType(ast.callSignature);
+                    case 241 /* FunctionPropertyAssignment */:
+                        return getType(ast.callSignature);
+                    case 222 /* FunctionExpression */:
+                        return getType(ast.callSignature);
+                    case 145 /* MethodSignature */:
+                        return getType(ast.callSignature);
+                    case 142 /* CallSignature */:
+                        return getType(ast.typeAnnotation);
+                    case 144 /* IndexSignature */:
+                        return getType(ast.typeAnnotation);
+                    case 141 /* PropertySignature */:
+                        return getType(ast.typeAnnotation);
+                    case 139 /* GetAccessor */:
+                        return getType(ast.typeAnnotation);
+                    case 242 /* Parameter */:
+                        return getType(ast.typeAnnotation);
+                    case 136 /* MemberVariableDeclaration */:
+                        return getType(ast.variableDeclarator);
+                    case 225 /* VariableDeclarator */:
+                        return getType(ast.typeAnnotation);
+                    case 236 /* CatchClause */:
+                        return getType(ast.typeAnnotation);
+                    case 125 /* ConstructorType */:
+                        return ast.type;
+                    case 123 /* FunctionType */:
+                        return ast.type;
+                    case 244 /* TypeAnnotation */:
+                        return ast.type;
+                }
+            }
+
+            return null;
+        }
+        ASTHelpers.getType = getType;
+
+        function getVariableStatement(variableDeclarator) {
+            if (variableDeclarator && variableDeclarator.parent && variableDeclarator.parent.parent && variableDeclarator.parent.parent.parent && variableDeclarator.parent.kind() === 2 /* SeparatedList */ && variableDeclarator.parent.parent.kind() === 224 /* VariableDeclaration */ && variableDeclarator.parent.parent.parent.kind() === 148 /* VariableStatement */) {
+                return variableDeclarator.parent.parent.parent;
+            }
+
+            return null;
+        }
+
+        function getVariableDeclaratorModifiers(variableDeclarator) {
+            var variableStatement = getVariableStatement(variableDeclarator);
+            return variableStatement ? variableStatement.modifiers : TypeScript.sentinelEmptyArray;
+        }
+        ASTHelpers.getVariableDeclaratorModifiers = getVariableDeclaratorModifiers;
+
+        function isIntegerLiteralAST(expression) {
+            if (expression) {
+                switch (expression.kind()) {
+                    case 164 /* PlusExpression */:
+                    case 165 /* NegateExpression */:
+                        expression = expression.operand;
+                        return expression.kind() === 13 /* NumericLiteral */ && TypeScript.IntegerUtilities.isInteger(expression.text());
+
+                    case 13 /* NumericLiteral */:
+                        var text = expression.text();
+                        return TypeScript.IntegerUtilities.isInteger(text) || TypeScript.IntegerUtilities.isHexInteger(text);
+                }
+            }
+
+            return false;
+        }
+        ASTHelpers.isIntegerLiteralAST = isIntegerLiteralAST;
+
+        function getEnclosingModuleDeclaration(ast) {
+            while (ast) {
+                if (ast.kind() === 130 /* ModuleDeclaration */) {
+                    return ast;
+                }
+
+                ast = ast.parent;
+            }
+
+            return null;
+        }
+        ASTHelpers.getEnclosingModuleDeclaration = getEnclosingModuleDeclaration;
+
+        function isLastNameOfModule(ast, astName) {
+            if (ast) {
+                if (ast.stringLiteral) {
+                    return astName === ast.stringLiteral;
+                } else {
+                    var moduleNames = getModuleNames(ast.name);
+                    var nameIndex = moduleNames.indexOf(astName);
+
+                    return nameIndex === (moduleNames.length - 1);
+                }
+            }
+
+            return false;
+        }
+        ASTHelpers.isLastNameOfModule = isLastNameOfModule;
+
+        function isAnyNameOfModule(ast, astName) {
+            if (ast) {
+                if (ast.stringLiteral) {
+                    return ast.stringLiteral === astName;
+                } else {
+                    var moduleNames = getModuleNames(ast.name);
+                    var nameIndex = moduleNames.indexOf(astName);
+
+                    return nameIndex >= 0;
+                }
+            }
+
+            return false;
+        }
+        ASTHelpers.isAnyNameOfModule = isAnyNameOfModule;
+
+        function getNameOfIdenfierOrQualifiedName(name) {
+            if (name.kind() === 11 /* IdentifierName */) {
+                return name.text();
+            } else {
+                TypeScript.Debug.assert(name.kind() == 121 /* QualifiedName */);
+                var dotExpr = name;
+                return getNameOfIdenfierOrQualifiedName(dotExpr.left) + "." + getNameOfIdenfierOrQualifiedName(dotExpr.right);
+            }
+        }
+        ASTHelpers.getNameOfIdenfierOrQualifiedName = getNameOfIdenfierOrQualifiedName;
+
+        function getModuleNames(name, result) {
+            result = result || [];
+
+            if (name.kind() === 121 /* QualifiedName */) {
+                getModuleNames(name.left, result);
+                result.push(name.right);
+            } else {
+                result.push(name);
+            }
+
+            return result;
+        }
+        ASTHelpers.getModuleNames = getModuleNames;
+    })(TypeScript.ASTHelpers || (TypeScript.ASTHelpers = {}));
+    var ASTHelpers = TypeScript.ASTHelpers;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    function walkListChildren(preAst, walker) {
+        for (var i = 0, n = preAst.childCount(); i < n; i++) {
+            walker.walk(preAst.childAt(i));
+        }
+    }
+
+    function walkThrowStatementChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+    }
+
+    function walkPrefixUnaryExpressionChildren(preAst, walker) {
+        walker.walk(preAst.operand);
+    }
+
+    function walkPostfixUnaryExpressionChildren(preAst, walker) {
+        walker.walk(preAst.operand);
+    }
+
+    function walkDeleteExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+    }
+
+    function walkTypeArgumentListChildren(preAst, walker) {
+        walker.walk(preAst.typeArguments);
+    }
+
+    function walkTypeOfExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+    }
+
+    function walkVoidExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+    }
+
+    function walkArgumentListChildren(preAst, walker) {
+        walker.walk(preAst.typeArgumentList);
+        walker.walk(preAst.arguments);
+    }
+
+    function walkArrayLiteralExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expressions);
+    }
+
+    function walkSimplePropertyAssignmentChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.expression);
+    }
+
+    function walkFunctionPropertyAssignmentChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.callSignature);
+        walker.walk(preAst.block);
+    }
+
+    function walkGetAccessorChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.parameterList);
+        walker.walk(preAst.typeAnnotation);
+        walker.walk(preAst.block);
+    }
+
+    function walkSeparatedListChildren(preAst, walker) {
+        for (var i = 0, n = preAst.nonSeparatorCount(); i < n; i++) {
+            walker.walk(preAst.nonSeparatorAt(i));
+        }
+    }
+
+    function walkSetAccessorChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.parameterList);
+        walker.walk(preAst.block);
+    }
+
+    function walkObjectLiteralExpressionChildren(preAst, walker) {
+        walker.walk(preAst.propertyAssignments);
+    }
+
+    function walkCastExpressionChildren(preAst, walker) {
+        walker.walk(preAst.type);
+        walker.walk(preAst.expression);
+    }
+
+    function walkParenthesizedExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+    }
+
+    function walkElementAccessExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+        walker.walk(preAst.argumentExpression);
+    }
+
+    function walkMemberAccessExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+        walker.walk(preAst.name);
+    }
+
+    function walkQualifiedNameChildren(preAst, walker) {
+        walker.walk(preAst.left);
+        walker.walk(preAst.right);
+    }
+
+    function walkBinaryExpressionChildren(preAst, walker) {
+        walker.walk(preAst.left);
+        walker.walk(preAst.right);
+    }
+
+    function walkEqualsValueClauseChildren(preAst, walker) {
+        walker.walk(preAst.value);
+    }
+
+    function walkTypeParameterChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.constraint);
+    }
+
+    function walkTypeParameterListChildren(preAst, walker) {
+        walker.walk(preAst.typeParameters);
+    }
+
+    function walkGenericTypeChildren(preAst, walker) {
+        walker.walk(preAst.name);
+        walker.walk(preAst.typeArgumentList);
+    }
+
+    function walkTypeAnnotationChildren(preAst, walker) {
+        walker.walk(preAst.type);
+    }
+
+    function walkTypeQueryChildren(preAst, walker) {
+        walker.walk(preAst.name);
+    }
+
+    function walkInvocationExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+        walker.walk(preAst.argumentList);
+    }
+
+    function walkObjectCreationExpressionChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+        walker.walk(preAst.argumentList);
+    }
+
+    function walkTrinaryExpressionChildren(preAst, walker) {
+        walker.walk(preAst.condition);
+        walker.walk(preAst.whenTrue);
+        walker.walk(preAst.whenFalse);
+    }
+
+    function walkFunctionExpressionChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.callSignature);
+        walker.walk(preAst.block);
+    }
+
+    function walkFunctionTypeChildren(preAst, walker) {
+        walker.walk(preAst.typeParameterList);
+        walker.walk(preAst.parameterList);
+        walker.walk(preAst.type);
+    }
+
+    function walkParenthesizedArrowFunctionExpressionChildren(preAst, walker) {
+        walker.walk(preAst.callSignature);
+        walker.walk(preAst.block);
+        walker.walk(preAst.expression);
+    }
+
+    function walkSimpleArrowFunctionExpressionChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.block);
+        walker.walk(preAst.expression);
+    }
+
+    function walkMemberFunctionDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.callSignature);
+        walker.walk(preAst.block);
+    }
+
+    function walkFuncDeclChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.callSignature);
+        walker.walk(preAst.block);
+    }
+
+    function walkIndexMemberDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.indexSignature);
+    }
+
+    function walkIndexSignatureChildren(preAst, walker) {
+        walker.walk(preAst.parameter);
+        walker.walk(preAst.typeAnnotation);
+    }
+
+    function walkCallSignatureChildren(preAst, walker) {
+        walker.walk(preAst.typeParameterList);
+        walker.walk(preAst.parameterList);
+        walker.walk(preAst.typeAnnotation);
+    }
+
+    function walkConstraintChildren(preAst, walker) {
+        walker.walk(preAst.type);
+    }
+
+    function walkConstructorDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.callSignature);
+        walker.walk(preAst.block);
+    }
+
+    function walkConstructorTypeChildren(preAst, walker) {
+        walker.walk(preAst.typeParameterList);
+        walker.walk(preAst.parameterList);
+        walker.walk(preAst.type);
+    }
+
+    function walkConstructSignatureChildren(preAst, walker) {
+        walker.walk(preAst.callSignature);
+    }
+
+    function walkParameterChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.typeAnnotation);
+        walker.walk(preAst.equalsValueClause);
+    }
+
+    function walkParameterListChildren(preAst, walker) {
+        walker.walk(preAst.parameters);
+    }
+
+    function walkPropertySignatureChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.typeAnnotation);
+    }
+
+    function walkVariableDeclaratorChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.typeAnnotation);
+        walker.walk(preAst.equalsValueClause);
+    }
+
+    function walkMemberVariableDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.variableDeclarator);
+    }
+
+    function walkMethodSignatureChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.callSignature);
+    }
+
+    function walkReturnStatementChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+    }
+
+    function walkForStatementChildren(preAst, walker) {
+        walker.walk(preAst.variableDeclaration);
+        walker.walk(preAst.initializer);
+        walker.walk(preAst.condition);
+        walker.walk(preAst.incrementor);
+        walker.walk(preAst.statement);
+    }
+
+    function walkForInStatementChildren(preAst, walker) {
+        walker.walk(preAst.variableDeclaration);
+        walker.walk(preAst.left);
+        walker.walk(preAst.expression);
+        walker.walk(preAst.statement);
+    }
+
+    function walkIfStatementChildren(preAst, walker) {
+        walker.walk(preAst.condition);
+        walker.walk(preAst.statement);
+        walker.walk(preAst.elseClause);
+    }
+
+    function walkElseClauseChildren(preAst, walker) {
+        walker.walk(preAst.statement);
+    }
+
+    function walkWhileStatementChildren(preAst, walker) {
+        walker.walk(preAst.condition);
+        walker.walk(preAst.statement);
+    }
+
+    function walkDoStatementChildren(preAst, walker) {
+        walker.walk(preAst.condition);
+        walker.walk(preAst.statement);
+    }
+
+    function walkBlockChildren(preAst, walker) {
+        walker.walk(preAst.statements);
+    }
+
+    function walkVariableDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.declarators);
+    }
+
+    function walkCaseSwitchClauseChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+        walker.walk(preAst.statements);
+    }
+
+    function walkDefaultSwitchClauseChildren(preAst, walker) {
+        walker.walk(preAst.statements);
+    }
+
+    function walkSwitchStatementChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+        walker.walk(preAst.switchClauses);
+    }
+
+    function walkTryStatementChildren(preAst, walker) {
+        walker.walk(preAst.block);
+        walker.walk(preAst.catchClause);
+        walker.walk(preAst.finallyClause);
+    }
+
+    function walkCatchClauseChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.typeAnnotation);
+        walker.walk(preAst.block);
+    }
+
+    function walkExternalModuleReferenceChildren(preAst, walker) {
+        walker.walk(preAst.stringLiteral);
+    }
+
+    function walkFinallyClauseChildren(preAst, walker) {
+        walker.walk(preAst.block);
+    }
+
+    function walkClassDeclChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.typeParameterList);
+        walker.walk(preAst.heritageClauses);
+        walker.walk(preAst.classElements);
+    }
+
+    function walkScriptChildren(preAst, walker) {
+        walker.walk(preAst.moduleElements);
+    }
+
+    function walkHeritageClauseChildren(preAst, walker) {
+        walker.walk(preAst.typeNames);
+    }
+
+    function walkInterfaceDeclerationChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.typeParameterList);
+        walker.walk(preAst.heritageClauses);
+        walker.walk(preAst.body);
+    }
+
+    function walkObjectTypeChildren(preAst, walker) {
+        walker.walk(preAst.typeMembers);
+    }
+
+    function walkArrayTypeChildren(preAst, walker) {
+        walker.walk(preAst.type);
+    }
+
+    function walkModuleDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.name);
+        walker.walk(preAst.stringLiteral);
+        walker.walk(preAst.moduleElements);
+    }
+
+    function walkModuleNameModuleReferenceChildren(preAst, walker) {
+        walker.walk(preAst.moduleName);
+    }
+
+    function walkEnumDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.enumElements);
+    }
+
+    function walkEnumElementChildren(preAst, walker) {
+        walker.walk(preAst.propertyName);
+        walker.walk(preAst.equalsValueClause);
+    }
+
+    function walkImportDeclarationChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.moduleReference);
+    }
+
+    function walkExportAssignmentChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+    }
+
+    function walkWithStatementChildren(preAst, walker) {
+        walker.walk(preAst.condition);
+        walker.walk(preAst.statement);
+    }
+
+    function walkExpressionStatementChildren(preAst, walker) {
+        walker.walk(preAst.expression);
+    }
+
+    function walkLabeledStatementChildren(preAst, walker) {
+        walker.walk(preAst.identifier);
+        walker.walk(preAst.statement);
+    }
+
+    function walkVariableStatementChildren(preAst, walker) {
+        walker.walk(preAst.declaration);
+    }
+
+    var childrenWalkers = new Array(246 /* Last */ + 1);
+
+    for (var i = 9 /* FirstToken */, n = 119 /* LastToken */; i <= n; i++) {
+        childrenWalkers[i] = null;
+    }
+    for (var i = 4 /* FirstTrivia */, n = 8 /* LastTrivia */; i <= n; i++) {
+        childrenWalkers[i] = null;
+    }
+
+    childrenWalkers[175 /* AddAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[208 /* AddExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[180 /* AndAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[60 /* AnyKeyword */] = null;
+    childrenWalkers[226 /* ArgumentList */] = walkArgumentListChildren;
+    childrenWalkers[214 /* ArrayLiteralExpression */] = walkArrayLiteralExpressionChildren;
+    childrenWalkers[124 /* ArrayType */] = walkArrayTypeChildren;
+    childrenWalkers[219 /* SimpleArrowFunctionExpression */] = walkSimpleArrowFunctionExpressionChildren;
+    childrenWalkers[218 /* ParenthesizedArrowFunctionExpression */] = walkParenthesizedArrowFunctionExpressionChildren;
+    childrenWalkers[174 /* AssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[191 /* BitwiseAndExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[190 /* BitwiseExclusiveOrExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[166 /* BitwiseNotExpression */] = walkPrefixUnaryExpressionChildren;
+    childrenWalkers[189 /* BitwiseOrExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[146 /* Block */] = walkBlockChildren;
+    childrenWalkers[61 /* BooleanKeyword */] = null;
+    childrenWalkers[152 /* BreakStatement */] = null;
+    childrenWalkers[142 /* CallSignature */] = walkCallSignatureChildren;
+    childrenWalkers[233 /* CaseSwitchClause */] = walkCaseSwitchClauseChildren;
+    childrenWalkers[220 /* CastExpression */] = walkCastExpressionChildren;
+    childrenWalkers[236 /* CatchClause */] = walkCatchClauseChildren;
+    childrenWalkers[131 /* ClassDeclaration */] = walkClassDeclChildren;
+    childrenWalkers[173 /* CommaExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[186 /* ConditionalExpression */] = walkTrinaryExpressionChildren;
+    childrenWalkers[239 /* Constraint */] = walkConstraintChildren;
+    childrenWalkers[137 /* ConstructorDeclaration */] = walkConstructorDeclarationChildren;
+    childrenWalkers[143 /* ConstructSignature */] = walkConstructSignatureChildren;
+    childrenWalkers[153 /* ContinueStatement */] = null;
+    childrenWalkers[125 /* ConstructorType */] = walkConstructorTypeChildren;
+    childrenWalkers[162 /* DebuggerStatement */] = null;
+    childrenWalkers[234 /* DefaultSwitchClause */] = walkDefaultSwitchClauseChildren;
+    childrenWalkers[170 /* DeleteExpression */] = walkDeleteExpressionChildren;
+    childrenWalkers[178 /* DivideAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[206 /* DivideExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[161 /* DoStatement */] = walkDoStatementChildren;
+    childrenWalkers[221 /* ElementAccessExpression */] = walkElementAccessExpressionChildren;
+    childrenWalkers[235 /* ElseClause */] = walkElseClauseChildren;
+    childrenWalkers[156 /* EmptyStatement */] = null;
+    childrenWalkers[132 /* EnumDeclaration */] = walkEnumDeclarationChildren;
+    childrenWalkers[243 /* EnumElement */] = walkEnumElementChildren;
+    childrenWalkers[194 /* EqualsExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[232 /* EqualsValueClause */] = walkEqualsValueClauseChildren;
+    childrenWalkers[192 /* EqualsWithTypeConversionExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[181 /* ExclusiveOrAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[134 /* ExportAssignment */] = walkExportAssignmentChildren;
+    childrenWalkers[149 /* ExpressionStatement */] = walkExpressionStatementChildren;
+    childrenWalkers[230 /* ExtendsHeritageClause */] = walkHeritageClauseChildren;
+    childrenWalkers[245 /* ExternalModuleReference */] = walkExternalModuleReferenceChildren;
+    childrenWalkers[24 /* FalseKeyword */] = null;
+    childrenWalkers[237 /* FinallyClause */] = walkFinallyClauseChildren;
+    childrenWalkers[155 /* ForInStatement */] = walkForInStatementChildren;
+    childrenWalkers[154 /* ForStatement */] = walkForStatementChildren;
+    childrenWalkers[129 /* FunctionDeclaration */] = walkFuncDeclChildren;
+    childrenWalkers[222 /* FunctionExpression */] = walkFunctionExpressionChildren;
+    childrenWalkers[241 /* FunctionPropertyAssignment */] = walkFunctionPropertyAssignmentChildren;
+    childrenWalkers[123 /* FunctionType */] = walkFunctionTypeChildren;
+    childrenWalkers[126 /* GenericType */] = walkGenericTypeChildren;
+    childrenWalkers[139 /* GetAccessor */] = walkGetAccessorChildren;
+    childrenWalkers[197 /* GreaterThanExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[199 /* GreaterThanOrEqualExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[147 /* IfStatement */] = walkIfStatementChildren;
+    childrenWalkers[231 /* ImplementsHeritageClause */] = walkHeritageClauseChildren;
+    childrenWalkers[133 /* ImportDeclaration */] = walkImportDeclarationChildren;
+    childrenWalkers[138 /* IndexMemberDeclaration */] = walkIndexMemberDeclarationChildren;
+    childrenWalkers[144 /* IndexSignature */] = walkIndexSignatureChildren;
+    childrenWalkers[201 /* InExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[200 /* InstanceOfExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[128 /* InterfaceDeclaration */] = walkInterfaceDeclerationChildren;
+    childrenWalkers[213 /* InvocationExpression */] = walkInvocationExpressionChildren;
+    childrenWalkers[160 /* LabeledStatement */] = walkLabeledStatementChildren;
+    childrenWalkers[183 /* LeftShiftAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[202 /* LeftShiftExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[196 /* LessThanExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[198 /* LessThanOrEqualExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[1 /* List */] = walkListChildren;
+    childrenWalkers[188 /* LogicalAndExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[167 /* LogicalNotExpression */] = walkPrefixUnaryExpressionChildren;
+    childrenWalkers[187 /* LogicalOrExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[212 /* MemberAccessExpression */] = walkMemberAccessExpressionChildren;
+    childrenWalkers[135 /* MemberFunctionDeclaration */] = walkMemberFunctionDeclarationChildren;
+    childrenWalkers[136 /* MemberVariableDeclaration */] = walkMemberVariableDeclarationChildren;
+    childrenWalkers[145 /* MethodSignature */] = walkMethodSignatureChildren;
+    childrenWalkers[130 /* ModuleDeclaration */] = walkModuleDeclarationChildren;
+    childrenWalkers[246 /* ModuleNameModuleReference */] = walkModuleNameModuleReferenceChildren;
+    childrenWalkers[179 /* ModuloAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[207 /* ModuloExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[177 /* MultiplyAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[205 /* MultiplyExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[11 /* IdentifierName */] = null;
+    childrenWalkers[165 /* NegateExpression */] = walkPrefixUnaryExpressionChildren;
+    childrenWalkers[0 /* None */] = null;
+    childrenWalkers[195 /* NotEqualsExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[193 /* NotEqualsWithTypeConversionExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[32 /* NullKeyword */] = null;
+    childrenWalkers[67 /* NumberKeyword */] = null;
+    childrenWalkers[13 /* NumericLiteral */] = null;
+    childrenWalkers[216 /* ObjectCreationExpression */] = walkObjectCreationExpressionChildren;
+    childrenWalkers[215 /* ObjectLiteralExpression */] = walkObjectLiteralExpressionChildren;
+    childrenWalkers[122 /* ObjectType */] = walkObjectTypeChildren;
+    childrenWalkers[223 /* OmittedExpression */] = null;
+    childrenWalkers[182 /* OrAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[242 /* Parameter */] = walkParameterChildren;
+    childrenWalkers[227 /* ParameterList */] = walkParameterListChildren;
+    childrenWalkers[217 /* ParenthesizedExpression */] = walkParenthesizedExpressionChildren;
+    childrenWalkers[164 /* PlusExpression */] = walkPrefixUnaryExpressionChildren;
+    childrenWalkers[211 /* PostDecrementExpression */] = walkPostfixUnaryExpressionChildren;
+    childrenWalkers[210 /* PostIncrementExpression */] = walkPostfixUnaryExpressionChildren;
+    childrenWalkers[169 /* PreDecrementExpression */] = walkPrefixUnaryExpressionChildren;
+    childrenWalkers[168 /* PreIncrementExpression */] = walkPrefixUnaryExpressionChildren;
+    childrenWalkers[141 /* PropertySignature */] = walkPropertySignatureChildren;
+    childrenWalkers[121 /* QualifiedName */] = walkQualifiedNameChildren;
+    childrenWalkers[12 /* RegularExpressionLiteral */] = null;
+    childrenWalkers[150 /* ReturnStatement */] = walkReturnStatementChildren;
+    childrenWalkers[120 /* SourceUnit */] = walkScriptChildren;
+    childrenWalkers[2 /* SeparatedList */] = walkSeparatedListChildren;
+    childrenWalkers[140 /* SetAccessor */] = walkSetAccessorChildren;
+    childrenWalkers[184 /* SignedRightShiftAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[203 /* SignedRightShiftExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[240 /* SimplePropertyAssignment */] = walkSimplePropertyAssignmentChildren;
+    childrenWalkers[14 /* StringLiteral */] = null;
+    childrenWalkers[69 /* StringKeyword */] = null;
+    childrenWalkers[176 /* SubtractAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[209 /* SubtractExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[50 /* SuperKeyword */] = null;
+    childrenWalkers[151 /* SwitchStatement */] = walkSwitchStatementChildren;
+    childrenWalkers[35 /* ThisKeyword */] = null;
+    childrenWalkers[157 /* ThrowStatement */] = walkThrowStatementChildren;
+    childrenWalkers[3 /* TriviaList */] = null;
+    childrenWalkers[37 /* TrueKeyword */] = null;
+    childrenWalkers[159 /* TryStatement */] = walkTryStatementChildren;
+    childrenWalkers[244 /* TypeAnnotation */] = walkTypeAnnotationChildren;
+    childrenWalkers[228 /* TypeArgumentList */] = walkTypeArgumentListChildren;
+    childrenWalkers[171 /* TypeOfExpression */] = walkTypeOfExpressionChildren;
+    childrenWalkers[238 /* TypeParameter */] = walkTypeParameterChildren;
+    childrenWalkers[229 /* TypeParameterList */] = walkTypeParameterListChildren;
+    childrenWalkers[127 /* TypeQuery */] = walkTypeQueryChildren;
+    childrenWalkers[185 /* UnsignedRightShiftAssignmentExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[204 /* UnsignedRightShiftExpression */] = walkBinaryExpressionChildren;
+    childrenWalkers[224 /* VariableDeclaration */] = walkVariableDeclarationChildren;
+    childrenWalkers[225 /* VariableDeclarator */] = walkVariableDeclaratorChildren;
+    childrenWalkers[148 /* VariableStatement */] = walkVariableStatementChildren;
+    childrenWalkers[172 /* VoidExpression */] = walkVoidExpressionChildren;
+    childrenWalkers[41 /* VoidKeyword */] = null;
+    childrenWalkers[158 /* WhileStatement */] = walkWhileStatementChildren;
+    childrenWalkers[163 /* WithStatement */] = walkWithStatementChildren;
+
+    for (var e in TypeScript.SyntaxKind) {
+        if (TypeScript.SyntaxKind.hasOwnProperty(e) && TypeScript.StringUtilities.isString(TypeScript.SyntaxKind[e])) {
+            TypeScript.Debug.assert(childrenWalkers[e] !== undefined, "Fix initWalkers: " + TypeScript.SyntaxKind[e]);
+        }
+    }
+
+    var AstWalkOptions = (function () {
+        function AstWalkOptions() {
+            this.goChildren = true;
+            this.stopWalking = false;
+        }
+        return AstWalkOptions;
+    })();
+    TypeScript.AstWalkOptions = AstWalkOptions;
+
+    var SimplePreAstWalker = (function () {
+        function SimplePreAstWalker(pre, state) {
+            this.pre = pre;
+            this.state = state;
+            this.options = new AstWalkOptions();
+        }
+        SimplePreAstWalker.prototype.walk = function (ast) {
+            if (!ast) {
+                return;
+            }
+
+            this.pre(ast, this.state);
+
+            var walker = childrenWalkers[ast.kind()];
+            if (walker) {
+                walker(ast, this);
+            }
+        };
+        return SimplePreAstWalker;
+    })();
+
+    var SimplePrePostAstWalker = (function () {
+        function SimplePrePostAstWalker(pre, post, state) {
+            this.pre = pre;
+            this.post = post;
+            this.state = state;
+            this.options = new AstWalkOptions();
+        }
+        SimplePrePostAstWalker.prototype.walk = function (ast) {
+            if (!ast) {
+                return;
+            }
+
+            this.pre(ast, this.state);
+
+            var walker = childrenWalkers[ast.kind()];
+            if (walker) {
+                walker(ast, this);
+            }
+
+            this.post(ast, this.state);
+        };
+        return SimplePrePostAstWalker;
+    })();
+
+    var NormalAstWalker = (function () {
+        function NormalAstWalker(pre, post, state) {
+            this.pre = pre;
+            this.post = post;
+            this.state = state;
+            this.options = new AstWalkOptions();
+        }
+        NormalAstWalker.prototype.walk = function (ast) {
+            if (!ast) {
+                return;
+            }
+
+            if (this.options.stopWalking) {
+                return;
+            }
+
+            this.pre(ast, this);
+
+            if (this.options.stopWalking) {
+                return;
+            }
+
+            if (this.options.goChildren) {
+                var walker = childrenWalkers[ast.kind()];
+                if (walker) {
+                    walker(ast, this);
+                }
+            } else {
+                this.options.goChildren = true;
+            }
+
+            if (this.post) {
+                this.post(ast, this);
+            }
+        };
+        return NormalAstWalker;
+    })();
+
+    var AstWalkerFactory = (function () {
+        function AstWalkerFactory() {
+        }
+        AstWalkerFactory.prototype.walk = function (ast, pre, post, state) {
+            new NormalAstWalker(pre, post, state).walk(ast);
+        };
+
+        AstWalkerFactory.prototype.simpleWalk = function (ast, pre, post, state) {
+            if (post) {
+                new SimplePrePostAstWalker(pre, post, state).walk(ast);
+            } else {
+                new SimplePreAstWalker(pre, state).walk(ast);
+            }
+        };
+        return AstWalkerFactory;
+    })();
+    TypeScript.AstWalkerFactory = AstWalkerFactory;
+
+    var globalAstWalkerFactory = new AstWalkerFactory();
+
+    function getAstWalkerFactory() {
+        return globalAstWalkerFactory;
+    }
+    TypeScript.getAstWalkerFactory = getAstWalkerFactory;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var Base64Format = (function () {
+        function Base64Format() {
+        }
+        Base64Format.encode = function (inValue) {
+            if (inValue < 64) {
+                return Base64Format.encodedValues.charAt(inValue);
+            }
+            throw TypeError(inValue + ": not a 64 based value");
+        };
+
+        Base64Format.decodeChar = function (inChar) {
+            if (inChar.length === 1) {
+                return Base64Format.encodedValues.indexOf(inChar);
+            } else {
+                throw TypeError('"' + inChar + '" must have length 1');
+            }
+        };
+        Base64Format.encodedValues = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+        return Base64Format;
+    })();
+
+    var Base64VLQFormat = (function () {
+        function Base64VLQFormat() {
+        }
+        Base64VLQFormat.encode = function (inValue) {
+            if (inValue < 0) {
+                inValue = ((-inValue) << 1) + 1;
+            } else {
+                inValue = inValue << 1;
+            }
+
+            var encodedStr = "";
+            do {
+                var currentDigit = inValue & 31;
+                inValue = inValue >> 5;
+                if (inValue > 0) {
+                    currentDigit = currentDigit | 32;
+                }
+                encodedStr = encodedStr + Base64Format.encode(currentDigit);
+            } while(inValue > 0);
+
+            return encodedStr;
+        };
+
+        Base64VLQFormat.decode = function (inString) {
+            var result = 0;
+            var negative = false;
+
+            var shift = 0;
+            for (var i = 0; i < inString.length; i++) {
+                var byte = Base64Format.decodeChar(inString[i]);
+                if (i === 0) {
+                    if ((byte & 1) === 1) {
+                        negative = true;
+                    }
+                    result = (byte >> 1) & 15;
+                } else {
+                    result = result | ((byte & 31) << shift);
+                }
+
+                shift += (i === 0) ? 4 : 5;
+
+                if ((byte & 32) === 32) {
+                } else {
+                    return { value: negative ? -(result) : result, rest: inString.substr(i + 1) };
+                }
+            }
+
+            throw new Error(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Base64_value_0_finished_with_a_continuation_bit, [inString]));
+        };
+        return Base64VLQFormat;
+    })();
+    TypeScript.Base64VLQFormat = Base64VLQFormat;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SourceMapPosition = (function () {
+        function SourceMapPosition() {
+        }
+        return SourceMapPosition;
+    })();
+    TypeScript.SourceMapPosition = SourceMapPosition;
+
+    var SourceMapping = (function () {
+        function SourceMapping() {
+            this.start = new SourceMapPosition();
+            this.end = new SourceMapPosition();
+            this.nameIndex = -1;
+            this.childMappings = [];
+        }
+        return SourceMapping;
+    })();
+    TypeScript.SourceMapping = SourceMapping;
+
+    var SourceMapEntry = (function () {
+        function SourceMapEntry(emittedFile, emittedLine, emittedColumn, sourceFile, sourceLine, sourceColumn, sourceName) {
+            this.emittedFile = emittedFile;
+            this.emittedLine = emittedLine;
+            this.emittedColumn = emittedColumn;
+            this.sourceFile = sourceFile;
+            this.sourceLine = sourceLine;
+            this.sourceColumn = sourceColumn;
+            this.sourceName = sourceName;
+            TypeScript.Debug.assert(isFinite(emittedLine));
+            TypeScript.Debug.assert(isFinite(emittedColumn));
+            TypeScript.Debug.assert(isFinite(sourceColumn));
+            TypeScript.Debug.assert(isFinite(sourceLine));
+        }
+        return SourceMapEntry;
+    })();
+    TypeScript.SourceMapEntry = SourceMapEntry;
+
+    var SourceMapper = (function () {
+        function SourceMapper(jsFile, sourceMapOut, document, jsFilePath, emitOptions, resolvePath) {
+            this.jsFile = jsFile;
+            this.sourceMapOut = sourceMapOut;
+            this.names = [];
+            this.mappingLevel = [];
+            this.tsFilePaths = [];
+            this.allSourceMappings = [];
+            this.sourceMapEntries = [];
+            this.setSourceMapOptions(document, jsFilePath, emitOptions, resolvePath);
+            this.setNewSourceFile(document, emitOptions);
+        }
+        SourceMapper.prototype.getOutputFile = function () {
+            var result = this.sourceMapOut.getOutputFile();
+            result.sourceMapEntries = this.sourceMapEntries;
+
+            return result;
+        };
+
+        SourceMapper.prototype.increaseMappingLevel = function (ast) {
+            this.mappingLevel.push(ast);
+        };
+
+        SourceMapper.prototype.decreaseMappingLevel = function (ast) {
+            TypeScript.Debug.assert(this.mappingLevel.length > 0, "Mapping level should never be less than 0. This suggests a missing start call.");
+            var expectedAst = this.mappingLevel.pop();
+            var expectedAstInfo = expectedAst.kind ? TypeScript.SyntaxKind[expectedAst.kind()] : [expectedAst.start(), expectedAst.end()];
+            var astInfo = ast.kind ? TypeScript.SyntaxKind[ast.kind()] : [ast.start(), ast.end()];
+            TypeScript.Debug.assert(ast === expectedAst, "Provided ast is not the expected AST, Expected: " + expectedAstInfo + " Given: " + astInfo);
+        };
+
+        SourceMapper.prototype.setNewSourceFile = function (document, emitOptions) {
+            var sourceMappings = [];
+            this.allSourceMappings.push(sourceMappings);
+            this.currentMappings = [sourceMappings];
+            this.currentNameIndex = [];
+
+            this.setNewSourceFilePath(document, emitOptions);
+        };
+
+        SourceMapper.prototype.setSourceMapOptions = function (document, jsFilePath, emitOptions, resolvePath) {
+            var prettyJsFileName = TypeScript.getPrettyName(jsFilePath, false, true);
+            var prettyMapFileName = prettyJsFileName + SourceMapper.MapFileExtension;
+            this.jsFileName = prettyJsFileName;
+
+            if (emitOptions.sourceMapRootDirectory()) {
+                this.sourceMapDirectory = emitOptions.sourceMapRootDirectory();
+                if (document.emitToOwnOutputFile()) {
+                    this.sourceMapDirectory = this.sourceMapDirectory + TypeScript.switchToForwardSlashes(TypeScript.getRootFilePath((document.fileName)).replace(emitOptions.commonDirectoryPath(), ""));
+                }
+
+                if (TypeScript.isRelative(this.sourceMapDirectory)) {
+                    this.sourceMapDirectory = emitOptions.commonDirectoryPath() + this.sourceMapDirectory;
+                    this.sourceMapDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(resolvePath(this.sourceMapDirectory)));
+                    this.sourceMapPath = TypeScript.getRelativePathToFixedPath(TypeScript.getRootFilePath(jsFilePath), this.sourceMapDirectory + prettyMapFileName);
+                } else {
+                    this.sourceMapPath = this.sourceMapDirectory + prettyMapFileName;
+                }
+            } else {
+                this.sourceMapPath = prettyMapFileName;
+                this.sourceMapDirectory = TypeScript.getRootFilePath(jsFilePath);
+            }
+            this.sourceRoot = emitOptions.sourceRootDirectory();
+        };
+
+        SourceMapper.prototype.setNewSourceFilePath = function (document, emitOptions) {
+            var tsFilePath = TypeScript.switchToForwardSlashes(document.fileName);
+            if (emitOptions.sourceRootDirectory()) {
+                tsFilePath = TypeScript.getRelativePathToFixedPath(emitOptions.commonDirectoryPath(), tsFilePath);
+            } else {
+                tsFilePath = TypeScript.getRelativePathToFixedPath(this.sourceMapDirectory, tsFilePath);
+            }
+            this.tsFilePaths.push(tsFilePath);
+        };
+
+        SourceMapper.prototype.emitSourceMapping = function () {
+            var _this = this;
+            TypeScript.Debug.assert(this.mappingLevel.length === 0, "Mapping level is not 0. This suggest a missing end call. Value: " + this.mappingLevel.map(function (item) {
+                return ['Node of type', TypeScript.SyntaxKind[item.kind()], 'at', item.start(), 'to', item.end()].join(' ');
+            }).join(', '));
+
+            this.jsFile.WriteLine("//# sourceMappingURL=" + this.sourceMapPath);
+
+            var mappingsString = "";
+
+            var prevEmittedColumn = 0;
+            var prevEmittedLine = 0;
+            var prevSourceColumn = 0;
+            var prevSourceLine = 0;
+            var prevSourceIndex = 0;
+            var prevNameIndex = 0;
+            var emitComma = false;
+
+            var recordedPosition = null;
+            for (var sourceIndex = 0; sourceIndex < this.tsFilePaths.length; sourceIndex++) {
+                var recordSourceMapping = function (mappedPosition, nameIndex) {
+                    if (recordedPosition !== null && recordedPosition.emittedColumn === mappedPosition.emittedColumn && recordedPosition.emittedLine === mappedPosition.emittedLine) {
+                        return;
+                    }
+
+                    if (prevEmittedLine !== mappedPosition.emittedLine) {
+                        while (prevEmittedLine < mappedPosition.emittedLine) {
+                            prevEmittedColumn = 0;
+                            mappingsString = mappingsString + ";";
+                            prevEmittedLine++;
+                        }
+                        emitComma = false;
+                    } else if (emitComma) {
+                        mappingsString = mappingsString + ",";
+                    }
+
+                    _this.sourceMapEntries.push(new SourceMapEntry(_this.jsFileName, mappedPosition.emittedLine + 1, mappedPosition.emittedColumn + 1, _this.tsFilePaths[sourceIndex], mappedPosition.sourceLine, mappedPosition.sourceColumn + 1, nameIndex >= 0 ? _this.names[nameIndex] : undefined));
+
+                    mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.emittedColumn - prevEmittedColumn);
+                    prevEmittedColumn = mappedPosition.emittedColumn;
+
+                    mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(sourceIndex - prevSourceIndex);
+                    prevSourceIndex = sourceIndex;
+
+                    mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.sourceLine - 1 - prevSourceLine);
+                    prevSourceLine = mappedPosition.sourceLine - 1;
+
+                    mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.sourceColumn - prevSourceColumn);
+                    prevSourceColumn = mappedPosition.sourceColumn;
+
+                    if (nameIndex >= 0) {
+                        mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(nameIndex - prevNameIndex);
+                        prevNameIndex = nameIndex;
+                    }
+
+                    emitComma = true;
+                    recordedPosition = mappedPosition;
+                };
+
+                var recordSourceMappingSiblings = function (sourceMappings) {
+                    for (var i = 0; i < sourceMappings.length; i++) {
+                        var sourceMapping = sourceMappings[i];
+                        recordSourceMapping(sourceMapping.start, sourceMapping.nameIndex);
+                        recordSourceMappingSiblings(sourceMapping.childMappings);
+                        recordSourceMapping(sourceMapping.end, sourceMapping.nameIndex);
+                    }
+                };
+
+                recordSourceMappingSiblings(this.allSourceMappings[sourceIndex]);
+            }
+
+            this.sourceMapOut.Write(JSON.stringify({
+                version: 3,
+                file: this.jsFileName,
+                sourceRoot: this.sourceRoot,
+                sources: this.tsFilePaths,
+                names: this.names,
+                mappings: mappingsString
+            }));
+
+            this.sourceMapOut.Close();
+        };
+        SourceMapper.MapFileExtension = ".map";
+        return SourceMapper;
+    })();
+    TypeScript.SourceMapper = SourceMapper;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (EmitContainer) {
+        EmitContainer[EmitContainer["Prog"] = 0] = "Prog";
+        EmitContainer[EmitContainer["Module"] = 1] = "Module";
+        EmitContainer[EmitContainer["DynamicModule"] = 2] = "DynamicModule";
+        EmitContainer[EmitContainer["Class"] = 3] = "Class";
+        EmitContainer[EmitContainer["Constructor"] = 4] = "Constructor";
+        EmitContainer[EmitContainer["Function"] = 5] = "Function";
+        EmitContainer[EmitContainer["Args"] = 6] = "Args";
+        EmitContainer[EmitContainer["Interface"] = 7] = "Interface";
+    })(TypeScript.EmitContainer || (TypeScript.EmitContainer = {}));
+    var EmitContainer = TypeScript.EmitContainer;
+
+    var EmitState = (function () {
+        function EmitState() {
+            this.column = 0;
+            this.line = 0;
+            this.container = 0 /* Prog */;
+        }
+        return EmitState;
+    })();
+    TypeScript.EmitState = EmitState;
+
+    var EmitOptions = (function () {
+        function EmitOptions(compiler, resolvePath) {
+            this.resolvePath = resolvePath;
+            this._diagnostic = null;
+            this._settings = null;
+            this._commonDirectoryPath = "";
+            this._sharedOutputFile = "";
+            this._sourceRootDirectory = "";
+            this._sourceMapRootDirectory = "";
+            this._outputDirectory = "";
+            var settings = compiler.compilationSettings();
+            this._settings = settings;
+
+            if (settings.moduleGenTarget() === 0 /* Unspecified */) {
+                var fileNames = compiler.fileNames();
+                for (var i = 0, n = fileNames.length; i < n; i++) {
+                    var document = compiler.getDocument(fileNames[i]);
+                    if (!document.isDeclareFile() && document.isExternalModule()) {
+                        var errorSpan = document.externalModuleIndicatorSpan();
+                        this._diagnostic = new TypeScript.Diagnostic(document.fileName, document.lineMap(), errorSpan.start(), errorSpan.length(), TypeScript.DiagnosticCode.Cannot_compile_external_modules_unless_the_module_flag_is_provided);
+
+                        return;
+                    }
+                }
+            }
+
+            if (!settings.mapSourceFiles()) {
+                if (settings.mapRoot()) {
+                    if (settings.sourceRoot()) {
+                        this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Options_mapRoot_and_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option, null);
+                        return;
+                    } else {
+                        this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Option_mapRoot_cannot_be_specified_without_specifying_sourcemap_option, null);
+                        return;
+                    }
+                } else if (settings.sourceRoot()) {
+                    this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Option_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option, null);
+                    return;
+                }
+            }
+
+            this._sourceMapRootDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(settings.mapRoot()));
+            this._sourceRootDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(settings.sourceRoot()));
+
+            if (settings.outFileOption() || settings.outDirOption() || settings.mapRoot() || settings.sourceRoot()) {
+                if (settings.outFileOption()) {
+                    this._sharedOutputFile = TypeScript.switchToForwardSlashes(resolvePath(settings.outFileOption()));
+                }
+
+                if (settings.outDirOption()) {
+                    this._outputDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(resolvePath(settings.outDirOption())));
+                }
+
+                if (this._outputDirectory || this._sourceMapRootDirectory || this.sourceRootDirectory) {
+                    this.determineCommonDirectoryPath(compiler);
+                }
+            }
+        }
+        EmitOptions.prototype.diagnostic = function () {
+            return this._diagnostic;
+        };
+
+        EmitOptions.prototype.commonDirectoryPath = function () {
+            return this._commonDirectoryPath;
+        };
+        EmitOptions.prototype.sharedOutputFile = function () {
+            return this._sharedOutputFile;
+        };
+        EmitOptions.prototype.sourceRootDirectory = function () {
+            return this._sourceRootDirectory;
+        };
+        EmitOptions.prototype.sourceMapRootDirectory = function () {
+            return this._sourceMapRootDirectory;
+        };
+        EmitOptions.prototype.outputDirectory = function () {
+            return this._outputDirectory;
+        };
+
+        EmitOptions.prototype.compilationSettings = function () {
+            return this._settings;
+        };
+
+        EmitOptions.prototype.determineCommonDirectoryPath = function (compiler) {
+            var commonComponents = [];
+            var commonComponentsLength = -1;
+
+            var fileNames = compiler.fileNames();
+            for (var i = 0, len = fileNames.length; i < len; i++) {
+                var fileName = fileNames[i];
+                var document = compiler.getDocument(fileNames[i]);
+                var sourceUnit = document.sourceUnit();
+
+                if (!document.isDeclareFile()) {
+                    var fileComponents = TypeScript.filePathComponents(fileName);
+                    if (commonComponentsLength === -1) {
+                        commonComponents = fileComponents;
+                        commonComponentsLength = commonComponents.length;
+                    } else {
+                        var updatedPath = false;
+                        for (var j = 0; j < commonComponentsLength && j < fileComponents.length; j++) {
+                            if (commonComponents[j] !== fileComponents[j]) {
+                                commonComponentsLength = j;
+                                updatedPath = true;
+
+                                if (j === 0) {
+                                    var isDynamicModuleCompilation = TypeScript.ArrayUtilities.any(fileNames, function (fileName) {
+                                        document = compiler.getDocument(fileName);
+                                        return !document.isDeclareFile() && document.isExternalModule();
+                                    });
+
+                                    if (this._outputDirectory || this._sourceRootDirectory || (this._sourceMapRootDirectory && (!this._sharedOutputFile || isDynamicModuleCompilation))) {
+                                        this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Cannot_find_the_common_subdirectory_path_for_the_input_files, null);
+                                        return;
+                                    }
+
+                                    return;
+                                }
+
+                                break;
+                            }
+                        }
+
+                        if (!updatedPath && fileComponents.length < commonComponentsLength) {
+                            commonComponentsLength = fileComponents.length;
+                        }
+                    }
+                }
+            }
+
+            this._commonDirectoryPath = commonComponents.slice(0, commonComponentsLength).join("/") + "/";
+        };
+        return EmitOptions;
+    })();
+    TypeScript.EmitOptions = EmitOptions;
+
+    var Indenter = (function () {
+        function Indenter() {
+            this.indentAmt = 0;
+        }
+        Indenter.prototype.increaseIndent = function () {
+            this.indentAmt += Indenter.indentStep;
+        };
+
+        Indenter.prototype.decreaseIndent = function () {
+            this.indentAmt -= Indenter.indentStep;
+        };
+
+        Indenter.prototype.getIndent = function () {
+            var indentString = Indenter.indentStrings[this.indentAmt];
+            if (indentString === undefined) {
+                indentString = "";
+                for (var i = 0; i < this.indentAmt; i = i + Indenter.indentStep) {
+                    indentString += Indenter.indentStepString;
+                }
+                Indenter.indentStrings[this.indentAmt] = indentString;
+            }
+            return indentString;
+        };
+        Indenter.indentStep = 4;
+        Indenter.indentStepString = "    ";
+        Indenter.indentStrings = [];
+        return Indenter;
+    })();
+    TypeScript.Indenter = Indenter;
+
+    function lastParameterIsRest(parameterList) {
+        var parameters = parameterList.parameters;
+        return parameters.nonSeparatorCount() > 0 && parameters.nonSeparatorAt(parameters.nonSeparatorCount() - 1).dotDotDotToken !== null;
+    }
+    TypeScript.lastParameterIsRest = lastParameterIsRest;
+
+    var Emitter = (function () {
+        function Emitter(emittingFileName, outfile, emitOptions, semanticInfoChain) {
+            this.emittingFileName = emittingFileName;
+            this.outfile = outfile;
+            this.emitOptions = emitOptions;
+            this.semanticInfoChain = semanticInfoChain;
+            this.globalThisCapturePrologueEmitted = false;
+            this.extendsPrologueEmitted = false;
+            this.thisClassNode = null;
+            this.inArrowFunction = false;
+            this.moduleName = "";
+            this.emitState = new EmitState();
+            this.indenter = new Indenter();
+            this.sourceMapper = null;
+            this.captureThisStmtString = "var _this = this;";
+            this.declStack = [];
+            this.exportAssignment = null;
+            this.inWithBlock = false;
+            this.document = null;
+            this.detachedCommentsElement = null;
+        }
+        Emitter.prototype.pushDecl = function (decl) {
+            if (decl) {
+                this.declStack[this.declStack.length] = decl;
+            }
+        };
+
+        Emitter.prototype.popDecl = function (decl) {
+            if (decl) {
+                this.declStack.length--;
+            }
+        };
+
+        Emitter.prototype.getEnclosingDecl = function () {
+            var declStackLen = this.declStack.length;
+            var enclosingDecl = declStackLen > 0 ? this.declStack[declStackLen - 1] : null;
+            return enclosingDecl;
+        };
+
+        Emitter.prototype.setExportAssignment = function (exportAssignment) {
+            this.exportAssignment = exportAssignment;
+        };
+
+        Emitter.prototype.getExportAssignment = function () {
+            return this.exportAssignment;
+        };
+
+        Emitter.prototype.setDocument = function (document) {
+            this.document = document;
+        };
+
+        Emitter.prototype.shouldEmitImportDeclaration = function (importDeclAST) {
+            var isExternalModuleReference = importDeclAST.moduleReference.kind() === 245 /* ExternalModuleReference */;
+            var importDecl = this.semanticInfoChain.getDeclForAST(importDeclAST);
+            var isExported = TypeScript.hasFlag(importDecl.flags, 1 /* Exported */);
+            var isAmdCodeGen = this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */;
+
+            if (isExternalModuleReference && !isExported && isAmdCodeGen) {
+                return false;
+            }
+
+            var importSymbol = importDecl.getSymbol();
+            if (importSymbol.isUsedAsValue()) {
+                return true;
+            }
+
+            if (importDeclAST.moduleReference.kind() !== 245 /* ExternalModuleReference */) {
+                var canBeUsedExternally = isExported || importSymbol.typeUsedExternally() || importSymbol.isUsedInExportedAlias();
+                if (!canBeUsedExternally && !this.document.isExternalModule()) {
+                    canBeUsedExternally = TypeScript.hasFlag(importDecl.getParentDecl().kind, 1 /* Script */ | 32 /* DynamicModule */);
+                }
+
+                if (canBeUsedExternally) {
+                    if (importSymbol.getExportAssignedValueSymbol()) {
+                        return true;
+                    }
+
+                    var containerSymbol = importSymbol.getExportAssignedContainerSymbol();
+                    if (containerSymbol && containerSymbol.getInstanceSymbol()) {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        Emitter.prototype.emitImportDeclaration = function (importDeclAST) {
+            var isExternalModuleReference = importDeclAST.moduleReference.kind() === 245 /* ExternalModuleReference */;
+            var importDecl = this.semanticInfoChain.getDeclForAST(importDeclAST);
+            var isExported = TypeScript.hasFlag(importDecl.flags, 1 /* Exported */);
+            var isAmdCodeGen = this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */;
+
+            this.emitComments(importDeclAST, true);
+
+            var importSymbol = importDecl.getSymbol();
+
+            var parentSymbol = importSymbol.getContainer();
+            var parentKind = parentSymbol ? parentSymbol.kind : 0 /* None */;
+            var associatedParentSymbol = parentSymbol ? parentSymbol.getAssociatedContainerType() : null;
+            var associatedParentSymbolKind = associatedParentSymbol ? associatedParentSymbol.kind : 0 /* None */;
+
+            var needsPropertyAssignment = false;
+            var usePropertyAssignmentInsteadOfVarDecl = false;
+            var moduleNamePrefix;
+
+            if (isExported && (parentKind === 4 /* Container */ || parentKind === 32 /* DynamicModule */ || associatedParentSymbolKind === 4 /* Container */ || associatedParentSymbolKind === 32 /* DynamicModule */)) {
+                if (importSymbol.getExportAssignedTypeSymbol() || importSymbol.getExportAssignedContainerSymbol()) {
+                    needsPropertyAssignment = true;
+                } else {
+                    var valueSymbol = importSymbol.getExportAssignedValueSymbol();
+                    if (valueSymbol && (valueSymbol.kind === 65536 /* Method */ || valueSymbol.kind === 16384 /* Function */)) {
+                        needsPropertyAssignment = true;
+                    } else {
+                        usePropertyAssignmentInsteadOfVarDecl = true;
+                    }
+                }
+
+                if (this.emitState.container === 2 /* DynamicModule */) {
+                    moduleNamePrefix = "exports.";
+                } else {
+                    moduleNamePrefix = this.moduleName + ".";
+                }
+            }
+
+            if (isAmdCodeGen && isExternalModuleReference) {
+                needsPropertyAssignment = true;
+            } else {
+                this.recordSourceMappingStart(importDeclAST);
+                if (usePropertyAssignmentInsteadOfVarDecl) {
+                    this.writeToOutput(moduleNamePrefix);
+                } else {
+                    this.writeToOutput("var ");
+                }
+                this.writeToOutput(importDeclAST.identifier.text() + " = ");
+                var aliasAST = importDeclAST.moduleReference;
+
+                if (isExternalModuleReference) {
+                    this.writeToOutput("require(" + aliasAST.stringLiteral.text() + ")");
+                } else {
+                    this.emitJavascript(aliasAST.moduleName, false);
+                }
+
+                this.recordSourceMappingEnd(importDeclAST);
+                this.writeToOutput(";");
+
+                if (needsPropertyAssignment) {
+                    this.writeLineToOutput("");
+                    this.emitIndent();
+                }
+            }
+
+            if (needsPropertyAssignment) {
+                this.writeToOutputWithSourceMapRecord(moduleNamePrefix + importDeclAST.identifier.text() + " = " + importDeclAST.identifier.text(), importDeclAST);
+                this.writeToOutput(";");
+            }
+            this.emitComments(importDeclAST, false);
+        };
+
+        Emitter.prototype.createSourceMapper = function (document, jsFileName, jsFile, sourceMapOut, resolvePath) {
+            this.sourceMapper = new TypeScript.SourceMapper(jsFile, sourceMapOut, document, jsFileName, this.emitOptions, resolvePath);
+        };
+
+        Emitter.prototype.setSourceMapperNewSourceFile = function (document) {
+            this.sourceMapper.setNewSourceFile(document, this.emitOptions);
+        };
+
+        Emitter.prototype.updateLineAndColumn = function (s) {
+            var lineNumbers = TypeScript.TextUtilities.parseLineStarts(s);
+            if (lineNumbers.length > 1) {
+                this.emitState.line += lineNumbers.length - 1;
+                this.emitState.column = s.length - lineNumbers[lineNumbers.length - 1];
+            } else {
+                this.emitState.column += s.length;
+            }
+        };
+
+        Emitter.prototype.writeToOutputWithSourceMapRecord = function (s, astSpan) {
+            this.recordSourceMappingStart(astSpan);
+            this.writeToOutput(s);
+            this.recordSourceMappingEnd(astSpan);
+        };
+
+        Emitter.prototype.writeToOutput = function (s) {
+            this.outfile.Write(s);
+            this.updateLineAndColumn(s);
+        };
+
+        Emitter.prototype.writeLineToOutput = function (s, force) {
+            if (typeof force === "undefined") { force = false; }
+            if (!force && s === "" && this.emitState.column === 0) {
+                return;
+            }
+
+            this.outfile.WriteLine(s);
+            this.updateLineAndColumn(s);
+            this.emitState.column = 0;
+            this.emitState.line++;
+        };
+
+        Emitter.prototype.writeCaptureThisStatement = function (ast) {
+            this.emitIndent();
+            this.writeToOutputWithSourceMapRecord(this.captureThisStmtString, ast);
+            this.writeLineToOutput("");
+        };
+
+        Emitter.prototype.setContainer = function (c) {
+            var temp = this.emitState.container;
+            this.emitState.container = c;
+            return temp;
+        };
+
+        Emitter.prototype.getIndentString = function () {
+            return this.indenter.getIndent();
+        };
+
+        Emitter.prototype.emitIndent = function () {
+            this.writeToOutput(this.getIndentString());
+        };
+
+        Emitter.prototype.emitComment = function (comment, trailing, first) {
+            if (this.emitOptions.compilationSettings().removeComments()) {
+                return;
+            }
+
+            var text = getTrimmedTextLines(comment);
+            var emitColumn = this.emitState.column;
+
+            if (emitColumn === 0) {
+                this.emitIndent();
+            } else if (trailing && first) {
+                this.writeToOutput(" ");
+            }
+
+            if (comment.kind() === 6 /* MultiLineCommentTrivia */) {
+                this.recordSourceMappingStart(comment);
+                this.writeToOutput(text[0]);
+
+                if (text.length > 1 || comment.endsLine) {
+                    for (var i = 1; i < text.length; i++) {
+                        this.writeLineToOutput("");
+                        this.emitIndent();
+                        this.writeToOutput(text[i]);
+                    }
+                    this.recordSourceMappingEnd(comment);
+                    this.writeLineToOutput("");
+                } else {
+                    this.recordSourceMappingEnd(comment);
+                    this.writeToOutput(" ");
+                    return;
+                }
+            } else {
+                this.recordSourceMappingStart(comment);
+                this.writeToOutput(text[0]);
+                this.recordSourceMappingEnd(comment);
+                this.writeLineToOutput("");
+            }
+
+            if (!trailing && emitColumn !== 0) {
+                this.emitIndent();
+            }
+        };
+
+        Emitter.prototype.emitComments = function (ast, pre, onlyPinnedOrTripleSlashComments) {
+            var _this = this;
+            if (typeof onlyPinnedOrTripleSlashComments === "undefined") { onlyPinnedOrTripleSlashComments = false; }
+            if (ast && ast.kind() !== 146 /* Block */) {
+                if (ast.parent.kind() === 219 /* SimpleArrowFunctionExpression */ || ast.parent.kind() === 218 /* ParenthesizedArrowFunctionExpression */) {
+                    return;
+                }
+            }
+
+            if (pre) {
+                var preComments = ast.preComments();
+
+                if (preComments && ast === this.detachedCommentsElement) {
+                    var detachedComments = this.getDetachedComments(ast);
+                    preComments = preComments.slice(detachedComments.length);
+                    this.detachedCommentsElement = null;
+                }
+
+                if (preComments && onlyPinnedOrTripleSlashComments) {
+                    preComments = TypeScript.ArrayUtilities.where(preComments, function (c) {
+                        return _this.isPinnedOrTripleSlash(c);
+                    });
+                }
+
+                this.emitCommentsArray(preComments, false);
+            } else {
+                this.emitCommentsArray(ast.postComments(), true);
+            }
+        };
+
+        Emitter.prototype.isPinnedOrTripleSlash = function (comment) {
+            var fullText = comment.fullText();
+            if (fullText.match(TypeScript.tripleSlashReferenceRegExp)) {
+                return true;
+            } else {
+                return fullText.indexOf("/*!") === 0;
+            }
+        };
+
+        Emitter.prototype.emitCommentsArray = function (comments, trailing) {
+            if (!this.emitOptions.compilationSettings().removeComments() && comments) {
+                for (var i = 0, n = comments.length; i < n; i++) {
+                    this.emitComment(comments[i], trailing, i === 0);
+                }
+            }
+        };
+
+        Emitter.prototype.emitObjectLiteralExpression = function (objectLiteral) {
+            this.recordSourceMappingStart(objectLiteral);
+
+            this.writeToOutput("{");
+            this.emitCommaSeparatedList(objectLiteral, objectLiteral.propertyAssignments, " ", true);
+            this.writeToOutput("}");
+
+            this.recordSourceMappingEnd(objectLiteral);
+        };
+
+        Emitter.prototype.emitArrayLiteralExpression = function (arrayLiteral) {
+            this.recordSourceMappingStart(arrayLiteral);
+
+            this.writeToOutput("[");
+            this.emitCommaSeparatedList(arrayLiteral, arrayLiteral.expressions, "", true);
+            this.writeToOutput("]");
+
+            this.recordSourceMappingEnd(arrayLiteral);
+        };
+
+        Emitter.prototype.emitObjectCreationExpression = function (objectCreationExpression) {
+            this.recordSourceMappingStart(objectCreationExpression);
+            this.writeToOutput("new ");
+            var target = objectCreationExpression.expression;
+
+            this.emit(target);
+            if (objectCreationExpression.argumentList) {
+                this.recordSourceMappingStart(objectCreationExpression.argumentList);
+                this.writeToOutput("(");
+                this.emitCommaSeparatedList(objectCreationExpression.argumentList, objectCreationExpression.argumentList.arguments, "", false);
+                this.writeToOutputWithSourceMapRecord(")", objectCreationExpression.argumentList.closeParenToken);
+                this.recordSourceMappingEnd(objectCreationExpression.argumentList);
+            }
+
+            this.recordSourceMappingEnd(objectCreationExpression);
+        };
+
+        Emitter.prototype.getConstantDecl = function (dotExpr) {
+            var pullSymbol = this.semanticInfoChain.getSymbolForAST(dotExpr);
+            if (pullSymbol && pullSymbol.kind === 67108864 /* EnumMember */) {
+                var pullDecls = pullSymbol.getDeclarations();
+                if (pullDecls.length === 1) {
+                    var pullDecl = pullDecls[0];
+                    if (pullDecl.kind === 67108864 /* EnumMember */) {
+                        return pullDecl;
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        Emitter.prototype.tryEmitConstant = function (dotExpr) {
+            var propertyName = dotExpr.name;
+            var boundDecl = this.getConstantDecl(dotExpr);
+            if (boundDecl) {
+                var value = boundDecl.constantValue;
+                if (value !== null) {
+                    this.recordSourceMappingStart(dotExpr);
+                    this.writeToOutput(value.toString());
+                    var comment = " /* ";
+                    comment += propertyName.text();
+                    comment += " */";
+                    this.writeToOutput(comment);
+                    this.recordSourceMappingEnd(dotExpr);
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        Emitter.prototype.emitInvocationExpression = function (callNode) {
+            this.recordSourceMappingStart(callNode);
+            var target = callNode.expression;
+            var args = callNode.argumentList.arguments;
+
+            if (target.kind() === 212 /* MemberAccessExpression */ && target.expression.kind() === 50 /* SuperKeyword */) {
+                this.emit(target);
+                this.writeToOutput(".call");
+                this.recordSourceMappingStart(args);
+                this.writeToOutput("(");
+                this.emitThis();
+                if (args && args.nonSeparatorCount() > 0) {
+                    this.writeToOutput(", ");
+                    this.emitCommaSeparatedList(callNode.argumentList, args, "", false);
+                }
+            } else {
+                if (callNode.expression.kind() === 50 /* SuperKeyword */ && this.emitState.container === 4 /* Constructor */) {
+                    this.writeToOutput("_super.call");
+                } else {
+                    this.emitJavascript(target, false);
+                }
+                this.recordSourceMappingStart(args);
+                this.writeToOutput("(");
+                if (callNode.expression.kind() === 50 /* SuperKeyword */ && this.emitState.container === 4 /* Constructor */) {
+                    this.writeToOutput("this");
+                    if (args && args.nonSeparatorCount() > 0) {
+                        this.writeToOutput(", ");
+                    }
+                }
+                this.emitCommaSeparatedList(callNode.argumentList, args, "", false);
+            }
+
+            this.writeToOutputWithSourceMapRecord(")", callNode.argumentList.closeParenToken);
+            this.recordSourceMappingEnd(args);
+            this.recordSourceMappingEnd(callNode);
+        };
+
+        Emitter.prototype.emitParameterList = function (list) {
+            this.writeToOutput("(");
+            this.emitCommentsArray(list.openParenTrailingComments, true);
+            this.emitFunctionParameters(TypeScript.ASTHelpers.parametersFromParameterList(list));
+            this.writeToOutput(")");
+        };
+
+        Emitter.prototype.emitFunctionParameters = function (parameters) {
+            var argsLen = 0;
+
+            if (parameters) {
+                this.emitComments(parameters.ast, true);
+
+                var tempContainer = this.setContainer(6 /* Args */);
+                argsLen = parameters.length;
+                var printLen = argsLen;
+                if (parameters.lastParameterIsRest()) {
+                    printLen--;
+                }
+                for (var i = 0; i < printLen; i++) {
+                    var arg = parameters.astAt(i);
+                    this.emit(arg);
+
+                    if (i < (printLen - 1)) {
+                        this.writeToOutput(", ");
+                    }
+                }
+                this.setContainer(tempContainer);
+
+                this.emitComments(parameters.ast, false);
+            }
+        };
+
+        Emitter.prototype.emitFunctionBodyStatements = function (name, funcDecl, parameterList, block, bodyExpression) {
+            this.writeLineToOutput(" {");
+            if (name) {
+                this.recordSourceMappingNameStart(name);
+            }
+
+            this.indenter.increaseIndent();
+
+            if (block) {
+                this.emitDetachedComments(block.statements);
+            }
+
+            if (this.shouldCaptureThis(funcDecl)) {
+                this.writeCaptureThisStatement(funcDecl);
+            }
+
+            if (parameterList) {
+                this.emitDefaultValueAssignments(parameterList);
+                this.emitRestParameterInitializer(parameterList);
+            }
+
+            if (block) {
+                this.emitList(block.statements);
+                this.emitCommentsArray(block.closeBraceLeadingComments, false);
+            } else {
+                this.emitIndent();
+                this.emitCommentsArray(bodyExpression.preComments(), false);
+                this.writeToOutput("return ");
+                this.emit(bodyExpression);
+                this.writeLineToOutput(";");
+                this.emitCommentsArray(bodyExpression.postComments(), true);
+            }
+
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+
+            if (block) {
+                this.writeToOutputWithSourceMapRecord("}", block.closeBraceToken);
+            } else {
+                this.writeToOutputWithSourceMapRecord("}", bodyExpression);
+            }
+
+            if (name) {
+                this.recordSourceMappingNameEnd();
+            }
+        };
+
+        Emitter.prototype.emitDefaultValueAssignments = function (parameters) {
+            var n = parameters.length;
+            if (parameters.lastParameterIsRest()) {
+                n--;
+            }
+
+            for (var i = 0; i < n; i++) {
+                var arg = parameters.astAt(i);
+                var id = parameters.identifierAt(i);
+                var equalsValueClause = parameters.initializerAt(i);
+                if (equalsValueClause) {
+                    this.emitIndent();
+                    this.recordSourceMappingStart(arg);
+                    this.writeToOutput("if (typeof " + id.text() + " === \"undefined\") { ");
+                    this.writeToOutputWithSourceMapRecord(id.text(), id);
+                    this.emitJavascript(equalsValueClause, false);
+                    this.writeLineToOutput("; }");
+                    this.recordSourceMappingEnd(arg);
+                }
+            }
+        };
+
+        Emitter.prototype.emitRestParameterInitializer = function (parameters) {
+            if (parameters.lastParameterIsRest()) {
+                var n = parameters.length;
+                var lastArg = parameters.astAt(n - 1);
+                var id = parameters.identifierAt(n - 1);
+                this.emitIndent();
+                this.recordSourceMappingStart(lastArg);
+                this.writeToOutput("var ");
+                this.writeToOutputWithSourceMapRecord(id.text(), id);
+                this.writeLineToOutput(" = [];");
+                this.recordSourceMappingEnd(lastArg);
+                this.emitIndent();
+                this.writeToOutput("for (");
+                this.writeToOutputWithSourceMapRecord("var _i = 0;", lastArg);
+                this.writeToOutput(" ");
+                this.writeToOutputWithSourceMapRecord("_i < (arguments.length - " + (n - 1) + ")", lastArg);
+                this.writeToOutput("; ");
+                this.writeToOutputWithSourceMapRecord("_i++", lastArg);
+                this.writeLineToOutput(") {");
+                this.indenter.increaseIndent();
+                this.emitIndent();
+
+                this.writeToOutputWithSourceMapRecord(id.text() + "[_i] = arguments[_i + " + (n - 1) + "];", lastArg);
+                this.writeLineToOutput("");
+                this.indenter.decreaseIndent();
+                this.emitIndent();
+                this.writeLineToOutput("}");
+            }
+        };
+
+        Emitter.prototype.getImportDecls = function (fileName) {
+            var topLevelDecl = this.semanticInfoChain.topLevelDecl(this.document.fileName);
+            var result = [];
+
+            var dynamicModuleDecl = topLevelDecl.getChildDecls()[0];
+            var queue = dynamicModuleDecl.getChildDecls();
+
+            for (var i = 0, n = queue.length; i < n; i++) {
+                var decl = queue[i];
+
+                if (decl.kind & 128 /* TypeAlias */) {
+                    var importStatementAST = this.semanticInfoChain.getASTForDecl(decl);
+                    if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) {
+                        var symbol = decl.getSymbol();
+                        var typeSymbol = symbol && symbol.type;
+                        if (typeSymbol && typeSymbol !== this.semanticInfoChain.anyTypeSymbol && !typeSymbol.isError()) {
+                            result.push(decl);
+                        }
+                    }
+                }
+            }
+
+            return result;
+        };
+
+        Emitter.prototype.getModuleImportAndDependencyList = function (sourceUnit) {
+            var importList = "";
+            var dependencyList = "";
+
+            var importDecls = this.getImportDecls(this.document.fileName);
+
+            if (importDecls.length) {
+                for (var i = 0; i < importDecls.length; i++) {
+                    var importStatementDecl = importDecls[i];
+                    var importStatementSymbol = importStatementDecl.getSymbol();
+                    var importStatementAST = this.semanticInfoChain.getASTForDecl(importStatementDecl);
+
+                    if (importStatementSymbol.isUsedAsValue()) {
+                        if (i <= importDecls.length - 1) {
+                            dependencyList += ", ";
+                            importList += ", ";
+                        }
+
+                        importList += importStatementDecl.name;
+                        dependencyList += importStatementAST.moduleReference.stringLiteral.text();
+                    }
+                }
+            }
+
+            var amdDependencies = this.document.amdDependencies();
+            for (var i = 0; i < amdDependencies.length; i++) {
+                dependencyList += ", \"" + amdDependencies[i] + "\"";
+            }
+
+            return {
+                importList: importList,
+                dependencyList: dependencyList
+            };
+        };
+
+        Emitter.prototype.shouldCaptureThis = function (ast) {
+            if (ast.kind() === 120 /* SourceUnit */) {
+                var scriptDecl = this.semanticInfoChain.topLevelDecl(this.document.fileName);
+                return TypeScript.hasFlag(scriptDecl.flags, 262144 /* MustCaptureThis */);
+            }
+
+            var decl = this.semanticInfoChain.getDeclForAST(ast);
+            if (decl) {
+                return TypeScript.hasFlag(decl.flags, 262144 /* MustCaptureThis */);
+            }
+
+            return false;
+        };
+
+        Emitter.prototype.emitEnum = function (moduleDecl) {
+            var pullDecl = this.semanticInfoChain.getDeclForAST(moduleDecl);
+            this.pushDecl(pullDecl);
+
+            var svModuleName = this.moduleName;
+            this.moduleName = moduleDecl.identifier.text();
+
+            var temp = this.setContainer(1 /* Module */);
+            var isExported = TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */);
+
+            if (!isExported) {
+                this.recordSourceMappingStart(moduleDecl);
+                this.writeToOutput("var ");
+                this.recordSourceMappingStart(moduleDecl.identifier);
+                this.writeToOutput(this.moduleName);
+                this.recordSourceMappingEnd(moduleDecl.identifier);
+                this.writeLineToOutput(";");
+                this.recordSourceMappingEnd(moduleDecl);
+                this.emitIndent();
+            }
+
+            this.writeToOutput("(");
+            this.recordSourceMappingStart(moduleDecl);
+            this.writeToOutput("function (");
+            this.writeToOutputWithSourceMapRecord(this.moduleName, moduleDecl.identifier);
+            this.writeLineToOutput(") {");
+
+            this.recordSourceMappingNameStart(this.moduleName);
+
+            this.indenter.increaseIndent();
+
+            if (this.shouldCaptureThis(moduleDecl)) {
+                this.writeCaptureThisStatement(moduleDecl);
+            }
+
+            this.emitSeparatedList(moduleDecl.enumElements);
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+
+            var parentIsDynamic = temp === 2 /* DynamicModule */;
+            if (temp === 0 /* Prog */ && isExported) {
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.writeToOutput(")(this." + this.moduleName + " || (this." + this.moduleName + " = {}));");
+            } else if (isExported || temp === 0 /* Prog */) {
+                var dotMod = svModuleName !== "" ? (parentIsDynamic ? "exports" : svModuleName) + "." : svModuleName;
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.writeToOutput(")(" + dotMod + this.moduleName + " || (" + dotMod + this.moduleName + " = {}));");
+            } else if (!isExported && temp !== 0 /* Prog */) {
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.writeToOutput(")(" + this.moduleName + " || (" + this.moduleName + " = {}));");
+            } else {
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.writeToOutput(")();");
+            }
+
+            this.recordSourceMappingEnd(moduleDecl);
+            if (temp !== 0 /* Prog */ && isExported) {
+                this.recordSourceMappingStart(moduleDecl);
+                if (parentIsDynamic) {
+                    this.writeLineToOutput("");
+                    this.emitIndent();
+                    this.writeToOutput("var " + this.moduleName + " = exports." + this.moduleName + ";");
+                } else {
+                    this.writeLineToOutput("");
+                    this.emitIndent();
+                    this.writeToOutput("var " + this.moduleName + " = " + svModuleName + "." + this.moduleName + ";");
+                }
+                this.recordSourceMappingEnd(moduleDecl);
+            }
+
+            this.setContainer(temp);
+            this.moduleName = svModuleName;
+
+            this.popDecl(pullDecl);
+        };
+
+        Emitter.prototype.getModuleDeclToVerifyChildNameCollision = function (moduleDecl, changeNameIfAnyDeclarationInContext) {
+            if (TypeScript.ArrayUtilities.contains(this.declStack, moduleDecl)) {
+                return moduleDecl;
+            } else if (changeNameIfAnyDeclarationInContext) {
+                var symbol = moduleDecl.getSymbol();
+                if (symbol) {
+                    var otherDecls = symbol.getDeclarations();
+                    for (var i = 0; i < otherDecls.length; i++) {
+                        if (TypeScript.ArrayUtilities.contains(this.declStack, otherDecls[i])) {
+                            return otherDecls[i];
+                        }
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        Emitter.prototype.hasChildNameCollision = function (moduleName, parentDecl) {
+            var _this = this;
+            var childDecls = parentDecl.getChildDecls();
+            return TypeScript.ArrayUtilities.any(childDecls, function (childDecl) {
+                var childAST = _this.semanticInfoChain.getASTForDecl(childDecl);
+
+                if (childDecl.kind != 67108864 /* EnumMember */ && _this.shouldEmit(childAST)) {
+                    if (childDecl.name === moduleName) {
+                        if (parentDecl.kind != 8 /* Class */) {
+                            return true;
+                        }
+
+                        if (!(childDecl.kind == 65536 /* Method */ || childDecl.kind == 4096 /* Property */ || childDecl.kind == 524288 /* SetAccessor */ || childDecl.kind == 262144 /* GetAccessor */)) {
+                            return true;
+                        }
+                    }
+
+                    if (_this.hasChildNameCollision(moduleName, childDecl)) {
+                        return true;
+                    }
+                }
+                return false;
+            });
+        };
+
+        Emitter.prototype.getModuleName = function (moduleDecl, changeNameIfAnyDeclarationInContext) {
+            var moduleName = moduleDecl.name;
+            var moduleDisplayName = moduleDecl.getDisplayName();
+
+            moduleDecl = this.getModuleDeclToVerifyChildNameCollision(moduleDecl, changeNameIfAnyDeclarationInContext);
+            if (moduleDecl && moduleDecl.kind != 64 /* Enum */) {
+                while (this.hasChildNameCollision(moduleName, moduleDecl)) {
+                    moduleName = "_" + moduleName;
+                    moduleDisplayName = "_" + moduleDisplayName;
+                }
+            }
+
+            return moduleDisplayName;
+        };
+
+        Emitter.prototype.emitModuleDeclarationWorker = function (moduleDecl) {
+            if (moduleDecl.stringLiteral) {
+                this.emitSingleModuleDeclaration(moduleDecl, moduleDecl.stringLiteral);
+            } else {
+                var moduleNames = TypeScript.ASTHelpers.getModuleNames(moduleDecl.name);
+                this.emitSingleModuleDeclaration(moduleDecl, moduleNames[0]);
+            }
+        };
+
+        Emitter.prototype.emitSingleModuleDeclaration = function (moduleDecl, moduleName) {
+            var isLastName = TypeScript.ASTHelpers.isLastNameOfModule(moduleDecl, moduleName);
+
+            if (isLastName) {
+                this.emitComments(moduleDecl, true);
+            }
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(moduleName);
+            this.pushDecl(pullDecl);
+
+            var svModuleName = this.moduleName;
+
+            if (moduleDecl.stringLiteral) {
+                this.moduleName = moduleDecl.stringLiteral.valueText();
+                if (TypeScript.isTSFile(this.moduleName)) {
+                    this.moduleName = this.moduleName.substring(0, this.moduleName.length - ".ts".length);
+                }
+            } else {
+                this.moduleName = moduleName.text();
+            }
+
+            var temp = this.setContainer(1 /* Module */);
+            var isExported = TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */);
+
+            if (!isExported) {
+                this.recordSourceMappingStart(moduleDecl);
+                this.writeToOutput("var ");
+                this.recordSourceMappingStart(moduleName);
+                this.writeToOutput(this.moduleName);
+                this.recordSourceMappingEnd(moduleName);
+                this.writeLineToOutput(";");
+                this.recordSourceMappingEnd(moduleDecl);
+                this.emitIndent();
+            }
+
+            this.writeToOutput("(");
+            this.recordSourceMappingStart(moduleDecl);
+            this.writeToOutput("function (");
+
+            this.moduleName = this.getModuleName(pullDecl);
+            this.writeToOutputWithSourceMapRecord(this.moduleName, moduleName);
+            this.writeLineToOutput(") {");
+
+            this.recordSourceMappingNameStart(moduleName.text());
+
+            this.indenter.increaseIndent();
+
+            if (this.shouldCaptureThis(moduleDecl)) {
+                this.writeCaptureThisStatement(moduleDecl);
+            }
+
+            if (moduleName === moduleDecl.stringLiteral) {
+                this.emitList(moduleDecl.moduleElements);
+            } else {
+                var moduleNames = TypeScript.ASTHelpers.getModuleNames(moduleDecl.name);
+                var nameIndex = moduleNames.indexOf(moduleName);
+                TypeScript.Debug.assert(nameIndex >= 0);
+
+                if (isLastName) {
+                    this.emitList(moduleDecl.moduleElements);
+                } else {
+                    this.emitIndent();
+                    this.emitSingleModuleDeclaration(moduleDecl, moduleNames[nameIndex + 1]);
+                    this.writeLineToOutput("");
+                }
+            }
+
+            this.moduleName = moduleName.text();
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+
+            var parentIsDynamic = temp === 2 /* DynamicModule */;
+            this.recordSourceMappingStart(moduleDecl.endingToken);
+            if (temp === 0 /* Prog */ && isExported) {
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.recordSourceMappingEnd(moduleDecl.endingToken);
+                this.writeToOutput(")(this." + this.moduleName + " || (this." + this.moduleName + " = {}));");
+            } else if (isExported || temp === 0 /* Prog */) {
+                var dotMod = svModuleName !== "" ? (parentIsDynamic ? "exports" : svModuleName) + "." : svModuleName;
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.recordSourceMappingEnd(moduleDecl.endingToken);
+                this.writeToOutput(")(" + dotMod + this.moduleName + " || (" + dotMod + this.moduleName + " = {}));");
+            } else if (!isExported && temp !== 0 /* Prog */) {
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.recordSourceMappingEnd(moduleDecl.endingToken);
+                this.writeToOutput(")(" + this.moduleName + " || (" + this.moduleName + " = {}));");
+            } else {
+                this.writeToOutput("}");
+                this.recordSourceMappingNameEnd();
+                this.recordSourceMappingEnd(moduleDecl.endingToken);
+                this.writeToOutput(")();");
+            }
+
+            this.recordSourceMappingEnd(moduleDecl);
+            if (temp !== 0 /* Prog */ && isExported) {
+                this.recordSourceMappingStart(moduleDecl);
+                if (parentIsDynamic) {
+                    this.writeLineToOutput("");
+                    this.emitIndent();
+                    this.writeToOutput("var " + this.moduleName + " = exports." + this.moduleName + ";");
+                } else {
+                    this.writeLineToOutput("");
+                    this.emitIndent();
+                    this.writeToOutput("var " + this.moduleName + " = " + svModuleName + "." + this.moduleName + ";");
+                }
+                this.recordSourceMappingEnd(moduleDecl);
+            }
+
+            this.setContainer(temp);
+            this.moduleName = svModuleName;
+
+            this.popDecl(pullDecl);
+
+            if (isLastName) {
+                this.emitComments(moduleDecl, false);
+            }
+        };
+
+        Emitter.prototype.emitEnumElement = function (varDecl) {
+            var pullDecl = this.semanticInfoChain.getDeclForAST(varDecl);
+            TypeScript.Debug.assert(pullDecl && pullDecl.kind === 67108864 /* EnumMember */);
+
+            this.emitComments(varDecl, true);
+            this.recordSourceMappingStart(varDecl);
+            var name = varDecl.propertyName.text();
+            var quoted = TypeScript.isQuoted(name);
+            this.writeToOutput(this.moduleName);
+            this.writeToOutput('[');
+            this.writeToOutput(this.moduleName);
+            this.writeToOutput('[');
+            this.writeToOutput(quoted ? name : '"' + name + '"');
+            this.writeToOutput(']');
+
+            if (varDecl.equalsValueClause) {
+                this.emit(varDecl.equalsValueClause);
+            } else if (pullDecl.constantValue !== null) {
+                this.writeToOutput(' = ');
+                this.writeToOutput(pullDecl.constantValue.toString());
+            } else {
+                this.writeToOutput(' = null');
+            }
+
+            this.writeToOutput('] = ');
+            this.writeToOutput(quoted ? name : '"' + name + '"');
+            this.recordSourceMappingEnd(varDecl);
+            this.emitComments(varDecl, false);
+            this.writeToOutput(';');
+        };
+
+        Emitter.prototype.emitElementAccessExpression = function (expression) {
+            this.recordSourceMappingStart(expression);
+            this.emit(expression.expression);
+            this.writeToOutput("[");
+            this.emit(expression.argumentExpression);
+            this.writeToOutput("]");
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.emitSimpleArrowFunctionExpression = function (arrowFunction) {
+            this.emitAnyArrowFunctionExpression(arrowFunction, null, TypeScript.ASTHelpers.parametersFromIdentifier(arrowFunction.identifier), arrowFunction.block, arrowFunction.expression);
+        };
+
+        Emitter.prototype.emitParenthesizedArrowFunctionExpression = function (arrowFunction) {
+            this.emitAnyArrowFunctionExpression(arrowFunction, null, TypeScript.ASTHelpers.parametersFromParameterList(arrowFunction.callSignature.parameterList), arrowFunction.block, arrowFunction.expression);
+        };
+
+        Emitter.prototype.emitAnyArrowFunctionExpression = function (arrowFunction, funcName, parameters, block, expression) {
+            var savedInArrowFunction = this.inArrowFunction;
+            this.inArrowFunction = true;
+
+            var temp = this.setContainer(5 /* Function */);
+
+            this.recordSourceMappingStart(arrowFunction);
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(arrowFunction);
+            this.pushDecl(pullDecl);
+
+            this.emitComments(arrowFunction, true);
+
+            this.recordSourceMappingStart(arrowFunction);
+            this.writeToOutput("function ");
+            this.writeToOutput("(");
+            this.emitFunctionParameters(parameters);
+            this.writeToOutput(")");
+
+            this.emitFunctionBodyStatements(funcName, arrowFunction, parameters, block, expression);
+
+            this.recordSourceMappingEnd(arrowFunction);
+
+            this.recordSourceMappingEnd(arrowFunction);
+
+            this.emitComments(arrowFunction, false);
+
+            this.popDecl(pullDecl);
+            this.setContainer(temp);
+            this.inArrowFunction = savedInArrowFunction;
+        };
+
+        Emitter.prototype.emitConstructor = function (funcDecl) {
+            if (!funcDecl.block) {
+                return;
+            }
+            var temp = this.setContainer(4 /* Constructor */);
+
+            this.recordSourceMappingStart(funcDecl);
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            this.pushDecl(pullDecl);
+
+            this.emitComments(funcDecl, true);
+
+            this.recordSourceMappingStart(funcDecl);
+            this.writeToOutput("function ");
+            this.writeToOutput(this.thisClassNode.identifier.text());
+            this.writeToOutput("(");
+            var parameters = TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList);
+            this.emitFunctionParameters(parameters);
+            this.writeLineToOutput(") {");
+
+            this.recordSourceMappingNameStart("constructor");
+            this.indenter.increaseIndent();
+
+            this.emitDefaultValueAssignments(parameters);
+            this.emitRestParameterInitializer(parameters);
+
+            if (this.shouldCaptureThis(funcDecl)) {
+                this.writeCaptureThisStatement(funcDecl);
+            }
+
+            this.emitConstructorStatements(funcDecl);
+            this.emitCommentsArray(funcDecl.block.closeBraceLeadingComments, false);
+
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+            this.writeToOutputWithSourceMapRecord("}", funcDecl.block.closeBraceToken);
+
+            this.recordSourceMappingNameEnd();
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.emitComments(funcDecl, false);
+
+            this.popDecl(pullDecl);
+            this.setContainer(temp);
+        };
+
+        Emitter.prototype.emitGetAccessor = function (accessor) {
+            this.recordSourceMappingStart(accessor);
+            this.writeToOutput("get ");
+
+            var temp = this.setContainer(5 /* Function */);
+
+            this.recordSourceMappingStart(accessor);
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(accessor);
+            this.pushDecl(pullDecl);
+
+            this.recordSourceMappingStart(accessor);
+
+            var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(accessor, this.semanticInfoChain);
+            var container = accessorSymbol.getContainer();
+            var containerKind = container.kind;
+
+            this.recordSourceMappingNameStart(accessor.propertyName.text());
+            this.writeToOutput(accessor.propertyName.text());
+            this.writeToOutput("(");
+            this.writeToOutput(")");
+
+            this.emitFunctionBodyStatements(null, accessor, TypeScript.ASTHelpers.parametersFromParameterList(accessor.parameterList), accessor.block, null);
+
+            this.recordSourceMappingEnd(accessor);
+
+            this.recordSourceMappingEnd(accessor);
+
+            this.popDecl(pullDecl);
+            this.setContainer(temp);
+            this.recordSourceMappingEnd(accessor);
+        };
+
+        Emitter.prototype.emitSetAccessor = function (accessor) {
+            this.recordSourceMappingStart(accessor);
+            this.writeToOutput("set ");
+
+            var temp = this.setContainer(5 /* Function */);
+
+            this.recordSourceMappingStart(accessor);
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(accessor);
+            this.pushDecl(pullDecl);
+
+            this.recordSourceMappingStart(accessor);
+
+            var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(accessor, this.semanticInfoChain);
+            var container = accessorSymbol.getContainer();
+            var containerKind = container.kind;
+
+            this.recordSourceMappingNameStart(accessor.propertyName.text());
+            this.writeToOutput(accessor.propertyName.text());
+            this.writeToOutput("(");
+
+            var parameters = TypeScript.ASTHelpers.parametersFromParameterList(accessor.parameterList);
+            this.emitFunctionParameters(parameters);
+            this.writeToOutput(")");
+
+            this.emitFunctionBodyStatements(null, accessor, parameters, accessor.block, null);
+
+            this.recordSourceMappingEnd(accessor);
+
+            this.recordSourceMappingEnd(accessor);
+
+            this.popDecl(pullDecl);
+            this.setContainer(temp);
+            this.recordSourceMappingEnd(accessor);
+        };
+
+        Emitter.prototype.emitFunctionExpression = function (funcDecl) {
+            var savedInArrowFunction = this.inArrowFunction;
+            this.inArrowFunction = false;
+
+            var temp = this.setContainer(5 /* Function */);
+
+            var funcName = funcDecl.identifier ? funcDecl.identifier.text() : null;
+
+            this.recordSourceMappingStart(funcDecl);
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            this.pushDecl(pullDecl);
+
+            this.recordSourceMappingStart(funcDecl);
+            this.writeToOutput("function ");
+
+            if (funcDecl.identifier) {
+                this.recordSourceMappingStart(funcDecl.identifier);
+                this.writeToOutput(funcDecl.identifier.text());
+                this.recordSourceMappingEnd(funcDecl.identifier);
+            }
+
+            this.writeToOutput("(");
+
+            var parameters = TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList);
+            this.emitFunctionParameters(parameters);
+            this.writeToOutput(")");
+
+            this.emitFunctionBodyStatements(funcName, funcDecl, parameters, funcDecl.block, null);
+
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.emitComments(funcDecl, false);
+
+            this.popDecl(pullDecl);
+
+            this.setContainer(temp);
+            this.inArrowFunction = savedInArrowFunction;
+        };
+
+        Emitter.prototype.emitFunction = function (funcDecl) {
+            if (funcDecl.block === null) {
+                return;
+            }
+            var savedInArrowFunction = this.inArrowFunction;
+            this.inArrowFunction = false;
+
+            var temp = this.setContainer(5 /* Function */);
+
+            var funcName = funcDecl.identifier.text();
+
+            this.recordSourceMappingStart(funcDecl);
+
+            var printName = funcDecl.identifier !== null;
+            var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            this.pushDecl(pullDecl);
+
+            this.emitComments(funcDecl, true);
+
+            this.recordSourceMappingStart(funcDecl);
+            this.writeToOutput("function ");
+
+            if (printName) {
+                var id = funcDecl.identifier.text();
+                if (id) {
+                    if (funcDecl.identifier) {
+                        this.recordSourceMappingStart(funcDecl.identifier);
+                    }
+                    this.writeToOutput(id);
+                    if (funcDecl.identifier) {
+                        this.recordSourceMappingEnd(funcDecl.identifier);
+                    }
+                }
+            }
+
+            this.emitParameterList(funcDecl.callSignature.parameterList);
+
+            var parameters = TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList);
+            this.emitFunctionBodyStatements(funcDecl.identifier.text(), funcDecl, parameters, funcDecl.block, null);
+
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.emitComments(funcDecl, false);
+
+            this.popDecl(pullDecl);
+
+            this.setContainer(temp);
+            this.inArrowFunction = savedInArrowFunction;
+
+            if (funcDecl.block) {
+                var pullFunctionDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+                if ((this.emitState.container === 1 /* Module */ || this.emitState.container === 2 /* DynamicModule */) && pullFunctionDecl && TypeScript.hasFlag(pullFunctionDecl.flags, 1 /* Exported */)) {
+                    this.writeLineToOutput("");
+                    this.emitIndent();
+                    var modName = this.emitState.container === 1 /* Module */ ? this.moduleName : "exports";
+                    this.recordSourceMappingStart(funcDecl);
+                    this.writeToOutput(modName + "." + funcName + " = " + funcName + ";");
+                    this.recordSourceMappingEnd(funcDecl);
+                }
+            }
+        };
+
+        Emitter.prototype.emitAmbientVarDecl = function (varDecl) {
+            this.recordSourceMappingStart(this.currentVariableDeclaration);
+            if (varDecl.equalsValueClause) {
+                this.emitComments(varDecl, true);
+                this.recordSourceMappingStart(varDecl);
+                this.writeToOutputWithSourceMapRecord(varDecl.propertyName.text(), varDecl.propertyName);
+                this.emitJavascript(varDecl.equalsValueClause, false);
+                this.recordSourceMappingEnd(varDecl);
+                this.emitComments(varDecl, false);
+            }
+        };
+
+        Emitter.prototype.emitVarDeclVar = function () {
+            if (this.currentVariableDeclaration) {
+                this.writeToOutput("var ");
+            }
+        };
+
+        Emitter.prototype.emitVariableDeclaration = function (declaration) {
+            var varDecl = declaration.declarators.nonSeparatorAt(0);
+
+            var symbol = this.semanticInfoChain.getSymbolForAST(varDecl);
+
+            var parentSymbol = symbol ? symbol.getContainer() : null;
+            var parentKind = parentSymbol ? parentSymbol.kind : 0 /* None */;
+
+            this.emitComments(declaration, true);
+
+            var pullVarDecl = this.semanticInfoChain.getDeclForAST(varDecl);
+            var isAmbientWithoutInit = pullVarDecl && TypeScript.hasFlag(pullVarDecl.flags, 8 /* Ambient */) && varDecl.equalsValueClause === null;
+            if (!isAmbientWithoutInit) {
+                var prevVariableDeclaration = this.currentVariableDeclaration;
+                this.currentVariableDeclaration = declaration;
+
+                for (var i = 0, n = declaration.declarators.nonSeparatorCount(); i < n; i++) {
+                    var declarator = declaration.declarators.nonSeparatorAt(i);
+
+                    if (i > 0) {
+                        this.writeToOutput(", ");
+                    }
+
+                    this.emit(declarator);
+                }
+                this.currentVariableDeclaration = prevVariableDeclaration;
+
+                this.recordSourceMappingEnd(declaration);
+            }
+
+            this.emitComments(declaration, false);
+        };
+
+        Emitter.prototype.emitMemberVariableDeclaration = function (varDecl) {
+            TypeScript.Debug.assert(!TypeScript.hasModifier(varDecl.modifiers, 16 /* Static */) && varDecl.variableDeclarator.equalsValueClause);
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(varDecl);
+            this.pushDecl(pullDecl);
+
+            this.emitComments(varDecl, true);
+            this.recordSourceMappingStart(varDecl);
+
+            var varDeclName = varDecl.variableDeclarator.propertyName.text();
+            var quotedOrNumber = TypeScript.isQuoted(varDeclName) || varDecl.variableDeclarator.propertyName.kind() !== 11 /* IdentifierName */;
+
+            var symbol = this.semanticInfoChain.getSymbolForAST(varDecl);
+            var parentSymbol = symbol ? symbol.getContainer() : null;
+            var parentDecl = pullDecl && pullDecl.getParentDecl();
+
+            if (quotedOrNumber) {
+                this.writeToOutput("this[");
+            } else {
+                this.writeToOutput("this.");
+            }
+
+            this.writeToOutputWithSourceMapRecord(varDecl.variableDeclarator.propertyName.text(), varDecl.variableDeclarator.propertyName);
+
+            if (quotedOrNumber) {
+                this.writeToOutput("]");
+            }
+
+            if (varDecl.variableDeclarator.equalsValueClause) {
+                var prevVariableDeclaration = this.currentVariableDeclaration;
+                this.emit(varDecl.variableDeclarator.equalsValueClause);
+                this.currentVariableDeclaration = prevVariableDeclaration;
+            }
+
+            if (this.emitState.container !== 6 /* Args */) {
+                this.writeToOutput(";");
+            }
+
+            this.recordSourceMappingEnd(varDecl);
+            this.emitComments(varDecl, false);
+
+            this.popDecl(pullDecl);
+        };
+
+        Emitter.prototype.emitVariableDeclarator = function (varDecl) {
+            var pullDecl = this.semanticInfoChain.getDeclForAST(varDecl);
+            this.pushDecl(pullDecl);
+            if (pullDecl && (pullDecl.flags & 8 /* Ambient */) === 8 /* Ambient */) {
+                this.emitAmbientVarDecl(varDecl);
+            } else {
+                this.emitComments(varDecl, true);
+                this.recordSourceMappingStart(this.currentVariableDeclaration);
+                this.recordSourceMappingStart(varDecl);
+
+                var varDeclName = varDecl.propertyName.text();
+
+                var symbol = this.semanticInfoChain.getSymbolForAST(varDecl);
+                var parentSymbol = symbol ? symbol.getContainer() : null;
+                var parentDecl = pullDecl && pullDecl.getParentDecl();
+                var parentIsModule = parentDecl && (parentDecl.flags & 102400 /* SomeInitializedModule */);
+
+                if (parentIsModule) {
+                    if (!TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */)) {
+                        this.emitVarDeclVar();
+                    } else {
+                        if (this.emitState.container === 2 /* DynamicModule */) {
+                            this.writeToOutput("exports.");
+                        } else {
+                            this.writeToOutput(this.moduleName + ".");
+                        }
+                    }
+                } else {
+                    this.emitVarDeclVar();
+                }
+
+                this.writeToOutputWithSourceMapRecord(varDecl.propertyName.text(), varDecl.propertyName);
+
+                if (varDecl.equalsValueClause) {
+                    var prevVariableDeclaration = this.currentVariableDeclaration;
+                    this.emit(varDecl.equalsValueClause);
+                    this.currentVariableDeclaration = prevVariableDeclaration;
+                }
+
+                this.recordSourceMappingEnd(varDecl);
+                this.emitComments(varDecl, false);
+            }
+            this.currentVariableDeclaration = undefined;
+            this.popDecl(pullDecl);
+        };
+
+        Emitter.prototype.symbolIsUsedInItsEnclosingContainer = function (symbol, dynamic) {
+            if (typeof dynamic === "undefined") { dynamic = false; }
+            var symDecls = symbol.getDeclarations();
+
+            if (symDecls.length) {
+                var enclosingDecl = this.getEnclosingDecl();
+                if (enclosingDecl) {
+                    var parentDecl = symDecls[0].getParentDecl();
+                    if (parentDecl) {
+                        var symbolDeclarationEnclosingContainer = parentDecl;
+                        var enclosingContainer = enclosingDecl;
+
+                        while (symbolDeclarationEnclosingContainer) {
+                            if (symbolDeclarationEnclosingContainer.kind === (dynamic ? 32 /* DynamicModule */ : 4 /* Container */)) {
+                                break;
+                            }
+                            symbolDeclarationEnclosingContainer = symbolDeclarationEnclosingContainer.getParentDecl();
+                        }
+
+                        if (symbolDeclarationEnclosingContainer) {
+                            while (enclosingContainer) {
+                                if (enclosingContainer.kind === (dynamic ? 32 /* DynamicModule */ : 4 /* Container */)) {
+                                    break;
+                                }
+
+                                enclosingContainer = enclosingContainer.getParentDecl();
+                            }
+                        }
+
+                        if (symbolDeclarationEnclosingContainer && enclosingContainer) {
+                            var same = symbolDeclarationEnclosingContainer === enclosingContainer;
+
+                            if (!same && symbol.anyDeclHasFlag(32768 /* InitializedModule */)) {
+                                same = symbolDeclarationEnclosingContainer === enclosingContainer.getParentDecl();
+                            }
+
+                            return same;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        Emitter.prototype.shouldQualifySymbolNameWithParentName = function (symbol) {
+            var enclosingContextDeclPath = this.declStack;
+            var symbolDeclarations = symbol.getDeclarations();
+            for (var i = 0; i < symbolDeclarations.length; i++) {
+                var currentDecl = symbolDeclarations[i];
+                var declParent = currentDecl.getParentDecl();
+
+                if (currentDecl.kind === 67108864 /* EnumMember */) {
+                    return true;
+                }
+
+                if (!TypeScript.hasFlag(currentDecl.flags, 1 /* Exported */)) {
+                    return false;
+                }
+
+                if (currentDecl.kind === 512 /* Variable */ && !TypeScript.hasFlag(currentDecl.flags, 118784 /* ImplicitVariable */)) {
+                    return true;
+                }
+
+                if (TypeScript.ArrayUtilities.contains(this.declStack, declParent)) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        Emitter.prototype.getSymbolForEmit = function (ast) {
+            var pullSymbol = this.semanticInfoChain.getSymbolForAST(ast);
+            var pullSymbolAlias = this.semanticInfoChain.getAliasSymbolForAST(ast);
+            if (pullSymbol && pullSymbolAlias) {
+                var symbolToCompare = TypeScript.isTypesOnlyLocation(ast) ? pullSymbolAlias.getExportAssignedTypeSymbol() : pullSymbolAlias.getExportAssignedValueSymbol();
+
+                if (pullSymbol === symbolToCompare) {
+                    pullSymbol = pullSymbolAlias;
+                    pullSymbolAlias = null;
+                }
+            }
+            return { symbol: pullSymbol, aliasSymbol: pullSymbolAlias };
+        };
+
+        Emitter.prototype.emitName = function (name, addThis) {
+            this.emitComments(name, true);
+            this.recordSourceMappingStart(name);
+            if (name.text().length > 0) {
+                var symbolForEmit = this.getSymbolForEmit(name);
+                var pullSymbol = symbolForEmit.symbol;
+                if (!pullSymbol) {
+                    pullSymbol = this.semanticInfoChain.anyTypeSymbol;
+                }
+                var pullSymbolAlias = symbolForEmit.aliasSymbol;
+                var pullSymbolKind = pullSymbol.kind;
+                var isLocalAlias = pullSymbolAlias && (pullSymbolAlias.getDeclarations()[0].getParentDecl() === this.getEnclosingDecl());
+                if (addThis && (this.emitState.container !== 6 /* Args */) && pullSymbol) {
+                    var pullSymbolContainer = pullSymbol.getContainer();
+
+                    if (pullSymbolContainer) {
+                        var pullSymbolContainerKind = pullSymbolContainer.kind;
+
+                        if (TypeScript.PullHelpers.symbolIsModule(pullSymbolContainer) || pullSymbolContainerKind === 64 /* Enum */ || pullSymbolContainer.anyDeclHasFlag(32768 /* InitializedModule */ | 4096 /* Enum */)) {
+                            var needToEmitParentName = this.shouldQualifySymbolNameWithParentName(pullSymbol);
+                            if (needToEmitParentName) {
+                                var parentDecl = pullSymbol.getDeclarations()[0].getParentDecl();
+                                TypeScript.Debug.assert(parentDecl && !parentDecl.isRootDecl());
+                                this.writeToOutput(this.getModuleName(parentDecl, true) + ".");
+                            }
+                        } else if (pullSymbolContainerKind === 32 /* DynamicModule */ || pullSymbolContainer.anyDeclHasFlag(65536 /* InitializedDynamicModule */)) {
+                            if (pullSymbolKind === 4096 /* Property */) {
+                                this.writeToOutput("exports.");
+                            } else if (pullSymbol.anyDeclHasFlag(1 /* Exported */) && !isLocalAlias && !pullSymbol.anyDeclHasFlag(118784 /* ImplicitVariable */) && pullSymbol.kind !== 32768 /* ConstructorMethod */ && pullSymbol.kind !== 8 /* Class */ && pullSymbol.kind !== 64 /* Enum */) {
+                                this.writeToOutput("exports.");
+                            }
+                        }
+                    }
+                }
+
+                this.writeToOutput(name.text());
+            }
+
+            this.recordSourceMappingEnd(name);
+            this.emitComments(name, false);
+        };
+
+        Emitter.prototype.recordSourceMappingNameStart = function (name) {
+            if (this.sourceMapper) {
+                var nameIndex = -1;
+                if (name) {
+                    if (this.sourceMapper.currentNameIndex.length > 0) {
+                        var parentNameIndex = this.sourceMapper.currentNameIndex[this.sourceMapper.currentNameIndex.length - 1];
+                        if (parentNameIndex !== -1) {
+                            name = this.sourceMapper.names[parentNameIndex] + "." + name;
+                        }
+                    }
+
+                    var nameIndex = this.sourceMapper.names.length - 1;
+                    for (nameIndex; nameIndex >= 0; nameIndex--) {
+                        if (this.sourceMapper.names[nameIndex] === name) {
+                            break;
+                        }
+                    }
+
+                    if (nameIndex === -1) {
+                        nameIndex = this.sourceMapper.names.length;
+                        this.sourceMapper.names.push(name);
+                    }
+                }
+                this.sourceMapper.currentNameIndex.push(nameIndex);
+            }
+        };
+
+        Emitter.prototype.recordSourceMappingNameEnd = function () {
+            if (this.sourceMapper) {
+                this.sourceMapper.currentNameIndex.pop();
+            }
+        };
+
+        Emitter.prototype.recordSourceMappingStart = function (ast) {
+            if (this.sourceMapper && TypeScript.ASTHelpers.isValidAstNode(ast)) {
+                var lineCol = { line: -1, character: -1 };
+                var sourceMapping = new TypeScript.SourceMapping();
+                sourceMapping.start.emittedColumn = this.emitState.column;
+                sourceMapping.start.emittedLine = this.emitState.line;
+
+                var lineMap = this.document.lineMap();
+                lineMap.fillLineAndCharacterFromPosition(ast.start(), lineCol);
+                sourceMapping.start.sourceColumn = lineCol.character;
+                sourceMapping.start.sourceLine = lineCol.line + 1;
+                lineMap.fillLineAndCharacterFromPosition(ast.end(), lineCol);
+                sourceMapping.end.sourceColumn = lineCol.character;
+                sourceMapping.end.sourceLine = lineCol.line + 1;
+
+                TypeScript.Debug.assert(!isNaN(sourceMapping.start.emittedColumn));
+                TypeScript.Debug.assert(!isNaN(sourceMapping.start.emittedLine));
+                TypeScript.Debug.assert(!isNaN(sourceMapping.start.sourceColumn));
+                TypeScript.Debug.assert(!isNaN(sourceMapping.start.sourceLine));
+                TypeScript.Debug.assert(!isNaN(sourceMapping.end.sourceColumn));
+                TypeScript.Debug.assert(!isNaN(sourceMapping.end.sourceLine));
+
+                if (this.sourceMapper.currentNameIndex.length > 0) {
+                    sourceMapping.nameIndex = this.sourceMapper.currentNameIndex[this.sourceMapper.currentNameIndex.length - 1];
+                }
+
+                var siblings = this.sourceMapper.currentMappings[this.sourceMapper.currentMappings.length - 1];
+                siblings.push(sourceMapping);
+                this.sourceMapper.currentMappings.push(sourceMapping.childMappings);
+                this.sourceMapper.increaseMappingLevel(ast);
+            }
+        };
+
+        Emitter.prototype.recordSourceMappingEnd = function (ast) {
+            if (this.sourceMapper && TypeScript.ASTHelpers.isValidAstNode(ast)) {
+                this.sourceMapper.currentMappings.pop();
+
+                var siblings = this.sourceMapper.currentMappings[this.sourceMapper.currentMappings.length - 1];
+                var sourceMapping = siblings[siblings.length - 1];
+
+                sourceMapping.end.emittedColumn = this.emitState.column;
+                sourceMapping.end.emittedLine = this.emitState.line;
+
+                TypeScript.Debug.assert(!isNaN(sourceMapping.end.emittedColumn));
+                TypeScript.Debug.assert(!isNaN(sourceMapping.end.emittedLine));
+
+                this.sourceMapper.decreaseMappingLevel(ast);
+            }
+        };
+
+        Emitter.prototype.getOutputFiles = function () {
+            var result = [];
+            if (this.sourceMapper !== null) {
+                this.sourceMapper.emitSourceMapping();
+                result.push(this.sourceMapper.getOutputFile());
+            }
+
+            result.push(this.outfile.getOutputFile());
+            return result;
+        };
+
+        Emitter.prototype.emitParameterPropertyAndMemberVariableAssignments = function () {
+            var constructorDecl = getLastConstructor(this.thisClassNode);
+
+            if (constructorDecl) {
+                for (var i = 0, n = constructorDecl.callSignature.parameterList.parameters.nonSeparatorCount(); i < n; i++) {
+                    var parameter = constructorDecl.callSignature.parameterList.parameters.nonSeparatorAt(i);
+                    var parameterDecl = this.semanticInfoChain.getDeclForAST(parameter);
+                    if (TypeScript.hasFlag(parameterDecl.flags, 8388608 /* PropertyParameter */)) {
+                        this.emitIndent();
+                        this.recordSourceMappingStart(parameter);
+                        this.writeToOutputWithSourceMapRecord("this." + parameter.identifier.text(), parameter.identifier);
+                        this.writeToOutput(" = ");
+                        this.writeToOutputWithSourceMapRecord(parameter.identifier.text(), parameter.identifier);
+                        this.writeLineToOutput(";");
+                        this.recordSourceMappingEnd(parameter);
+                    }
+                }
+            }
+
+            for (var i = 0, n = this.thisClassNode.classElements.childCount(); i < n; i++) {
+                if (this.thisClassNode.classElements.childAt(i).kind() === 136 /* MemberVariableDeclaration */) {
+                    var varDecl = this.thisClassNode.classElements.childAt(i);
+                    if (!TypeScript.hasModifier(varDecl.modifiers, 16 /* Static */) && varDecl.variableDeclarator.equalsValueClause) {
+                        this.emitIndent();
+                        this.emitMemberVariableDeclaration(varDecl);
+                        this.writeLineToOutput("");
+                    }
+                }
+            }
+        };
+
+        Emitter.prototype.isOnSameLine = function (pos1, pos2) {
+            var lineMap = this.document.lineMap();
+            return lineMap.getLineNumberFromPosition(pos1) === lineMap.getLineNumberFromPosition(pos2);
+        };
+
+        Emitter.prototype.emitCommaSeparatedList = function (parent, list, buffer, preserveNewLines) {
+            if (list === null || list.nonSeparatorCount() === 0) {
+                return;
+            }
+
+            var startLine = preserveNewLines && !this.isOnSameLine(parent.end(), list.nonSeparatorAt(0).end());
+
+            if (preserveNewLines) {
+                this.indenter.increaseIndent();
+            }
+
+            if (startLine) {
+                this.writeLineToOutput("");
+            } else {
+                this.writeToOutput(buffer);
+            }
+
+            for (var i = 0, n = list.nonSeparatorCount(); i < n; i++) {
+                var emitNode = list.nonSeparatorAt(i);
+
+                this.emitJavascript(emitNode, startLine);
+
+                if (i < (n - 1)) {
+                    startLine = preserveNewLines && !this.isOnSameLine(emitNode.end(), list.nonSeparatorAt(i + 1).start());
+                    if (startLine) {
+                        this.writeLineToOutput(",");
+                    } else {
+                        this.writeToOutput(", ");
+                    }
+                }
+            }
+
+            if (preserveNewLines) {
+                this.indenter.decreaseIndent();
+            }
+
+            if (preserveNewLines && !this.isOnSameLine(parent.end(), list.nonSeparatorAt(list.nonSeparatorCount() - 1).end())) {
+                this.writeLineToOutput("");
+                this.emitIndent();
+            } else {
+                this.writeToOutput(buffer);
+            }
+        };
+
+        Emitter.prototype.emitList = function (list, useNewLineSeparator, startInclusive, endExclusive) {
+            if (typeof useNewLineSeparator === "undefined") { useNewLineSeparator = true; }
+            if (typeof startInclusive === "undefined") { startInclusive = 0; }
+            if (typeof endExclusive === "undefined") { endExclusive = list.childCount(); }
+            if (list === null) {
+                return;
+            }
+
+            this.emitComments(list, true);
+            var lastEmittedNode = null;
+
+            for (var i = startInclusive; i < endExclusive; i++) {
+                var node = list.childAt(i);
+
+                if (this.shouldEmit(node)) {
+                    this.emitSpaceBetweenConstructs(lastEmittedNode, node);
+
+                    this.emitJavascript(node, true);
+                    if (useNewLineSeparator) {
+                        this.writeLineToOutput("");
+                    }
+
+                    lastEmittedNode = node;
+                }
+            }
+
+            this.emitComments(list, false);
+        };
+
+        Emitter.prototype.emitSeparatedList = function (list, useNewLineSeparator, startInclusive, endExclusive) {
+            if (typeof useNewLineSeparator === "undefined") { useNewLineSeparator = true; }
+            if (typeof startInclusive === "undefined") { startInclusive = 0; }
+            if (typeof endExclusive === "undefined") { endExclusive = list.nonSeparatorCount(); }
+            if (list === null) {
+                return;
+            }
+
+            this.emitComments(list, true);
+            var lastEmittedNode = null;
+
+            for (var i = startInclusive; i < endExclusive; i++) {
+                var node = list.nonSeparatorAt(i);
+
+                if (this.shouldEmit(node)) {
+                    this.emitSpaceBetweenConstructs(lastEmittedNode, node);
+
+                    this.emitJavascript(node, true);
+                    if (useNewLineSeparator) {
+                        this.writeLineToOutput("");
+                    }
+
+                    lastEmittedNode = node;
+                }
+            }
+
+            this.emitComments(list, false);
+        };
+
+        Emitter.prototype.isDirectivePrologueElement = function (node) {
+            if (node.kind() === 149 /* ExpressionStatement */) {
+                var exprStatement = node;
+                return exprStatement.expression.kind() === 14 /* StringLiteral */;
+            }
+
+            return false;
+        };
+
+        Emitter.prototype.emitSpaceBetweenConstructs = function (node1, node2) {
+            if (node1 === null || node2 === null) {
+                return;
+            }
+
+            if (node1.start() === -1 || node1.end() === -1 || node2.start() === -1 || node2.end() === -1) {
+                return;
+            }
+
+            var lineMap = this.document.lineMap();
+            var node1EndLine = lineMap.getLineNumberFromPosition(node1.end());
+            var node2StartLine = lineMap.getLineNumberFromPosition(node2.start());
+
+            if ((node2StartLine - node1EndLine) > 1) {
+                this.writeLineToOutput("", true);
+            }
+        };
+
+        Emitter.prototype.getDetachedComments = function (element) {
+            var preComments = element.preComments();
+            if (preComments) {
+                var lineMap = this.document.lineMap();
+
+                var detachedComments = [];
+                var lastComment = null;
+
+                for (var i = 0, n = preComments.length; i < n; i++) {
+                    var comment = preComments[i];
+
+                    if (lastComment) {
+                        var lastCommentLine = lineMap.getLineNumberFromPosition(lastComment.end());
+                        var commentLine = lineMap.getLineNumberFromPosition(comment.start());
+
+                        if (commentLine >= lastCommentLine + 2) {
+                            return detachedComments;
+                        }
+                    }
+
+                    detachedComments.push(comment);
+                    lastComment = comment;
+                }
+
+                var lastCommentLine = lineMap.getLineNumberFromPosition(TypeScript.ArrayUtilities.last(detachedComments).end());
+                var astLine = lineMap.getLineNumberFromPosition(element.start());
+                if (astLine >= lastCommentLine + 2) {
+                    return detachedComments;
+                }
+            }
+
+            return [];
+        };
+
+        Emitter.prototype.emitPossibleCopyrightHeaders = function (script) {
+            this.emitDetachedComments(script.moduleElements);
+        };
+
+        Emitter.prototype.emitDetachedComments = function (list) {
+            if (list.childCount() > 0) {
+                var firstElement = list.childAt(0);
+
+                this.detachedCommentsElement = firstElement;
+                this.emitCommentsArray(this.getDetachedComments(this.detachedCommentsElement), false);
+            }
+        };
+
+        Emitter.prototype.emitScriptElements = function (sourceUnit) {
+            var list = sourceUnit.moduleElements;
+
+            this.emitPossibleCopyrightHeaders(sourceUnit);
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                var node = list.childAt(i);
+
+                if (!this.isDirectivePrologueElement(node)) {
+                    break;
+                }
+
+                this.emitJavascript(node, true);
+                this.writeLineToOutput("");
+            }
+
+            this.emitPrologue(sourceUnit);
+
+            var isExternalModule = this.document.isExternalModule();
+            var isNonElidedExternalModule = isExternalModule && !TypeScript.ASTHelpers.scriptIsElided(sourceUnit);
+            if (isNonElidedExternalModule) {
+                this.recordSourceMappingStart(sourceUnit);
+
+                if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) {
+                    var dependencyList = "[\"require\", \"exports\"";
+                    var importList = "require, exports";
+
+                    var importAndDependencyList = this.getModuleImportAndDependencyList(sourceUnit);
+                    importList += importAndDependencyList.importList;
+                    dependencyList += importAndDependencyList.dependencyList + "]";
+
+                    this.writeLineToOutput("define(" + dependencyList + "," + " function(" + importList + ") {");
+                }
+            }
+
+            if (isExternalModule) {
+                var temp = this.setContainer(2 /* DynamicModule */);
+
+                var svModuleName = this.moduleName;
+                this.moduleName = sourceUnit.fileName();
+                if (TypeScript.isTSFile(this.moduleName)) {
+                    this.moduleName = this.moduleName.substring(0, this.moduleName.length - ".ts".length);
+                }
+
+                this.setExportAssignment(null);
+
+                if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) {
+                    this.indenter.increaseIndent();
+                }
+
+                var externalModule = this.semanticInfoChain.getDeclForAST(this.document.sourceUnit());
+
+                if (TypeScript.hasFlag(externalModule.flags, 262144 /* MustCaptureThis */)) {
+                    this.writeCaptureThisStatement(sourceUnit);
+                }
+
+                this.pushDecl(externalModule);
+            }
+
+            this.emitList(list, true, i, n);
+
+            if (isExternalModule) {
+                if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) {
+                    this.indenter.decreaseIndent();
+                }
+
+                if (isNonElidedExternalModule) {
+                    var exportAssignment = this.getExportAssignment();
+                    var exportAssignmentIdentifierText = exportAssignment ? exportAssignment.identifier.text() : null;
+                    var exportAssignmentValueSymbol = externalModule.getSymbol().getExportAssignedValueSymbol();
+
+                    if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) {
+                        if (exportAssignmentIdentifierText && exportAssignmentValueSymbol && !(exportAssignmentValueSymbol.kind & 58720272 /* SomeTypeReference */)) {
+                            this.indenter.increaseIndent();
+                            this.emitIndent();
+                            this.writeToOutputWithSourceMapRecord("return " + exportAssignmentIdentifierText, exportAssignment);
+                            this.writeLineToOutput(";");
+                            this.indenter.decreaseIndent();
+                        }
+                        this.writeToOutput("});");
+                    } else if (exportAssignmentIdentifierText && exportAssignmentValueSymbol && !(exportAssignmentValueSymbol.kind & 58720272 /* SomeTypeReference */)) {
+                        this.emitIndent();
+                        this.writeToOutputWithSourceMapRecord("module.exports = " + exportAssignmentIdentifierText, exportAssignment);
+                        this.writeToOutput(";");
+                    }
+
+                    this.recordSourceMappingEnd(sourceUnit);
+                    this.writeLineToOutput("");
+                }
+
+                this.setContainer(temp);
+                this.moduleName = svModuleName;
+                this.popDecl(externalModule);
+            }
+        };
+
+        Emitter.prototype.emitConstructorStatements = function (funcDecl) {
+            var list = funcDecl.block.statements;
+
+            if (list === null) {
+                return;
+            }
+
+            this.emitComments(list, true);
+
+            var emitPropertyAssignmentsAfterSuperCall = TypeScript.ASTHelpers.getExtendsHeritageClause(this.thisClassNode.heritageClauses) !== null;
+            var propertyAssignmentIndex = emitPropertyAssignmentsAfterSuperCall ? 1 : 0;
+            var lastEmittedNode = null;
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                if (i === propertyAssignmentIndex) {
+                    this.emitParameterPropertyAndMemberVariableAssignments();
+                }
+
+                var node = list.childAt(i);
+
+                if (this.shouldEmit(node)) {
+                    this.emitSpaceBetweenConstructs(lastEmittedNode, node);
+
+                    this.emitJavascript(node, true);
+                    this.writeLineToOutput("");
+
+                    lastEmittedNode = node;
+                }
+            }
+
+            if (i === propertyAssignmentIndex) {
+                this.emitParameterPropertyAndMemberVariableAssignments();
+            }
+
+            this.emitComments(list, false);
+        };
+
+        Emitter.prototype.emitJavascript = function (ast, startLine) {
+            if (ast === null) {
+                return;
+            }
+
+            if (startLine && this.indenter.indentAmt > 0) {
+                this.emitIndent();
+            }
+
+            this.emit(ast);
+        };
+
+        Emitter.prototype.emitAccessorMemberDeclaration = function (funcDecl, name, className, isProto) {
+            if (funcDecl.kind() !== 139 /* GetAccessor */) {
+                var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(funcDecl, this.semanticInfoChain);
+                if (accessorSymbol.getGetter()) {
+                    return;
+                }
+            }
+
+            this.emitIndent();
+            this.recordSourceMappingStart(funcDecl);
+
+            this.writeToOutput("Object.defineProperty(" + className);
+            if (isProto) {
+                this.writeToOutput(".prototype, ");
+            } else {
+                this.writeToOutput(", ");
+            }
+
+            var functionName = name.text();
+            if (TypeScript.isQuoted(functionName)) {
+                this.writeToOutput(functionName);
+            } else {
+                this.writeToOutput('"' + functionName + '"');
+            }
+
+            this.writeLineToOutput(", {");
+
+            this.indenter.increaseIndent();
+
+            var accessors = TypeScript.PullHelpers.getGetterAndSetterFunction(funcDecl, this.semanticInfoChain);
+            if (accessors.getter) {
+                this.emitIndent();
+                this.recordSourceMappingStart(accessors.getter);
+                this.emitComments(accessors.getter, true);
+                this.writeToOutput("get: ");
+                this.emitAccessorBody(accessors.getter, accessors.getter.parameterList, accessors.getter.block);
+                this.writeLineToOutput(",");
+            }
+
+            if (accessors.setter) {
+                this.emitIndent();
+                this.recordSourceMappingStart(accessors.setter);
+                this.emitComments(accessors.setter, true);
+                this.writeToOutput("set: ");
+                this.emitAccessorBody(accessors.setter, accessors.setter.parameterList, accessors.setter.block);
+                this.writeLineToOutput(",");
+            }
+
+            this.emitIndent();
+            this.writeLineToOutput("enumerable: true,");
+            this.emitIndent();
+            this.writeLineToOutput("configurable: true");
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+            this.writeLineToOutput("});");
+            this.recordSourceMappingEnd(funcDecl);
+        };
+
+        Emitter.prototype.emitAccessorBody = function (funcDecl, parameterList, block) {
+            var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            this.pushDecl(pullDecl);
+
+            this.recordSourceMappingStart(funcDecl);
+            this.writeToOutput("function ");
+
+            this.writeToOutput("(");
+
+            var parameters = TypeScript.ASTHelpers.parametersFromParameterList(parameterList);
+            this.emitFunctionParameters(parameters);
+            this.writeToOutput(")");
+
+            this.emitFunctionBodyStatements(null, funcDecl, parameters, block, null);
+
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.recordSourceMappingEnd(funcDecl);
+            this.popDecl(pullDecl);
+        };
+
+        Emitter.prototype.emitClass = function (classDecl) {
+            var pullDecl = this.semanticInfoChain.getDeclForAST(classDecl);
+            this.pushDecl(pullDecl);
+
+            var svClassNode = this.thisClassNode;
+            this.thisClassNode = classDecl;
+            var className = classDecl.identifier.text();
+            this.emitComments(classDecl, true);
+            var temp = this.setContainer(3 /* Class */);
+
+            this.recordSourceMappingStart(classDecl);
+            this.writeToOutput("var " + className);
+
+            var hasBaseClass = TypeScript.ASTHelpers.getExtendsHeritageClause(classDecl.heritageClauses) !== null;
+            var baseTypeReference = null;
+            var varDecl = null;
+
+            if (hasBaseClass) {
+                this.writeLineToOutput(" = (function (_super) {");
+            } else {
+                this.writeLineToOutput(" = (function () {");
+            }
+
+            this.recordSourceMappingNameStart(className);
+            this.indenter.increaseIndent();
+
+            if (hasBaseClass) {
+                baseTypeReference = TypeScript.ASTHelpers.getExtendsHeritageClause(classDecl.heritageClauses).typeNames.nonSeparatorAt(0);
+                this.emitIndent();
+                this.writeToOutputWithSourceMapRecord("__extends(" + className + ", _super)", baseTypeReference);
+                this.writeLineToOutput(";");
+            }
+
+            this.emitIndent();
+
+            var constrDecl = getLastConstructor(classDecl);
+
+            if (constrDecl) {
+                this.emit(constrDecl);
+                this.writeLineToOutput("");
+            } else {
+                this.recordSourceMappingStart(classDecl);
+
+                this.indenter.increaseIndent();
+                this.writeLineToOutput("function " + classDecl.identifier.text() + "() {");
+                this.recordSourceMappingNameStart("constructor");
+                if (hasBaseClass) {
+                    this.emitIndent();
+                    this.writeToOutputWithSourceMapRecord("_super.apply(this, arguments)", baseTypeReference);
+                    this.writeLineToOutput(";");
+                }
+
+                if (this.shouldCaptureThis(classDecl)) {
+                    this.writeCaptureThisStatement(classDecl);
+                }
+
+                this.emitParameterPropertyAndMemberVariableAssignments();
+
+                this.indenter.decreaseIndent();
+                this.emitIndent();
+                this.writeToOutputWithSourceMapRecord("}", classDecl.closeBraceToken);
+                this.writeLineToOutput("");
+
+                this.recordSourceMappingNameEnd();
+                this.recordSourceMappingEnd(classDecl);
+            }
+
+            this.emitClassMembers(classDecl);
+
+            this.emitIndent();
+            this.writeToOutputWithSourceMapRecord("return " + className + ";", classDecl.closeBraceToken);
+            this.writeLineToOutput("");
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+            this.writeToOutputWithSourceMapRecord("}", classDecl.closeBraceToken);
+            this.recordSourceMappingNameEnd();
+            this.recordSourceMappingStart(classDecl);
+            this.writeToOutput(")(");
+            if (hasBaseClass) {
+                this.emitJavascript(baseTypeReference, false);
+            }
+            this.writeToOutput(");");
+            this.recordSourceMappingEnd(classDecl);
+
+            if ((temp === 1 /* Module */ || temp === 2 /* DynamicModule */) && TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */)) {
+                this.writeLineToOutput("");
+                this.emitIndent();
+                var modName = temp === 1 /* Module */ ? this.moduleName : "exports";
+                this.writeToOutputWithSourceMapRecord(modName + "." + className + " = " + className + ";", classDecl);
+            }
+
+            this.recordSourceMappingEnd(classDecl);
+            this.emitComments(classDecl, false);
+            this.setContainer(temp);
+            this.thisClassNode = svClassNode;
+
+            this.popDecl(pullDecl);
+        };
+
+        Emitter.prototype.emitClassMembers = function (classDecl) {
+            var lastEmittedMember = null;
+
+            for (var i = 0, n = classDecl.classElements.childCount(); i < n; i++) {
+                var memberDecl = classDecl.classElements.childAt(i);
+
+                if (memberDecl.kind() === 139 /* GetAccessor */) {
+                    this.emitSpaceBetweenConstructs(lastEmittedMember, memberDecl);
+                    var getter = memberDecl;
+                    this.emitAccessorMemberDeclaration(getter, getter.propertyName, classDecl.identifier.text(), !TypeScript.hasModifier(getter.modifiers, 16 /* Static */));
+                    lastEmittedMember = memberDecl;
+                } else if (memberDecl.kind() === 140 /* SetAccessor */) {
+                    this.emitSpaceBetweenConstructs(lastEmittedMember, memberDecl);
+                    var setter = memberDecl;
+                    this.emitAccessorMemberDeclaration(setter, setter.propertyName, classDecl.identifier.text(), !TypeScript.hasModifier(setter.modifiers, 16 /* Static */));
+                    lastEmittedMember = memberDecl;
+                } else if (memberDecl.kind() === 135 /* MemberFunctionDeclaration */) {
+                    var memberFunction = memberDecl;
+
+                    if (memberFunction.block) {
+                        this.emitSpaceBetweenConstructs(lastEmittedMember, memberDecl);
+
+                        this.emitClassMemberFunctionDeclaration(classDecl, memberFunction);
+                        lastEmittedMember = memberDecl;
+                    }
+                }
+            }
+
+            for (var i = 0, n = classDecl.classElements.childCount(); i < n; i++) {
+                var memberDecl = classDecl.classElements.childAt(i);
+
+                if (memberDecl.kind() === 136 /* MemberVariableDeclaration */) {
+                    var varDecl = memberDecl;
+
+                    if (TypeScript.hasModifier(varDecl.modifiers, 16 /* Static */) && varDecl.variableDeclarator.equalsValueClause) {
+                        this.emitSpaceBetweenConstructs(lastEmittedMember, varDecl);
+
+                        this.emitIndent();
+                        this.recordSourceMappingStart(varDecl);
+
+                        var varDeclName = varDecl.variableDeclarator.propertyName.text();
+                        if (TypeScript.isQuoted(varDeclName) || varDecl.variableDeclarator.propertyName.kind() !== 11 /* IdentifierName */) {
+                            this.writeToOutput(classDecl.identifier.text() + "[" + varDeclName + "]");
+                        } else {
+                            this.writeToOutput(classDecl.identifier.text() + "." + varDeclName);
+                        }
+
+                        this.emit(varDecl.variableDeclarator.equalsValueClause);
+
+                        this.recordSourceMappingEnd(varDecl);
+                        this.writeLineToOutput(";");
+
+                        lastEmittedMember = varDecl;
+                    }
+                }
+            }
+        };
+
+        Emitter.prototype.emitClassMemberFunctionDeclaration = function (classDecl, funcDecl) {
+            this.emitIndent();
+            this.recordSourceMappingStart(funcDecl);
+            this.emitComments(funcDecl, true);
+            var functionName = funcDecl.propertyName.text();
+
+            this.writeToOutput(classDecl.identifier.text());
+
+            if (!TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */)) {
+                this.writeToOutput(".prototype");
+            }
+
+            if (TypeScript.isQuoted(functionName) || funcDecl.propertyName.kind() !== 11 /* IdentifierName */) {
+                this.writeToOutput("[" + functionName + "] = ");
+            } else {
+                this.writeToOutput("." + functionName + " = ");
+            }
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            this.pushDecl(pullDecl);
+
+            this.recordSourceMappingStart(funcDecl);
+            this.writeToOutput("function ");
+
+            this.emitParameterList(funcDecl.callSignature.parameterList);
+
+            var parameters = TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList);
+            this.emitFunctionBodyStatements(funcDecl.propertyName.text(), funcDecl, parameters, funcDecl.block, null);
+
+            this.recordSourceMappingEnd(funcDecl);
+
+            this.emitComments(funcDecl, false);
+
+            this.recordSourceMappingEnd(funcDecl);
+            this.popDecl(pullDecl);
+
+            this.writeLineToOutput(";");
+        };
+
+        Emitter.prototype.requiresExtendsBlock = function (moduleElements) {
+            for (var i = 0, n = moduleElements.childCount(); i < n; i++) {
+                var moduleElement = moduleElements.childAt(i);
+
+                if (moduleElement.kind() === 130 /* ModuleDeclaration */) {
+                    var moduleAST = moduleElement;
+
+                    if (!TypeScript.hasModifier(moduleAST.modifiers, 8 /* Ambient */) && this.requiresExtendsBlock(moduleAST.moduleElements)) {
+                        return true;
+                    }
+                } else if (moduleElement.kind() === 131 /* ClassDeclaration */) {
+                    var classDeclaration = moduleElement;
+
+                    if (!TypeScript.hasModifier(classDeclaration.modifiers, 8 /* Ambient */) && TypeScript.ASTHelpers.getExtendsHeritageClause(classDeclaration.heritageClauses) !== null) {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        Emitter.prototype.emitPrologue = function (sourceUnit) {
+            if (!this.extendsPrologueEmitted) {
+                if (this.requiresExtendsBlock(sourceUnit.moduleElements)) {
+                    this.extendsPrologueEmitted = true;
+                    this.writeLineToOutput("var __extends = this.__extends || function (d, b) {");
+                    this.writeLineToOutput("    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];");
+                    this.writeLineToOutput("    function __() { this.constructor = d; }");
+                    this.writeLineToOutput("    __.prototype = b.prototype;");
+                    this.writeLineToOutput("    d.prototype = new __();");
+                    this.writeLineToOutput("};");
+                }
+            }
+
+            if (!this.globalThisCapturePrologueEmitted) {
+                if (this.shouldCaptureThis(sourceUnit)) {
+                    this.globalThisCapturePrologueEmitted = true;
+                    this.writeLineToOutput(this.captureThisStmtString);
+                }
+            }
+        };
+
+        Emitter.prototype.emitThis = function () {
+            if (!this.inWithBlock && this.inArrowFunction) {
+                this.writeToOutput("_this");
+            } else {
+                this.writeToOutput("this");
+            }
+        };
+
+        Emitter.prototype.emitBlockOrStatement = function (node) {
+            if (node.kind() === 146 /* Block */) {
+                this.emit(node);
+            } else {
+                this.writeLineToOutput("");
+                this.indenter.increaseIndent();
+                this.emitJavascript(node, true);
+                this.indenter.decreaseIndent();
+            }
+        };
+
+        Emitter.prototype.emitLiteralExpression = function (expression) {
+            switch (expression.kind()) {
+                case 32 /* NullKeyword */:
+                    this.writeToOutputWithSourceMapRecord("null", expression);
+                    break;
+                case 24 /* FalseKeyword */:
+                    this.writeToOutputWithSourceMapRecord("false", expression);
+                    break;
+                case 37 /* TrueKeyword */:
+                    this.writeToOutputWithSourceMapRecord("true", expression);
+                    break;
+                default:
+                    throw TypeScript.Errors.abstract();
+            }
+        };
+
+        Emitter.prototype.emitThisExpression = function (expression) {
+            if (!this.inWithBlock && this.inArrowFunction) {
+                this.writeToOutputWithSourceMapRecord("_this", expression);
+            } else {
+                this.writeToOutputWithSourceMapRecord("this", expression);
+            }
+        };
+
+        Emitter.prototype.emitSuperExpression = function (expression) {
+            this.writeToOutputWithSourceMapRecord("_super.prototype", expression);
+        };
+
+        Emitter.prototype.emitParenthesizedExpression = function (parenthesizedExpression) {
+            if (parenthesizedExpression.expression.kind() === 220 /* CastExpression */ && parenthesizedExpression.openParenTrailingComments === null) {
+                this.emit(parenthesizedExpression.expression);
+            } else {
+                this.recordSourceMappingStart(parenthesizedExpression);
+                this.writeToOutput("(");
+                this.emitCommentsArray(parenthesizedExpression.openParenTrailingComments, false);
+                this.emit(parenthesizedExpression.expression);
+                this.writeToOutput(")");
+                this.recordSourceMappingEnd(parenthesizedExpression);
+            }
+        };
+
+        Emitter.prototype.emitCastExpression = function (expression) {
+            this.emit(expression.expression);
+        };
+
+        Emitter.prototype.emitPrefixUnaryExpression = function (expression) {
+            var nodeType = expression.kind();
+
+            this.recordSourceMappingStart(expression);
+            switch (nodeType) {
+                case 167 /* LogicalNotExpression */:
+                    this.writeToOutput("!");
+                    this.emit(expression.operand);
+                    break;
+                case 166 /* BitwiseNotExpression */:
+                    this.writeToOutput("~");
+                    this.emit(expression.operand);
+                    break;
+                case 165 /* NegateExpression */:
+                    this.writeToOutput("-");
+                    if (expression.operand.kind() === 165 /* NegateExpression */ || expression.operand.kind() === 169 /* PreDecrementExpression */) {
+                        this.writeToOutput(" ");
+                    }
+                    this.emit(expression.operand);
+                    break;
+                case 164 /* PlusExpression */:
+                    this.writeToOutput("+");
+                    if (expression.operand.kind() === 164 /* PlusExpression */ || expression.operand.kind() === 168 /* PreIncrementExpression */) {
+                        this.writeToOutput(" ");
+                    }
+                    this.emit(expression.operand);
+                    break;
+                case 168 /* PreIncrementExpression */:
+                    this.writeToOutput("++");
+                    this.emit(expression.operand);
+                    break;
+                case 169 /* PreDecrementExpression */:
+                    this.writeToOutput("--");
+                    this.emit(expression.operand);
+                    break;
+                default:
+                    throw TypeScript.Errors.abstract();
+            }
+
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.emitPostfixUnaryExpression = function (expression) {
+            var nodeType = expression.kind();
+
+            this.recordSourceMappingStart(expression);
+            switch (nodeType) {
+                case 210 /* PostIncrementExpression */:
+                    this.emit(expression.operand);
+                    this.writeToOutput("++");
+                    break;
+                case 211 /* PostDecrementExpression */:
+                    this.emit(expression.operand);
+                    this.writeToOutput("--");
+                    break;
+                default:
+                    throw TypeScript.Errors.abstract();
+            }
+
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.emitTypeOfExpression = function (expression) {
+            this.recordSourceMappingStart(expression);
+            this.writeToOutput("typeof ");
+            this.emit(expression.expression);
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.emitDeleteExpression = function (expression) {
+            this.recordSourceMappingStart(expression);
+            this.writeToOutput("delete ");
+            this.emit(expression.expression);
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.emitVoidExpression = function (expression) {
+            this.recordSourceMappingStart(expression);
+            this.writeToOutput("void ");
+            this.emit(expression.expression);
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.canEmitDottedNameMemberAccessExpression = function (expression) {
+            var memberExpressionNodeType = expression.expression.kind();
+
+            if (memberExpressionNodeType === 11 /* IdentifierName */ || memberExpressionNodeType == 212 /* MemberAccessExpression */) {
+                var memberAccessSymbol = this.getSymbolForEmit(expression).symbol;
+                var memberAccessExpressionSymbol = this.getSymbolForEmit(expression.expression).symbol;
+                if (memberAccessSymbol && memberAccessExpressionSymbol && !this.semanticInfoChain.getAliasSymbolForAST(expression.expression) && (TypeScript.PullHelpers.symbolIsModule(memberAccessExpressionSymbol) || memberAccessExpressionSymbol.kind === 64 /* Enum */ || memberAccessExpressionSymbol.anyDeclHasFlag(32768 /* InitializedModule */ | 4096 /* Enum */))) {
+                    var memberAccessSymbolKind = memberAccessSymbol.kind;
+                    if (memberAccessSymbolKind === 4096 /* Property */ || memberAccessSymbolKind === 67108864 /* EnumMember */ || (memberAccessSymbol.anyDeclHasFlag(1 /* Exported */) && memberAccessSymbolKind === 512 /* Variable */ && !memberAccessSymbol.anyDeclHasFlag(32768 /* InitializedModule */ | 4096 /* Enum */)) || ((memberAccessSymbol.anyDeclHasFlag(1 /* Exported */) && !this.symbolIsUsedInItsEnclosingContainer(memberAccessSymbol)))) {
+                        if (memberExpressionNodeType === 212 /* MemberAccessExpression */) {
+                            return this.canEmitDottedNameMemberAccessExpression(expression.expression);
+                        }
+
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        Emitter.prototype.emitDottedNameMemberAccessExpression = function (expression) {
+            this.recordSourceMappingStart(expression);
+            if (expression.expression.kind() === 212 /* MemberAccessExpression */) {
+                this.emitDottedNameMemberAccessExpressionRecurse(expression.expression);
+            } else {
+                this.emitName(expression.expression, true);
+            }
+
+            this.writeToOutput(".");
+            this.emitName(expression.name, false);
+
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.emitDottedNameMemberAccessExpressionRecurse = function (expression) {
+            this.emitComments(expression, true);
+            this.emitDottedNameMemberAccessExpression(expression);
+            this.emitComments(expression, false);
+        };
+
+        Emitter.prototype.emitMemberAccessExpression = function (expression) {
+            if (!this.tryEmitConstant(expression)) {
+                if (this.canEmitDottedNameMemberAccessExpression(expression)) {
+                    this.emitDottedNameMemberAccessExpression(expression);
+                } else {
+                    this.recordSourceMappingStart(expression);
+                    this.emit(expression.expression);
+                    this.writeToOutput(".");
+                    this.emitName(expression.name, false);
+                    this.recordSourceMappingEnd(expression);
+                }
+            }
+        };
+
+        Emitter.prototype.emitQualifiedName = function (name) {
+            this.recordSourceMappingStart(name);
+
+            this.emit(name.left);
+            this.writeToOutput(".");
+            this.emitName(name.right, false);
+
+            this.recordSourceMappingEnd(name);
+        };
+
+        Emitter.prototype.emitBinaryExpression = function (expression) {
+            this.recordSourceMappingStart(expression);
+            switch (expression.kind()) {
+                case 173 /* CommaExpression */:
+                    this.emit(expression.left);
+                    this.writeToOutput(", ");
+                    this.emit(expression.right);
+                    break;
+                default: {
+                    this.emit(expression.left);
+                    var binOp = TypeScript.SyntaxFacts.getText(TypeScript.SyntaxFacts.getOperatorTokenFromBinaryExpression(expression.kind()));
+                    if (binOp === "instanceof") {
+                        this.writeToOutput(" instanceof ");
+                    } else if (binOp === "in") {
+                        this.writeToOutput(" in ");
+                    } else {
+                        this.writeToOutput(" " + binOp + " ");
+                    }
+                    this.emit(expression.right);
+                }
+            }
+            this.recordSourceMappingEnd(expression);
+        };
+
+        Emitter.prototype.emitSimplePropertyAssignment = function (property) {
+            this.recordSourceMappingStart(property);
+            this.emit(property.propertyName);
+            this.writeToOutput(": ");
+            this.emit(property.expression);
+            this.recordSourceMappingEnd(property);
+        };
+
+        Emitter.prototype.emitFunctionPropertyAssignment = function (funcProp) {
+            this.recordSourceMappingStart(funcProp);
+
+            this.emit(funcProp.propertyName);
+            this.writeToOutput(": ");
+
+            var pullFunctionDecl = this.semanticInfoChain.getDeclForAST(funcProp);
+
+            var savedInArrowFunction = this.inArrowFunction;
+            this.inArrowFunction = false;
+
+            var temp = this.setContainer(5 /* Function */);
+            var funcName = funcProp.propertyName;
+
+            var pullDecl = this.semanticInfoChain.getDeclForAST(funcProp);
+            this.pushDecl(pullDecl);
+
+            this.recordSourceMappingStart(funcProp);
+            this.writeToOutput("function ");
+
+            this.writeToOutput("(");
+
+            var parameters = TypeScript.ASTHelpers.parametersFromParameterList(funcProp.callSignature.parameterList);
+            this.emitFunctionParameters(parameters);
+            this.writeToOutput(")");
+
+            this.emitFunctionBodyStatements(funcProp.propertyName.text(), funcProp, parameters, funcProp.block, null);
+
+            this.recordSourceMappingEnd(funcProp);
+
+            this.recordSourceMappingEnd(funcProp);
+
+            this.emitComments(funcProp, false);
+
+            this.popDecl(pullDecl);
+
+            this.setContainer(temp);
+            this.inArrowFunction = savedInArrowFunction;
+        };
+
+        Emitter.prototype.emitConditionalExpression = function (expression) {
+            this.emit(expression.condition);
+            this.writeToOutput(" ? ");
+            this.emit(expression.whenTrue);
+            this.writeToOutput(" : ");
+            this.emit(expression.whenFalse);
+        };
+
+        Emitter.prototype.emitThrowStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("throw ");
+            this.emit(statement.expression);
+            this.recordSourceMappingEnd(statement);
+            this.writeToOutput(";");
+        };
+
+        Emitter.prototype.emitExpressionStatement = function (statement) {
+            var isArrowExpression = statement.expression.kind() === 219 /* SimpleArrowFunctionExpression */ || statement.expression.kind() === 218 /* ParenthesizedArrowFunctionExpression */;
+
+            this.recordSourceMappingStart(statement);
+            if (isArrowExpression) {
+                this.writeToOutput("(");
+            }
+
+            this.emit(statement.expression);
+
+            if (isArrowExpression) {
+                this.writeToOutput(")");
+            }
+
+            this.recordSourceMappingEnd(statement);
+            this.writeToOutput(";");
+        };
+
+        Emitter.prototype.emitLabeledStatement = function (statement) {
+            this.writeToOutputWithSourceMapRecord(statement.identifier.text(), statement.identifier);
+            this.writeLineToOutput(":");
+            this.emitJavascript(statement.statement, true);
+        };
+
+        Emitter.prototype.emitBlock = function (block) {
+            this.recordSourceMappingStart(block);
+            this.writeLineToOutput(" {");
+            this.indenter.increaseIndent();
+            if (block.statements) {
+                this.emitList(block.statements);
+            }
+            this.emitCommentsArray(block.closeBraceLeadingComments, false);
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+            this.writeToOutput("}");
+            this.recordSourceMappingEnd(block);
+        };
+
+        Emitter.prototype.emitBreakStatement = function (jump) {
+            this.recordSourceMappingStart(jump);
+            this.writeToOutput("break");
+
+            if (jump.identifier) {
+                this.writeToOutput(" " + jump.identifier.text());
+            }
+
+            this.recordSourceMappingEnd(jump);
+            this.writeToOutput(";");
+        };
+
+        Emitter.prototype.emitContinueStatement = function (jump) {
+            this.recordSourceMappingStart(jump);
+            this.writeToOutput("continue");
+
+            if (jump.identifier) {
+                this.writeToOutput(" " + jump.identifier.text());
+            }
+
+            this.recordSourceMappingEnd(jump);
+            this.writeToOutput(";");
+        };
+
+        Emitter.prototype.emitWhileStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("while (");
+            this.emit(statement.condition);
+            this.writeToOutput(")");
+            this.emitBlockOrStatement(statement.statement);
+            this.recordSourceMappingEnd(statement);
+        };
+
+        Emitter.prototype.emitDoStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("do");
+            this.emitBlockOrStatement(statement.statement);
+            this.writeToOutputWithSourceMapRecord(" while", statement.whileKeyword);
+            this.writeToOutput('(');
+            this.emit(statement.condition);
+            this.writeToOutput(")");
+            this.recordSourceMappingEnd(statement);
+            this.writeToOutput(";");
+        };
+
+        Emitter.prototype.emitIfStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("if (");
+            this.emit(statement.condition);
+            this.writeToOutput(")");
+
+            this.emitBlockOrStatement(statement.statement);
+
+            if (statement.elseClause) {
+                if (statement.statement.kind() !== 146 /* Block */) {
+                    this.writeLineToOutput("");
+                    this.emitIndent();
+                } else {
+                    this.writeToOutput(" ");
+                }
+
+                this.emit(statement.elseClause);
+            }
+            this.recordSourceMappingEnd(statement);
+        };
+
+        Emitter.prototype.emitElseClause = function (elseClause) {
+            if (elseClause.statement.kind() === 147 /* IfStatement */) {
+                this.writeToOutput("else ");
+                this.emit(elseClause.statement);
+            } else {
+                this.writeToOutput("else");
+                this.emitBlockOrStatement(elseClause.statement);
+            }
+        };
+
+        Emitter.prototype.emitReturnStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            if (statement.expression) {
+                this.writeToOutput("return ");
+                this.emit(statement.expression);
+            } else {
+                this.writeToOutput("return");
+            }
+            this.recordSourceMappingEnd(statement);
+            this.writeToOutput(";");
+        };
+
+        Emitter.prototype.emitForInStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("for (");
+            if (statement.left) {
+                this.emit(statement.left);
+            } else {
+                this.emit(statement.variableDeclaration);
+            }
+            this.writeToOutput(" in ");
+            this.emit(statement.expression);
+            this.writeToOutput(")");
+            this.emitBlockOrStatement(statement.statement);
+            this.recordSourceMappingEnd(statement);
+        };
+
+        Emitter.prototype.emitForStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("for (");
+            if (statement.variableDeclaration) {
+                this.emit(statement.variableDeclaration);
+            } else if (statement.initializer) {
+                this.emit(statement.initializer);
+            }
+
+            this.writeToOutput("; ");
+            this.emitJavascript(statement.condition, false);
+            this.writeToOutput(";");
+            if (statement.incrementor) {
+                this.writeToOutput(" ");
+                this.emitJavascript(statement.incrementor, false);
+            }
+            this.writeToOutput(")");
+            this.emitBlockOrStatement(statement.statement);
+            this.recordSourceMappingEnd(statement);
+        };
+
+        Emitter.prototype.emitWithStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("with (");
+            if (statement.condition) {
+                this.emit(statement.condition);
+            }
+
+            this.writeToOutput(")");
+            var prevInWithBlock = this.inWithBlock;
+            this.inWithBlock = true;
+            this.emitBlockOrStatement(statement.statement);
+            this.inWithBlock = prevInWithBlock;
+            this.recordSourceMappingEnd(statement);
+        };
+
+        Emitter.prototype.emitSwitchStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("switch (");
+            this.emit(statement.expression);
+            this.recordSourceMappingStart(statement.closeParenToken);
+            this.writeToOutput(")");
+            this.recordSourceMappingEnd(statement.closeParenToken);
+            this.writeLineToOutput(" {");
+            this.indenter.increaseIndent();
+            this.emitList(statement.switchClauses, false);
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+            this.writeToOutput("}");
+            this.recordSourceMappingEnd(statement);
+        };
+
+        Emitter.prototype.emitCaseSwitchClause = function (clause) {
+            this.recordSourceMappingStart(clause);
+            this.writeToOutput("case ");
+            this.emit(clause.expression);
+            this.writeToOutput(":");
+
+            this.emitSwitchClauseBody(clause.statements);
+            this.recordSourceMappingEnd(clause);
+        };
+
+        Emitter.prototype.emitSwitchClauseBody = function (body) {
+            if (body.childCount() === 1 && body.childAt(0).kind() === 146 /* Block */) {
+                this.emit(body.childAt(0));
+                this.writeLineToOutput("");
+            } else {
+                this.writeLineToOutput("");
+                this.indenter.increaseIndent();
+                this.emit(body);
+                this.indenter.decreaseIndent();
+            }
+        };
+
+        Emitter.prototype.emitDefaultSwitchClause = function (clause) {
+            this.recordSourceMappingStart(clause);
+            this.writeToOutput("default:");
+
+            this.emitSwitchClauseBody(clause.statements);
+            this.recordSourceMappingEnd(clause);
+        };
+
+        Emitter.prototype.emitTryStatement = function (statement) {
+            this.recordSourceMappingStart(statement);
+            this.writeToOutput("try ");
+            this.emit(statement.block);
+            this.emitJavascript(statement.catchClause, false);
+
+            if (statement.finallyClause) {
+                this.emit(statement.finallyClause);
+            }
+            this.recordSourceMappingEnd(statement);
+        };
+
+        Emitter.prototype.emitCatchClause = function (clause) {
+            this.writeToOutput(" ");
+            this.recordSourceMappingStart(clause);
+            this.writeToOutput("catch (");
+            this.emit(clause.identifier);
+            this.writeToOutput(")");
+            this.emit(clause.block);
+            this.recordSourceMappingEnd(clause);
+        };
+
+        Emitter.prototype.emitFinallyClause = function (clause) {
+            this.writeToOutput(" finally");
+            this.emit(clause.block);
+        };
+
+        Emitter.prototype.emitDebuggerStatement = function (statement) {
+            this.writeToOutputWithSourceMapRecord("debugger", statement);
+            this.writeToOutput(";");
+        };
+
+        Emitter.prototype.emitNumericLiteral = function (literal) {
+            this.writeToOutputWithSourceMapRecord(literal.text(), literal);
+        };
+
+        Emitter.prototype.emitRegularExpressionLiteral = function (literal) {
+            this.writeToOutputWithSourceMapRecord(literal.text(), literal);
+        };
+
+        Emitter.prototype.emitStringLiteral = function (literal) {
+            this.writeToOutputWithSourceMapRecord(literal.text(), literal);
+        };
+
+        Emitter.prototype.emitEqualsValueClause = function (clause) {
+            this.writeToOutput(" = ");
+            this.emit(clause.value);
+        };
+
+        Emitter.prototype.emitParameter = function (parameter) {
+            this.writeToOutputWithSourceMapRecord(parameter.identifier.text(), parameter);
+        };
+
+        Emitter.prototype.emitConstructorDeclaration = function (declaration) {
+            if (declaration.block) {
+                this.emitConstructor(declaration);
+            } else {
+                this.emitComments(declaration, true, true);
+            }
+        };
+
+        Emitter.prototype.shouldEmitFunctionDeclaration = function (declaration) {
+            return declaration.preComments() !== null || (!TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */) && declaration.block !== null);
+        };
+
+        Emitter.prototype.emitFunctionDeclaration = function (declaration) {
+            if (!TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */) && declaration.block !== null) {
+                this.emitFunction(declaration);
+            } else {
+                this.emitComments(declaration, true, true);
+            }
+        };
+
+        Emitter.prototype.emitSourceUnit = function (sourceUnit) {
+            if (!this.document.isDeclareFile()) {
+                var pullDecl = this.semanticInfoChain.getDeclForAST(sourceUnit);
+                this.pushDecl(pullDecl);
+                this.emitScriptElements(sourceUnit);
+                this.popDecl(pullDecl);
+
+                this.emitCommentsArray(sourceUnit.endOfFileTokenLeadingComments, false);
+            }
+        };
+
+        Emitter.prototype.shouldEmitEnumDeclaration = function (declaration) {
+            return declaration.preComments() !== null || !TypeScript.ASTHelpers.enumIsElided(declaration);
+        };
+
+        Emitter.prototype.emitEnumDeclaration = function (declaration) {
+            if (!TypeScript.ASTHelpers.enumIsElided(declaration)) {
+                this.emitComments(declaration, true);
+                this.emitEnum(declaration);
+                this.emitComments(declaration, false);
+            } else {
+                this.emitComments(declaration, true, true);
+            }
+        };
+
+        Emitter.prototype.shouldEmitModuleDeclaration = function (declaration) {
+            return declaration.preComments() !== null || !TypeScript.ASTHelpers.moduleIsElided(declaration);
+        };
+
+        Emitter.prototype.emitModuleDeclaration = function (declaration) {
+            if (!TypeScript.ASTHelpers.moduleIsElided(declaration)) {
+                this.emitModuleDeclarationWorker(declaration);
+            } else {
+                this.emitComments(declaration, true, true);
+            }
+        };
+
+        Emitter.prototype.shouldEmitClassDeclaration = function (declaration) {
+            return declaration.preComments() !== null || !TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */);
+        };
+
+        Emitter.prototype.emitClassDeclaration = function (declaration) {
+            if (!TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */)) {
+                this.emitClass(declaration);
+            } else {
+                this.emitComments(declaration, true, true);
+            }
+        };
+
+        Emitter.prototype.shouldEmitInterfaceDeclaration = function (declaration) {
+            return declaration.preComments() !== null;
+        };
+
+        Emitter.prototype.emitInterfaceDeclaration = function (declaration) {
+            this.emitComments(declaration, true, true);
+        };
+
+        Emitter.prototype.firstVariableDeclarator = function (statement) {
+            return statement.declaration.declarators.nonSeparatorAt(0);
+        };
+
+        Emitter.prototype.isNotAmbientOrHasInitializer = function (variableStatement) {
+            return !TypeScript.hasModifier(variableStatement.modifiers, 8 /* Ambient */) || this.firstVariableDeclarator(variableStatement).equalsValueClause !== null;
+        };
+
+        Emitter.prototype.shouldEmitVariableStatement = function (statement) {
+            return statement.preComments() !== null || this.isNotAmbientOrHasInitializer(statement);
+        };
+
+        Emitter.prototype.emitVariableStatement = function (statement) {
+            if (this.isNotAmbientOrHasInitializer(statement)) {
+                this.emitComments(statement, true);
+                this.emit(statement.declaration);
+                this.writeToOutput(";");
+                this.emitComments(statement, false);
+            } else {
+                this.emitComments(statement, true, true);
+            }
+        };
+
+        Emitter.prototype.emitGenericType = function (type) {
+            this.emit(type.name);
+        };
+
+        Emitter.prototype.shouldEmit = function (ast) {
+            if (!ast) {
+                return false;
+            }
+
+            switch (ast.kind()) {
+                case 133 /* ImportDeclaration */:
+                    return this.shouldEmitImportDeclaration(ast);
+                case 131 /* ClassDeclaration */:
+                    return this.shouldEmitClassDeclaration(ast);
+                case 128 /* InterfaceDeclaration */:
+                    return this.shouldEmitInterfaceDeclaration(ast);
+                case 129 /* FunctionDeclaration */:
+                    return this.shouldEmitFunctionDeclaration(ast);
+                case 130 /* ModuleDeclaration */:
+                    return this.shouldEmitModuleDeclaration(ast);
+                case 148 /* VariableStatement */:
+                    return this.shouldEmitVariableStatement(ast);
+                case 223 /* OmittedExpression */:
+                    return false;
+                case 132 /* EnumDeclaration */:
+                    return this.shouldEmitEnumDeclaration(ast);
+            }
+
+            return true;
+        };
+
+        Emitter.prototype.emit = function (ast) {
+            if (!ast) {
+                return;
+            }
+
+            switch (ast.kind()) {
+                case 2 /* SeparatedList */:
+                    return this.emitSeparatedList(ast);
+                case 1 /* List */:
+                    return this.emitList(ast);
+                case 120 /* SourceUnit */:
+                    return this.emitSourceUnit(ast);
+                case 133 /* ImportDeclaration */:
+                    return this.emitImportDeclaration(ast);
+                case 134 /* ExportAssignment */:
+                    return this.setExportAssignment(ast);
+                case 131 /* ClassDeclaration */:
+                    return this.emitClassDeclaration(ast);
+                case 128 /* InterfaceDeclaration */:
+                    return this.emitInterfaceDeclaration(ast);
+                case 11 /* IdentifierName */:
+                    return this.emitName(ast, true);
+                case 225 /* VariableDeclarator */:
+                    return this.emitVariableDeclarator(ast);
+                case 219 /* SimpleArrowFunctionExpression */:
+                    return this.emitSimpleArrowFunctionExpression(ast);
+                case 218 /* ParenthesizedArrowFunctionExpression */:
+                    return this.emitParenthesizedArrowFunctionExpression(ast);
+                case 129 /* FunctionDeclaration */:
+                    return this.emitFunctionDeclaration(ast);
+                case 130 /* ModuleDeclaration */:
+                    return this.emitModuleDeclaration(ast);
+                case 224 /* VariableDeclaration */:
+                    return this.emitVariableDeclaration(ast);
+                case 126 /* GenericType */:
+                    return this.emitGenericType(ast);
+                case 137 /* ConstructorDeclaration */:
+                    return this.emitConstructorDeclaration(ast);
+                case 132 /* EnumDeclaration */:
+                    return this.emitEnumDeclaration(ast);
+                case 243 /* EnumElement */:
+                    return this.emitEnumElement(ast);
+                case 222 /* FunctionExpression */:
+                    return this.emitFunctionExpression(ast);
+                case 148 /* VariableStatement */:
+                    return this.emitVariableStatement(ast);
+            }
+
+            this.emitComments(ast, true);
+            this.emitWorker(ast);
+            this.emitComments(ast, false);
+        };
+
+        Emitter.prototype.emitWorker = function (ast) {
+            if (!ast) {
+                return;
+            }
+
+            switch (ast.kind()) {
+                case 13 /* NumericLiteral */:
+                    return this.emitNumericLiteral(ast);
+                case 12 /* RegularExpressionLiteral */:
+                    return this.emitRegularExpressionLiteral(ast);
+                case 14 /* StringLiteral */:
+                    return this.emitStringLiteral(ast);
+                case 24 /* FalseKeyword */:
+                case 32 /* NullKeyword */:
+                case 37 /* TrueKeyword */:
+                    return this.emitLiteralExpression(ast);
+                case 35 /* ThisKeyword */:
+                    return this.emitThisExpression(ast);
+                case 50 /* SuperKeyword */:
+                    return this.emitSuperExpression(ast);
+                case 217 /* ParenthesizedExpression */:
+                    return this.emitParenthesizedExpression(ast);
+                case 214 /* ArrayLiteralExpression */:
+                    return this.emitArrayLiteralExpression(ast);
+                case 211 /* PostDecrementExpression */:
+                case 210 /* PostIncrementExpression */:
+                    return this.emitPostfixUnaryExpression(ast);
+                case 167 /* LogicalNotExpression */:
+                case 166 /* BitwiseNotExpression */:
+                case 165 /* NegateExpression */:
+                case 164 /* PlusExpression */:
+                case 168 /* PreIncrementExpression */:
+                case 169 /* PreDecrementExpression */:
+                    return this.emitPrefixUnaryExpression(ast);
+                case 213 /* InvocationExpression */:
+                    return this.emitInvocationExpression(ast);
+                case 221 /* ElementAccessExpression */:
+                    return this.emitElementAccessExpression(ast);
+                case 212 /* MemberAccessExpression */:
+                    return this.emitMemberAccessExpression(ast);
+                case 121 /* QualifiedName */:
+                    return this.emitQualifiedName(ast);
+                case 173 /* CommaExpression */:
+                case 174 /* AssignmentExpression */:
+                case 175 /* AddAssignmentExpression */:
+                case 176 /* SubtractAssignmentExpression */:
+                case 177 /* MultiplyAssignmentExpression */:
+                case 178 /* DivideAssignmentExpression */:
+                case 179 /* ModuloAssignmentExpression */:
+                case 180 /* AndAssignmentExpression */:
+                case 181 /* ExclusiveOrAssignmentExpression */:
+                case 182 /* OrAssignmentExpression */:
+                case 183 /* LeftShiftAssignmentExpression */:
+                case 184 /* SignedRightShiftAssignmentExpression */:
+                case 185 /* UnsignedRightShiftAssignmentExpression */:
+                case 187 /* LogicalOrExpression */:
+                case 188 /* LogicalAndExpression */:
+                case 189 /* BitwiseOrExpression */:
+                case 190 /* BitwiseExclusiveOrExpression */:
+                case 191 /* BitwiseAndExpression */:
+                case 192 /* EqualsWithTypeConversionExpression */:
+                case 193 /* NotEqualsWithTypeConversionExpression */:
+                case 194 /* EqualsExpression */:
+                case 195 /* NotEqualsExpression */:
+                case 196 /* LessThanExpression */:
+                case 197 /* GreaterThanExpression */:
+                case 198 /* LessThanOrEqualExpression */:
+                case 199 /* GreaterThanOrEqualExpression */:
+                case 200 /* InstanceOfExpression */:
+                case 201 /* InExpression */:
+                case 202 /* LeftShiftExpression */:
+                case 203 /* SignedRightShiftExpression */:
+                case 204 /* UnsignedRightShiftExpression */:
+                case 205 /* MultiplyExpression */:
+                case 206 /* DivideExpression */:
+                case 207 /* ModuloExpression */:
+                case 208 /* AddExpression */:
+                case 209 /* SubtractExpression */:
+                    return this.emitBinaryExpression(ast);
+                case 186 /* ConditionalExpression */:
+                    return this.emitConditionalExpression(ast);
+                case 232 /* EqualsValueClause */:
+                    return this.emitEqualsValueClause(ast);
+                case 242 /* Parameter */:
+                    return this.emitParameter(ast);
+                case 146 /* Block */:
+                    return this.emitBlock(ast);
+                case 235 /* ElseClause */:
+                    return this.emitElseClause(ast);
+                case 147 /* IfStatement */:
+                    return this.emitIfStatement(ast);
+                case 149 /* ExpressionStatement */:
+                    return this.emitExpressionStatement(ast);
+                case 139 /* GetAccessor */:
+                    return this.emitGetAccessor(ast);
+                case 140 /* SetAccessor */:
+                    return this.emitSetAccessor(ast);
+                case 157 /* ThrowStatement */:
+                    return this.emitThrowStatement(ast);
+                case 150 /* ReturnStatement */:
+                    return this.emitReturnStatement(ast);
+                case 216 /* ObjectCreationExpression */:
+                    return this.emitObjectCreationExpression(ast);
+                case 151 /* SwitchStatement */:
+                    return this.emitSwitchStatement(ast);
+                case 233 /* CaseSwitchClause */:
+                    return this.emitCaseSwitchClause(ast);
+                case 234 /* DefaultSwitchClause */:
+                    return this.emitDefaultSwitchClause(ast);
+                case 152 /* BreakStatement */:
+                    return this.emitBreakStatement(ast);
+                case 153 /* ContinueStatement */:
+                    return this.emitContinueStatement(ast);
+                case 154 /* ForStatement */:
+                    return this.emitForStatement(ast);
+                case 155 /* ForInStatement */:
+                    return this.emitForInStatement(ast);
+                case 158 /* WhileStatement */:
+                    return this.emitWhileStatement(ast);
+                case 163 /* WithStatement */:
+                    return this.emitWithStatement(ast);
+                case 220 /* CastExpression */:
+                    return this.emitCastExpression(ast);
+                case 215 /* ObjectLiteralExpression */:
+                    return this.emitObjectLiteralExpression(ast);
+                case 240 /* SimplePropertyAssignment */:
+                    return this.emitSimplePropertyAssignment(ast);
+                case 241 /* FunctionPropertyAssignment */:
+                    return this.emitFunctionPropertyAssignment(ast);
+                case 156 /* EmptyStatement */:
+                    return this.writeToOutputWithSourceMapRecord(";", ast);
+                case 159 /* TryStatement */:
+                    return this.emitTryStatement(ast);
+                case 236 /* CatchClause */:
+                    return this.emitCatchClause(ast);
+                case 237 /* FinallyClause */:
+                    return this.emitFinallyClause(ast);
+                case 160 /* LabeledStatement */:
+                    return this.emitLabeledStatement(ast);
+                case 161 /* DoStatement */:
+                    return this.emitDoStatement(ast);
+                case 171 /* TypeOfExpression */:
+                    return this.emitTypeOfExpression(ast);
+                case 170 /* DeleteExpression */:
+                    return this.emitDeleteExpression(ast);
+                case 172 /* VoidExpression */:
+                    return this.emitVoidExpression(ast);
+                case 162 /* DebuggerStatement */:
+                    return this.emitDebuggerStatement(ast);
+            }
+        };
+        return Emitter;
+    })();
+    TypeScript.Emitter = Emitter;
+
+    function getLastConstructor(classDecl) {
+        return classDecl.classElements.lastOrDefault(function (e) {
+            return e.kind() === 137 /* ConstructorDeclaration */;
+        });
+    }
+    TypeScript.getLastConstructor = getLastConstructor;
+
+    function getTrimmedTextLines(comment) {
+        if (comment.kind() === 6 /* MultiLineCommentTrivia */) {
+            return comment.fullText().split("\n").map(function (s) {
+                return s.trim();
+            });
+        } else {
+            return [comment.fullText().trim()];
+        }
+    }
+    TypeScript.getTrimmedTextLines = getTrimmedTextLines;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var MemberName = (function () {
+        function MemberName() {
+            this.prefix = "";
+            this.suffix = "";
+        }
+        MemberName.prototype.isString = function () {
+            return false;
+        };
+        MemberName.prototype.isArray = function () {
+            return false;
+        };
+        MemberName.prototype.isMarker = function () {
+            return !this.isString() && !this.isArray();
+        };
+
+        MemberName.prototype.toString = function () {
+            return MemberName.memberNameToString(this);
+        };
+
+        MemberName.memberNameToString = function (memberName, markerInfo, markerBaseLength) {
+            if (typeof markerBaseLength === "undefined") { markerBaseLength = 0; }
+            var result = memberName.prefix;
+
+            if (memberName.isString()) {
+                result += memberName.text;
+            } else if (memberName.isArray()) {
+                var ar = memberName;
+                for (var index = 0; index < ar.entries.length; index++) {
+                    if (ar.entries[index].isMarker()) {
+                        if (markerInfo) {
+                            markerInfo.push(markerBaseLength + result.length);
+                        }
+                        continue;
+                    }
+
+                    result += MemberName.memberNameToString(ar.entries[index], markerInfo, markerBaseLength + result.length);
+                    result += ar.delim;
+                }
+            }
+
+            result += memberName.suffix;
+            return result;
+        };
+
+        MemberName.create = function (arg1, arg2, arg3) {
+            if (typeof arg1 === "string") {
+                return new MemberNameString(arg1);
+            } else {
+                var result = new MemberNameArray();
+                if (arg2)
+                    result.prefix = arg2;
+                if (arg3)
+                    result.suffix = arg3;
+                result.entries.push(arg1);
+                return result;
+            }
+        };
+        return MemberName;
+    })();
+    TypeScript.MemberName = MemberName;
+
+    var MemberNameString = (function (_super) {
+        __extends(MemberNameString, _super);
+        function MemberNameString(text) {
+            _super.call(this);
+            this.text = text;
+        }
+        MemberNameString.prototype.isString = function () {
+            return true;
+        };
+        return MemberNameString;
+    })(MemberName);
+    TypeScript.MemberNameString = MemberNameString;
+
+    var MemberNameArray = (function (_super) {
+        __extends(MemberNameArray, _super);
+        function MemberNameArray() {
+            _super.call(this);
+            this.delim = "";
+            this.entries = [];
+        }
+        MemberNameArray.prototype.isArray = function () {
+            return true;
+        };
+
+        MemberNameArray.prototype.add = function (entry) {
+            this.entries.push(entry);
+        };
+
+        MemberNameArray.prototype.addAll = function (entries) {
+            for (var i = 0; i < entries.length; i++) {
+                this.entries.push(entries[i]);
+            }
+        };
+        return MemberNameArray;
+    })(MemberName);
+    TypeScript.MemberNameArray = MemberNameArray;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    function stripStartAndEndQuotes(str) {
+        var firstCharCode = str && str.charCodeAt(0);
+        if (str && str.length >= 2 && firstCharCode === str.charCodeAt(str.length - 1) && (firstCharCode === 39 /* singleQuote */ || firstCharCode === 34 /* doubleQuote */)) {
+            return str.substring(1, str.length - 1);
+        }
+
+        return str;
+    }
+    TypeScript.stripStartAndEndQuotes = stripStartAndEndQuotes;
+
+    function isSingleQuoted(str) {
+        return str && str.length >= 2 && str.charCodeAt(0) === str.charCodeAt(str.length - 1) && str.charCodeAt(0) === 39 /* singleQuote */;
+    }
+    TypeScript.isSingleQuoted = isSingleQuoted;
+
+    function isDoubleQuoted(str) {
+        return str && str.length >= 2 && str.charCodeAt(0) === str.charCodeAt(str.length - 1) && str.charCodeAt(0) === 34 /* doubleQuote */;
+    }
+    TypeScript.isDoubleQuoted = isDoubleQuoted;
+
+    function isQuoted(str) {
+        return isDoubleQuoted(str) || isSingleQuoted(str);
+    }
+    TypeScript.isQuoted = isQuoted;
+
+    function quoteStr(str) {
+        return "\"" + str + "\"";
+    }
+    TypeScript.quoteStr = quoteStr;
+
+    var switchToForwardSlashesRegEx = /\\/g;
+    function switchToForwardSlashes(path) {
+        return path.replace(switchToForwardSlashesRegEx, "/");
+    }
+    TypeScript.switchToForwardSlashes = switchToForwardSlashes;
+
+    function trimModName(modName) {
+        if (modName.length > 5 && modName.substring(modName.length - 5, modName.length) === ".d.ts") {
+            return modName.substring(0, modName.length - 5);
+        }
+        if (modName.length > 3 && modName.substring(modName.length - 3, modName.length) === ".ts") {
+            return modName.substring(0, modName.length - 3);
+        }
+
+        if (modName.length > 3 && modName.substring(modName.length - 3, modName.length) === ".js") {
+            return modName.substring(0, modName.length - 3);
+        }
+
+        return modName;
+    }
+    TypeScript.trimModName = trimModName;
+
+    function getDeclareFilePath(fname) {
+        return isTSFile(fname) ? changePathToDTS(fname) : changePathToDTS(fname);
+    }
+    TypeScript.getDeclareFilePath = getDeclareFilePath;
+
+    function isFileOfExtension(fname, ext) {
+        var invariantFname = fname.toLocaleUpperCase();
+        var invariantExt = ext.toLocaleUpperCase();
+        var extLength = invariantExt.length;
+        return invariantFname.length > extLength && invariantFname.substring(invariantFname.length - extLength, invariantFname.length) === invariantExt;
+    }
+
+    function isTSFile(fname) {
+        return isFileOfExtension(fname, ".ts");
+    }
+    TypeScript.isTSFile = isTSFile;
+
+    function isDTSFile(fname) {
+        return isFileOfExtension(fname, ".d.ts");
+    }
+    TypeScript.isDTSFile = isDTSFile;
+
+    function getPrettyName(modPath, quote, treatAsFileName) {
+        if (typeof quote === "undefined") { quote = true; }
+        if (typeof treatAsFileName === "undefined") { treatAsFileName = false; }
+        var modName = treatAsFileName ? switchToForwardSlashes(modPath) : trimModName(stripStartAndEndQuotes(modPath));
+        var components = this.getPathComponents(modName);
+        return components.length ? (quote ? quoteStr(components[components.length - 1]) : components[components.length - 1]) : modPath;
+    }
+    TypeScript.getPrettyName = getPrettyName;
+
+    function getPathComponents(path) {
+        return path.split("/");
+    }
+    TypeScript.getPathComponents = getPathComponents;
+
+    function getRelativePathToFixedPath(fixedModFilePath, absoluteModPath, isAbsoultePathURL) {
+        if (typeof isAbsoultePathURL === "undefined") { isAbsoultePathURL = true; }
+        absoluteModPath = switchToForwardSlashes(absoluteModPath);
+
+        var modComponents = this.getPathComponents(absoluteModPath);
+        var fixedModComponents = this.getPathComponents(fixedModFilePath);
+
+        var joinStartIndex = 0;
+        for (; joinStartIndex < modComponents.length && joinStartIndex < fixedModComponents.length; joinStartIndex++) {
+            if (fixedModComponents[joinStartIndex] !== modComponents[joinStartIndex]) {
+                break;
+            }
+        }
+
+        if (joinStartIndex !== 0) {
+            var relativePath = "";
+            var relativePathComponents = modComponents.slice(joinStartIndex, modComponents.length);
+            for (; joinStartIndex < fixedModComponents.length; joinStartIndex++) {
+                if (fixedModComponents[joinStartIndex] !== "") {
+                    relativePath = relativePath + "../";
+                }
+            }
+
+            return relativePath + relativePathComponents.join("/");
+        }
+
+        if (isAbsoultePathURL && absoluteModPath.indexOf("://") === -1) {
+            absoluteModPath = "file:///" + absoluteModPath;
+        }
+
+        return absoluteModPath;
+    }
+    TypeScript.getRelativePathToFixedPath = getRelativePathToFixedPath;
+
+    function changePathToDTS(modPath) {
+        return trimModName(stripStartAndEndQuotes(modPath)) + ".d.ts";
+    }
+    TypeScript.changePathToDTS = changePathToDTS;
+
+    function isRelative(path) {
+        return path.length > 0 && path.charAt(0) === ".";
+    }
+    TypeScript.isRelative = isRelative;
+    function isRooted(path) {
+        return path.length > 0 && (path.charAt(0) === "\\" || path.charAt(0) === "/" || (path.indexOf(":\\") !== -1) || (path.indexOf(":/") !== -1));
+    }
+    TypeScript.isRooted = isRooted;
+
+    function getRootFilePath(outFname) {
+        if (outFname === "") {
+            return outFname;
+        } else {
+            var isPath = outFname.indexOf("/") !== -1;
+            return isPath ? filePath(outFname) : "";
+        }
+    }
+    TypeScript.getRootFilePath = getRootFilePath;
+
+    function filePathComponents(fullPath) {
+        fullPath = switchToForwardSlashes(fullPath);
+        var components = getPathComponents(fullPath);
+        return components.slice(0, components.length - 1);
+    }
+    TypeScript.filePathComponents = filePathComponents;
+
+    function filePath(fullPath) {
+        var path = filePathComponents(fullPath);
+        return path.join("/") + "/";
+    }
+    TypeScript.filePath = filePath;
+
+    function convertToDirectoryPath(dirPath) {
+        if (dirPath && dirPath.charAt(dirPath.length - 1) !== "/") {
+            dirPath += "/";
+        }
+
+        return dirPath;
+    }
+    TypeScript.convertToDirectoryPath = convertToDirectoryPath;
+
+    var normalizePathRegEx = /^\\\\[^\\]/;
+    function normalizePath(path) {
+        if (normalizePathRegEx.test(path)) {
+            path = "file:" + path;
+        }
+        var parts = this.getPathComponents(switchToForwardSlashes(path));
+        var normalizedParts = [];
+
+        for (var i = 0; i < parts.length; i++) {
+            var part = parts[i];
+            if (part === ".") {
+                continue;
+            }
+
+            if (normalizedParts.length > 0 && TypeScript.ArrayUtilities.last(normalizedParts) !== ".." && part === "..") {
+                normalizedParts.pop();
+                continue;
+            }
+
+            normalizedParts.push(part);
+        }
+
+        return normalizedParts.join("/");
+    }
+    TypeScript.normalizePath = normalizePath;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    
+
+    function isNoDefaultLibMatch(comment) {
+        var isNoDefaultLibRegex = /^(\/\/\/\s*<reference\s+no-default-lib=)('|")(.+?)\2\s*\/>/gim;
+        return isNoDefaultLibRegex.exec(comment);
+    }
+
+    TypeScript.tripleSlashReferenceRegExp = /^(\/\/\/\s*<reference\s+path=)('|")(.+?)\2\s*(static=('|")(.+?)\2\s*)*\/>/;
+
+    function getFileReferenceFromReferencePath(fileName, lineMap, position, comment, diagnostics) {
+        var simpleReferenceRegEx = /^\/\/\/\s*<reference\s+/gim;
+        if (simpleReferenceRegEx.exec(comment)) {
+            var isNoDefaultLib = isNoDefaultLibMatch(comment);
+
+            if (!isNoDefaultLib) {
+                var fullReferenceRegEx = TypeScript.tripleSlashReferenceRegExp;
+                var fullReference = fullReferenceRegEx.exec(comment);
+
+                if (!fullReference) {
+                    diagnostics.push(new TypeScript.Diagnostic(fileName, lineMap, position, comment.length, TypeScript.DiagnosticCode.Invalid_reference_directive_syntax));
+                } else {
+                    var path = TypeScript.normalizePath(fullReference[3]);
+                    var adjustedPath = TypeScript.normalizePath(path);
+
+                    var isResident = fullReference.length >= 7 && fullReference[6] === "true";
+                    if (isResident) {
+                        TypeScript.CompilerDiagnostics.debugPrint(path + " is resident");
+                    }
+                    return {
+                        line: 0,
+                        character: 0,
+                        position: 0,
+                        length: 0,
+                        path: TypeScript.switchToForwardSlashes(adjustedPath),
+                        isResident: isResident
+                    };
+                }
+            }
+        }
+
+        return null;
+    }
+
+    var scannerWindow = TypeScript.ArrayUtilities.createArray(2048, 0);
+    var scannerDiagnostics = [];
+
+    function processImports(lineMap, scanner, token, importedFiles) {
+        var position = 0;
+        var lineChar = { line: -1, character: -1 };
+
+        var start = new Date().getTime();
+
+        while (token.tokenKind !== 10 /* EndOfFileToken */) {
+            if (token.tokenKind === 49 /* ImportKeyword */) {
+                var importStart = position + token.leadingTriviaWidth();
+                token = scanner.scan(scannerDiagnostics, false);
+
+                if (TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token)) {
+                    token = scanner.scan(scannerDiagnostics, false);
+
+                    if (token.tokenKind === 107 /* EqualsToken */) {
+                        token = scanner.scan(scannerDiagnostics, false);
+
+                        if (token.tokenKind === 65 /* ModuleKeyword */ || token.tokenKind === 66 /* RequireKeyword */) {
+                            token = scanner.scan(scannerDiagnostics, false);
+
+                            if (token.tokenKind === 72 /* OpenParenToken */) {
+                                var afterOpenParenPosition = scanner.absoluteIndex();
+                                token = scanner.scan(scannerDiagnostics, false);
+
+                                lineMap.fillLineAndCharacterFromPosition(importStart, lineChar);
+
+                                if (token.tokenKind === 14 /* StringLiteral */) {
+                                    var ref = {
+                                        line: lineChar.line,
+                                        character: lineChar.character,
+                                        position: afterOpenParenPosition + token.leadingTriviaWidth(),
+                                        length: token.width(),
+                                        path: TypeScript.stripStartAndEndQuotes(TypeScript.switchToForwardSlashes(token.text())),
+                                        isResident: false
+                                    };
+                                    importedFiles.push(ref);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            position = scanner.absoluteIndex();
+            token = scanner.scan(scannerDiagnostics, false);
+        }
+
+        var totalTime = new Date().getTime() - start;
+        TypeScript.fileResolutionScanImportsTime += totalTime;
+    }
+
+    function processTripleSlashDirectives(fileName, lineMap, firstToken) {
+        var leadingTrivia = firstToken.leadingTrivia();
+
+        var position = 0;
+        var lineChar = { line: -1, character: -1 };
+        var noDefaultLib = false;
+        var diagnostics = [];
+        var referencedFiles = [];
+
+        for (var i = 0, n = leadingTrivia.count(); i < n; i++) {
+            var trivia = leadingTrivia.syntaxTriviaAt(i);
+
+            if (trivia.kind() === 7 /* SingleLineCommentTrivia */) {
+                var triviaText = trivia.fullText();
+                var referencedCode = getFileReferenceFromReferencePath(fileName, lineMap, position, triviaText, diagnostics);
+
+                if (referencedCode) {
+                    lineMap.fillLineAndCharacterFromPosition(position, lineChar);
+                    referencedCode.position = position;
+                    referencedCode.length = trivia.fullWidth();
+                    referencedCode.line = lineChar.line;
+                    referencedCode.character = lineChar.character;
+
+                    referencedFiles.push(referencedCode);
+                }
+
+                var isNoDefaultLib = isNoDefaultLibMatch(triviaText);
+                if (isNoDefaultLib) {
+                    noDefaultLib = isNoDefaultLib[3] === "true";
+                }
+            }
+
+            position += trivia.fullWidth();
+        }
+
+        return { noDefaultLib: noDefaultLib, diagnostics: diagnostics, referencedFiles: referencedFiles };
+    }
+
+    function preProcessFile(fileName, sourceText, readImportFiles) {
+        if (typeof readImportFiles === "undefined") { readImportFiles = true; }
+        var text = TypeScript.SimpleText.fromScriptSnapshot(sourceText);
+        var scanner = new TypeScript.Scanner(fileName, text, 1 /* EcmaScript5 */, scannerWindow);
+
+        var firstToken = scanner.scan(scannerDiagnostics, false);
+
+        var importedFiles = [];
+        if (readImportFiles) {
+            processImports(text.lineMap(), scanner, firstToken, importedFiles);
+        }
+
+        var properties = processTripleSlashDirectives(fileName, text.lineMap(), firstToken);
+
+        scannerDiagnostics.length = 0;
+        return { referencedFiles: properties.referencedFiles, importedFiles: importedFiles, isLibFile: properties.noDefaultLib, diagnostics: properties.diagnostics };
+    }
+    TypeScript.preProcessFile = preProcessFile;
+
+    function getParseOptions(settings) {
+        return new TypeScript.ParseOptions(settings.codeGenTarget(), settings.allowAutomaticSemicolonInsertion());
+    }
+    TypeScript.getParseOptions = getParseOptions;
+
+    function getReferencedFiles(fileName, sourceText) {
+        return preProcessFile(fileName, sourceText, false).referencedFiles;
+    }
+    TypeScript.getReferencedFiles = getReferencedFiles;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var ReferenceResolutionResult = (function () {
+        function ReferenceResolutionResult() {
+            this.resolvedFiles = [];
+            this.diagnostics = [];
+            this.seenNoDefaultLibTag = false;
+        }
+        return ReferenceResolutionResult;
+    })();
+    TypeScript.ReferenceResolutionResult = ReferenceResolutionResult;
+
+    var ReferenceLocation = (function () {
+        function ReferenceLocation(filePath, lineMap, position, length, isImported) {
+            this.filePath = filePath;
+            this.lineMap = lineMap;
+            this.position = position;
+            this.length = length;
+            this.isImported = isImported;
+        }
+        return ReferenceLocation;
+    })();
+
+    var ReferenceResolver = (function () {
+        function ReferenceResolver(inputFileNames, host, useCaseSensitiveFileResolution) {
+            this.useCaseSensitiveFileResolution = useCaseSensitiveFileResolution;
+            this.inputFileNames = inputFileNames;
+            this.host = host;
+            this.visited = {};
+        }
+        ReferenceResolver.resolve = function (inputFileNames, host, useCaseSensitiveFileResolution) {
+            var resolver = new ReferenceResolver(inputFileNames, host, useCaseSensitiveFileResolution);
+            return resolver.resolveInputFiles();
+        };
+
+        ReferenceResolver.prototype.resolveInputFiles = function () {
+            var _this = this;
+            var result = new ReferenceResolutionResult();
+
+            if (!this.inputFileNames || this.inputFileNames.length <= 0) {
+                return result;
+            }
+
+            var referenceLocation = new ReferenceLocation(null, null, 0, 0, false);
+            this.inputFileNames.forEach(function (fileName) {
+                return _this.resolveIncludedFile(fileName, referenceLocation, result);
+            });
+
+            return result;
+        };
+
+        ReferenceResolver.prototype.resolveIncludedFile = function (path, referenceLocation, resolutionResult) {
+            var normalizedPath = this.getNormalizedFilePath(path, referenceLocation.filePath);
+
+            if (this.isSameFile(normalizedPath, referenceLocation.filePath)) {
+                if (!referenceLocation.isImported) {
+                    resolutionResult.diagnostics.push(new TypeScript.Diagnostic(referenceLocation.filePath, referenceLocation.lineMap, referenceLocation.position, referenceLocation.length, TypeScript.DiagnosticCode.A_file_cannot_have_a_reference_to_itself, null));
+                }
+
+                return normalizedPath;
+            }
+
+            if (!TypeScript.isTSFile(normalizedPath) && !TypeScript.isDTSFile(normalizedPath)) {
+                var dtsFile = normalizedPath + ".d.ts";
+                var tsFile = normalizedPath + ".ts";
+
+                if (this.host.fileExists(tsFile)) {
+                    normalizedPath = tsFile;
+                } else {
+                    normalizedPath = dtsFile;
+                }
+            }
+
+            if (!this.host.fileExists(normalizedPath)) {
+                if (!referenceLocation.isImported) {
+                    resolutionResult.diagnostics.push(new TypeScript.Diagnostic(referenceLocation.filePath, referenceLocation.lineMap, referenceLocation.position, referenceLocation.length, TypeScript.DiagnosticCode.Cannot_resolve_referenced_file_0, [path]));
+                }
+
+                return normalizedPath;
+            }
+
+            return this.resolveFile(normalizedPath, resolutionResult);
+        };
+
+        ReferenceResolver.prototype.resolveImportedFile = function (path, referenceLocation, resolutionResult) {
+            var isRelativePath = TypeScript.isRelative(path);
+            var isRootedPath = isRelativePath ? false : TypeScript.isRooted(path);
+
+            if (isRelativePath || isRootedPath) {
+                return this.resolveIncludedFile(path, referenceLocation, resolutionResult);
+            } else {
+                var parentDirectory = this.host.getParentDirectory(referenceLocation.filePath);
+                var searchFilePath = null;
+                var dtsFileName = path + ".d.ts";
+                var tsFilePath = path + ".ts";
+
+                var start = new Date().getTime();
+
+                do {
+                    currentFilePath = this.host.resolveRelativePath(tsFilePath, parentDirectory);
+                    if (this.host.fileExists(currentFilePath)) {
+                        searchFilePath = currentFilePath;
+                        break;
+                    }
+
+                    var currentFilePath = this.host.resolveRelativePath(dtsFileName, parentDirectory);
+                    if (this.host.fileExists(currentFilePath)) {
+                        searchFilePath = currentFilePath;
+                        break;
+                    }
+
+                    parentDirectory = this.host.getParentDirectory(parentDirectory);
+                } while(parentDirectory);
+
+                TypeScript.fileResolutionImportFileSearchTime += new Date().getTime() - start;
+
+                if (!searchFilePath) {
+                    return path;
+                }
+
+                return this.resolveFile(searchFilePath, resolutionResult);
+            }
+        };
+
+        ReferenceResolver.prototype.resolveFile = function (normalizedPath, resolutionResult) {
+            var _this = this;
+            var visitedPath = this.isVisited(normalizedPath);
+            if (!visitedPath) {
+                this.recordVisitedFile(normalizedPath);
+
+                var start = new Date().getTime();
+                var scriptSnapshot = this.host.getScriptSnapshot(normalizedPath);
+                var totalTime = new Date().getTime() - start;
+                TypeScript.fileResolutionIOTime += totalTime;
+
+                var lineMap = TypeScript.LineMap1.fromScriptSnapshot(scriptSnapshot);
+                var preprocessedFileInformation = TypeScript.preProcessFile(normalizedPath, scriptSnapshot);
+                resolutionResult.diagnostics.push.apply(resolutionResult.diagnostics, preprocessedFileInformation.diagnostics);
+
+                if (preprocessedFileInformation.isLibFile) {
+                    resolutionResult.seenNoDefaultLibTag = true;
+                }
+
+                var normalizedReferencePaths = [];
+                preprocessedFileInformation.referencedFiles.forEach(function (fileReference) {
+                    var currentReferenceLocation = new ReferenceLocation(normalizedPath, lineMap, fileReference.position, fileReference.length, false);
+                    var normalizedReferencePath = _this.resolveIncludedFile(fileReference.path, currentReferenceLocation, resolutionResult);
+                    normalizedReferencePaths.push(normalizedReferencePath);
+                });
+
+                var normalizedImportPaths = [];
+                for (var i = 0; i < preprocessedFileInformation.importedFiles.length; i++) {
+                    var fileImport = preprocessedFileInformation.importedFiles[i];
+                    var currentReferenceLocation = new ReferenceLocation(normalizedPath, lineMap, fileImport.position, fileImport.length, true);
+                    var normalizedImportPath = this.resolveImportedFile(fileImport.path, currentReferenceLocation, resolutionResult);
+                    normalizedImportPaths.push(normalizedImportPath);
+                }
+
+                resolutionResult.resolvedFiles.push({
+                    path: normalizedPath,
+                    referencedFiles: normalizedReferencePaths,
+                    importedFiles: normalizedImportPaths
+                });
+            } else {
+                normalizedPath = visitedPath;
+            }
+
+            return normalizedPath;
+        };
+
+        ReferenceResolver.prototype.getNormalizedFilePath = function (path, parentFilePath) {
+            var parentFileDirectory = parentFilePath ? this.host.getParentDirectory(parentFilePath) : "";
+            var normalizedPath = this.host.resolveRelativePath(path, parentFileDirectory);
+            return normalizedPath;
+        };
+
+        ReferenceResolver.prototype.getUniqueFileId = function (filePath) {
+            return this.useCaseSensitiveFileResolution ? filePath : filePath.toLocaleUpperCase();
+        };
+
+        ReferenceResolver.prototype.recordVisitedFile = function (filePath) {
+            this.visited[this.getUniqueFileId(filePath)] = filePath;
+        };
+
+        ReferenceResolver.prototype.isVisited = function (filePath) {
+            return this.visited[this.getUniqueFileId(filePath)];
+        };
+
+        ReferenceResolver.prototype.isSameFile = function (filePath1, filePath2) {
+            if (!filePath1 || !filePath2) {
+                return false;
+            }
+
+            if (this.useCaseSensitiveFileResolution) {
+                return filePath1 === filePath2;
+            } else {
+                return filePath1.toLocaleUpperCase() === filePath2.toLocaleUpperCase();
+            }
+        };
+        return ReferenceResolver;
+    })();
+    TypeScript.ReferenceResolver = ReferenceResolver;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var TextWriter = (function () {
+        function TextWriter(name, writeByteOrderMark, outputFileType) {
+            this.name = name;
+            this.writeByteOrderMark = writeByteOrderMark;
+            this.outputFileType = outputFileType;
+            this.contents = "";
+            this.onNewLine = true;
+        }
+        TextWriter.prototype.Write = function (s) {
+            this.contents += s;
+            this.onNewLine = false;
+        };
+
+        TextWriter.prototype.WriteLine = function (s) {
+            this.contents += s;
+            this.contents += TypeScript.newLine();
+            this.onNewLine = true;
+        };
+
+        TextWriter.prototype.Close = function () {
+        };
+
+        TextWriter.prototype.getOutputFile = function () {
+            return new TypeScript.OutputFile(this.name, this.writeByteOrderMark, this.contents, this.outputFileType);
+        };
+        return TextWriter;
+    })();
+    TypeScript.TextWriter = TextWriter;
+
+    var DeclarationEmitter = (function () {
+        function DeclarationEmitter(emittingFileName, document, compiler, emitOptions, semanticInfoChain) {
+            this.emittingFileName = emittingFileName;
+            this.document = document;
+            this.compiler = compiler;
+            this.emitOptions = emitOptions;
+            this.semanticInfoChain = semanticInfoChain;
+            this.declFile = null;
+            this.indenter = new TypeScript.Indenter();
+            this.emittedReferencePaths = false;
+            this.declFile = new TextWriter(emittingFileName, this.document.byteOrderMark !== 0 /* None */, 2 /* Declaration */);
+        }
+        DeclarationEmitter.prototype.getOutputFile = function () {
+            return this.declFile.getOutputFile();
+        };
+
+        DeclarationEmitter.prototype.emitDeclarations = function (sourceUnit) {
+            this.emitDeclarationsForSourceUnit(sourceUnit);
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForList = function (list) {
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                this.emitDeclarationsForAST(list.childAt(i));
+            }
+        };
+
+        DeclarationEmitter.prototype.emitSeparatedList = function (list) {
+            for (var i = 0, n = list.nonSeparatorCount(); i < n; i++) {
+                this.emitDeclarationsForAST(list.nonSeparatorAt(i));
+            }
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForAST = function (ast) {
+            switch (ast.kind()) {
+                case 148 /* VariableStatement */:
+                    return this.emitDeclarationsForVariableStatement(ast);
+                case 141 /* PropertySignature */:
+                    return this.emitPropertySignature(ast);
+                case 225 /* VariableDeclarator */:
+                    return this.emitVariableDeclarator(ast, true, true);
+                case 136 /* MemberVariableDeclaration */:
+                    return this.emitDeclarationsForMemberVariableDeclaration(ast);
+                case 137 /* ConstructorDeclaration */:
+                    return this.emitDeclarationsForConstructorDeclaration(ast);
+                case 139 /* GetAccessor */:
+                    return this.emitDeclarationsForGetAccessor(ast);
+                case 140 /* SetAccessor */:
+                    return this.emitDeclarationsForSetAccessor(ast);
+                case 138 /* IndexMemberDeclaration */:
+                    return this.emitIndexMemberDeclaration(ast);
+                case 144 /* IndexSignature */:
+                    return this.emitIndexSignature(ast);
+                case 142 /* CallSignature */:
+                    return this.emitCallSignature(ast);
+                case 143 /* ConstructSignature */:
+                    return this.emitConstructSignature(ast);
+                case 145 /* MethodSignature */:
+                    return this.emitMethodSignature(ast);
+                case 129 /* FunctionDeclaration */:
+                    return this.emitDeclarationsForFunctionDeclaration(ast);
+                case 135 /* MemberFunctionDeclaration */:
+                    return this.emitMemberFunctionDeclaration(ast);
+                case 131 /* ClassDeclaration */:
+                    return this.emitDeclarationsForClassDeclaration(ast);
+                case 128 /* InterfaceDeclaration */:
+                    return this.emitDeclarationsForInterfaceDeclaration(ast);
+                case 133 /* ImportDeclaration */:
+                    return this.emitDeclarationsForImportDeclaration(ast);
+                case 130 /* ModuleDeclaration */:
+                    return this.emitDeclarationsForModuleDeclaration(ast);
+                case 132 /* EnumDeclaration */:
+                    return this.emitDeclarationsForEnumDeclaration(ast);
+                case 134 /* ExportAssignment */:
+                    return this.emitDeclarationsForExportAssignment(ast);
+            }
+        };
+
+        DeclarationEmitter.prototype.getIndentString = function (declIndent) {
+            if (typeof declIndent === "undefined") { declIndent = false; }
+            return this.indenter.getIndent();
+        };
+
+        DeclarationEmitter.prototype.emitIndent = function () {
+            this.declFile.Write(this.getIndentString());
+        };
+
+        DeclarationEmitter.prototype.canEmitDeclarations = function (declAST) {
+            var container = DeclarationEmitter.getEnclosingContainer(declAST);
+            if (container.kind() === 130 /* ModuleDeclaration */ || container.kind() === 120 /* SourceUnit */) {
+                var pullDecl = this.semanticInfoChain.getDeclForAST(declAST);
+                if (!TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */)) {
+                    var start = new Date().getTime();
+                    var declSymbol = this.semanticInfoChain.getSymbolForAST(declAST);
+                    var result = declSymbol && declSymbol.isExternallyVisible();
+                    TypeScript.declarationEmitIsExternallyVisibleTime += new Date().getTime() - start;
+
+                    return result;
+                }
+            }
+
+            return true;
+        };
+
+        DeclarationEmitter.prototype.getDeclFlagsString = function (pullDecl, typeString) {
+            var result = this.getIndentString();
+            var pullFlags = pullDecl.flags;
+
+            if (TypeScript.hasFlag(pullFlags, 16 /* Static */)) {
+                if (TypeScript.hasFlag(pullFlags, 2 /* Private */)) {
+                    result += "private ";
+                }
+                result += "static ";
+            } else {
+                if (TypeScript.hasFlag(pullFlags, 2 /* Private */)) {
+                    result += "private ";
+                } else if (TypeScript.hasFlag(pullFlags, 4 /* Public */)) {
+                    result += "public ";
+                } else {
+                    var emitDeclare = !TypeScript.hasFlag(pullFlags, 1 /* Exported */);
+
+                    var declAST = this.semanticInfoChain.getASTForDecl(pullDecl);
+                    var container = DeclarationEmitter.getEnclosingContainer(declAST);
+
+                    var isExternalModule = container.kind() === 120 /* SourceUnit */ && this.document.isExternalModule();
+
+                    if (isExternalModule && TypeScript.hasFlag(pullFlags, 1 /* Exported */)) {
+                        result += "export ";
+                        emitDeclare = true;
+                    }
+
+                    if (isExternalModule || container.kind() === 120 /* SourceUnit */) {
+                        if (emitDeclare && typeString !== "interface" && typeString !== "import") {
+                            result += "declare ";
+                        }
+                    }
+
+                    result += typeString + " ";
+                }
+            }
+
+            return result;
+        };
+
+        DeclarationEmitter.prototype.emitDeclFlags = function (declarationAST, typeString) {
+            this.declFile.Write(this.getDeclFlagsString(this.semanticInfoChain.getDeclForAST(declarationAST), typeString));
+        };
+
+        DeclarationEmitter.prototype.emitTypeNamesMember = function (memberName, emitIndent) {
+            if (typeof emitIndent === "undefined") { emitIndent = false; }
+            if (memberName.prefix === "{ ") {
+                if (emitIndent) {
+                    this.emitIndent();
+                }
+
+                this.declFile.WriteLine("{");
+                this.indenter.increaseIndent();
+                emitIndent = true;
+            } else if (memberName.prefix !== "") {
+                if (emitIndent) {
+                    this.emitIndent();
+                }
+
+                this.declFile.Write(memberName.prefix);
+                emitIndent = false;
+            }
+
+            if (memberName.isString()) {
+                if (emitIndent) {
+                    this.emitIndent();
+                }
+
+                this.declFile.Write(memberName.text);
+            } else if (memberName.isArray()) {
+                var ar = memberName;
+                for (var index = 0; index < ar.entries.length; index++) {
+                    this.emitTypeNamesMember(ar.entries[index], emitIndent);
+                    if (ar.delim === "; ") {
+                        this.declFile.WriteLine(";");
+                    }
+                }
+            }
+
+            if (memberName.suffix === "}") {
+                this.indenter.decreaseIndent();
+                this.emitIndent();
+                this.declFile.Write(memberName.suffix);
+            } else {
+                this.declFile.Write(memberName.suffix);
+            }
+        };
+
+        DeclarationEmitter.prototype.emitTypeSignature = function (ast, type) {
+            var declarationContainerAst = DeclarationEmitter.getEnclosingContainer(ast);
+
+            var start = new Date().getTime();
+            var declarationContainerDecl = this.semanticInfoChain.getDeclForAST(declarationContainerAst);
+
+            var declarationPullSymbol = declarationContainerDecl.getSymbol();
+            TypeScript.declarationEmitTypeSignatureTime += new Date().getTime() - start;
+
+            var isNotAGenericType = ast.kind() !== 126 /* GenericType */;
+
+            var typeNameMembers = type.getScopedNameEx(declarationPullSymbol, false, false, false, false, false, isNotAGenericType);
+            this.emitTypeNamesMember(typeNameMembers);
+        };
+
+        DeclarationEmitter.prototype.emitComment = function (comment) {
+            var text = TypeScript.getTrimmedTextLines(comment);
+            if (this.declFile.onNewLine) {
+                this.emitIndent();
+            } else if (comment.kind() !== 6 /* MultiLineCommentTrivia */) {
+                this.declFile.WriteLine("");
+                this.emitIndent();
+            }
+
+            this.declFile.Write(text[0]);
+
+            for (var i = 1; i < text.length; i++) {
+                this.declFile.WriteLine("");
+                this.emitIndent();
+                this.declFile.Write(text[i]);
+            }
+
+            if (comment.endsLine || comment.kind() !== 6 /* MultiLineCommentTrivia */) {
+                this.declFile.WriteLine("");
+            } else {
+                this.declFile.Write(" ");
+            }
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationComments = function (astOrSymbol, endLine) {
+            if (typeof endLine === "undefined") { endLine = true; }
+            if (this.emitOptions.compilationSettings().removeComments()) {
+                return;
+            }
+
+            var declComments = astOrSymbol.docComments ? astOrSymbol.docComments() : TypeScript.ASTHelpers.docComments(astOrSymbol);
+            this.writeDeclarationComments(declComments, endLine);
+        };
+
+        DeclarationEmitter.prototype.writeDeclarationComments = function (declComments, endLine) {
+            if (typeof endLine === "undefined") { endLine = true; }
+            if (declComments.length > 0) {
+                for (var i = 0; i < declComments.length; i++) {
+                    this.emitComment(declComments[i]);
+                }
+
+                if (endLine) {
+                    if (!this.declFile.onNewLine) {
+                        this.declFile.WriteLine("");
+                    }
+                } else {
+                    if (this.declFile.onNewLine) {
+                        this.emitIndent();
+                    }
+                }
+            }
+        };
+
+        DeclarationEmitter.prototype.emitTypeOfVariableDeclaratorOrParameter = function (boundDecl) {
+            var start = new Date().getTime();
+            var decl = this.semanticInfoChain.getDeclForAST(boundDecl);
+            var pullSymbol = decl.getSymbol();
+            TypeScript.declarationEmitGetBoundDeclTypeTime += new Date().getTime() - start;
+
+            var type = pullSymbol.type;
+            TypeScript.Debug.assert(type);
+
+            this.declFile.Write(": ");
+            this.emitTypeSignature(boundDecl, type);
+        };
+
+        DeclarationEmitter.prototype.emitPropertySignature = function (varDecl) {
+            this.emitDeclarationComments(varDecl);
+            this.emitIndent();
+            this.declFile.Write(varDecl.propertyName.text());
+            if (varDecl.questionToken) {
+                this.declFile.Write("?");
+            }
+
+            this.emitTypeOfVariableDeclaratorOrParameter(varDecl);
+
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitVariableDeclarator = function (varDecl, isFirstVarInList, isLastVarInList) {
+            if (this.canEmitDeclarations(varDecl)) {
+                this.emitDeclarationComments(varDecl);
+
+                if (isFirstVarInList) {
+                    this.emitDeclFlags(varDecl, "var");
+                }
+
+                this.declFile.Write(varDecl.propertyName.text());
+
+                if (!TypeScript.hasModifier(TypeScript.ASTHelpers.getVariableDeclaratorModifiers(varDecl), 2 /* Private */)) {
+                    this.emitTypeOfVariableDeclaratorOrParameter(varDecl);
+                }
+
+                if (isLastVarInList) {
+                    this.declFile.WriteLine(";");
+                } else {
+                    this.declFile.Write(", ");
+                }
+            }
+        };
+
+        DeclarationEmitter.prototype.emitClassElementModifiers = function (modifiers) {
+            if (TypeScript.hasModifier(modifiers, 16 /* Static */)) {
+                if (TypeScript.hasModifier(modifiers, 2 /* Private */)) {
+                    this.declFile.Write("private ");
+                }
+                this.declFile.Write("static ");
+            } else {
+                if (TypeScript.hasModifier(modifiers, 2 /* Private */)) {
+                    this.declFile.Write("private ");
+                } else {
+                    this.declFile.Write("public ");
+                }
+            }
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForMemberVariableDeclaration = function (varDecl) {
+            if (this.canEmitDeclarations(varDecl)) {
+                this.emitDeclarationComments(varDecl);
+
+                this.declFile.Write(this.getIndentString());
+                this.emitClassElementModifiers(varDecl.modifiers);
+                ;
+
+                this.declFile.Write(varDecl.variableDeclarator.propertyName.text());
+
+                if (!TypeScript.hasModifier(varDecl.modifiers, 2 /* Private */)) {
+                    this.emitTypeOfVariableDeclaratorOrParameter(varDecl);
+                }
+
+                this.declFile.WriteLine(";");
+            }
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForVariableStatement = function (variableStatement) {
+            this.emitDeclarationsForVariableDeclaration(variableStatement.declaration);
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForVariableDeclaration = function (variableDeclaration) {
+            var varListCount = variableDeclaration.declarators.nonSeparatorCount();
+            for (var i = 0; i < varListCount; i++) {
+                this.emitVariableDeclarator(variableDeclaration.declarators.nonSeparatorAt(i), i === 0, i === varListCount - 1);
+            }
+        };
+
+        DeclarationEmitter.prototype.emitArgDecl = function (argDecl, id, isOptional, isPrivate) {
+            this.indenter.increaseIndent();
+
+            this.emitDeclarationComments(argDecl, false);
+            this.declFile.Write(id.text());
+            if (isOptional) {
+                this.declFile.Write("?");
+            }
+
+            this.indenter.decreaseIndent();
+
+            if (!isPrivate) {
+                this.emitTypeOfVariableDeclaratorOrParameter(argDecl);
+            }
+        };
+
+        DeclarationEmitter.prototype.isOverloadedCallSignature = function (funcDecl) {
+            var start = new Date().getTime();
+            var functionDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            var funcSymbol = functionDecl.getSymbol();
+            TypeScript.declarationEmitIsOverloadedCallSignatureTime += new Date().getTime() - start;
+
+            var funcTypeSymbol = funcSymbol.type;
+            var signatures = funcTypeSymbol.getCallSignatures();
+            var result = signatures && signatures.length > 1;
+
+            return result;
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForConstructorDeclaration = function (funcDecl) {
+            var start = new Date().getTime();
+            var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl);
+
+            TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start;
+
+            var funcTypeSymbol = funcSymbol.type;
+            if (funcDecl.block) {
+                var constructSignatures = funcTypeSymbol.getConstructSignatures();
+                if (constructSignatures && constructSignatures.length > 1) {
+                    return;
+                }
+            }
+
+            var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            var funcSignature = funcPullDecl.getSignatureSymbol();
+            this.emitDeclarationComments(funcDecl);
+
+            this.emitIndent();
+            this.declFile.Write("constructor");
+
+            this.declFile.Write("(");
+            this.emitParameters(false, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList));
+            this.declFile.Write(")");
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitParameterList = function (isPrivate, parameterList) {
+            this.declFile.Write("(");
+            this.emitParameters(isPrivate, TypeScript.ASTHelpers.parametersFromParameterList(parameterList));
+            this.declFile.Write(")");
+        };
+
+        DeclarationEmitter.prototype.emitParameters = function (isPrivate, parameterList) {
+            var hasLastParameterRestParameter = parameterList.lastParameterIsRest();
+            var argsLen = parameterList.length;
+            if (hasLastParameterRestParameter) {
+                argsLen--;
+            }
+
+            for (var i = 0; i < argsLen; i++) {
+                this.emitArgDecl(parameterList.astAt(i), parameterList.identifierAt(i), parameterList.isOptionalAt(i), isPrivate);
+                if (i < (argsLen - 1)) {
+                    this.declFile.Write(", ");
+                }
+            }
+
+            if (hasLastParameterRestParameter) {
+                if (parameterList.length > 1) {
+                    this.declFile.Write(", ...");
+                } else {
+                    this.declFile.Write("...");
+                }
+
+                var index = parameterList.length - 1;
+                this.emitArgDecl(parameterList.astAt(index), parameterList.identifierAt(index), parameterList.isOptionalAt(index), isPrivate);
+            }
+        };
+
+        DeclarationEmitter.prototype.emitMemberFunctionDeclaration = function (funcDecl) {
+            var start = new Date().getTime();
+            var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl);
+
+            TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start;
+
+            var funcTypeSymbol = funcSymbol.type;
+            if (funcDecl.block) {
+                var constructSignatures = funcTypeSymbol.getConstructSignatures();
+                if (constructSignatures && constructSignatures.length > 1) {
+                    return;
+                } else if (this.isOverloadedCallSignature(funcDecl)) {
+                    return;
+                }
+            } else if (TypeScript.hasModifier(funcDecl.modifiers, 2 /* Private */) && this.isOverloadedCallSignature(funcDecl)) {
+                var callSignatures = funcTypeSymbol.getCallSignatures();
+                TypeScript.Debug.assert(callSignatures && callSignatures.length > 1);
+                var firstSignature = callSignatures[0].isDefinition() ? callSignatures[1] : callSignatures[0];
+                var firstSignatureDecl = firstSignature.getDeclarations()[0];
+                var firstFuncDecl = this.semanticInfoChain.getASTForDecl(firstSignatureDecl);
+                if (firstFuncDecl !== funcDecl) {
+                    return;
+                }
+            }
+
+            if (!this.canEmitDeclarations(funcDecl)) {
+                return;
+            }
+
+            var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            var funcSignature = funcPullDecl.getSignatureSymbol();
+            this.emitDeclarationComments(funcDecl);
+
+            this.emitDeclFlags(funcDecl, "function");
+            var id = funcDecl.propertyName.text();
+            this.declFile.Write(id);
+            this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature);
+
+            var isPrivate = TypeScript.hasModifier(funcDecl.modifiers, 2 /* Private */);
+
+            this.emitParameterList(isPrivate, funcDecl.callSignature.parameterList);
+
+            if (!isPrivate) {
+                var returnType = funcSignature.returnType;
+                this.declFile.Write(": ");
+                this.emitTypeSignature(funcDecl, returnType);
+            }
+
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitCallSignature = function (funcDecl) {
+            var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+
+            this.emitDeclarationComments(funcDecl);
+
+            var funcSignature = funcPullDecl.getSignatureSymbol();
+            this.emitTypeParameters(funcDecl.typeParameterList, funcSignature);
+
+            this.emitIndent();
+            this.declFile.Write("(");
+            this.emitParameters(false, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.parameterList));
+            this.declFile.Write(")");
+
+            var returnType = funcSignature.returnType;
+            this.declFile.Write(": ");
+            if (returnType) {
+                this.emitTypeSignature(funcDecl, returnType);
+            } else {
+                this.declFile.Write("any");
+            }
+
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitConstructSignature = function (funcDecl) {
+            var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+
+            var start = new Date().getTime();
+            var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl);
+
+            TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start;
+
+            this.emitDeclarationComments(funcDecl);
+
+            this.emitIndent();
+            this.declFile.Write("new");
+
+            var funcSignature = funcPullDecl.getSignatureSymbol();
+            this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature);
+
+            this.declFile.Write("(");
+            this.emitParameters(false, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList));
+            this.declFile.Write(")");
+
+            var returnType = funcSignature.returnType;
+            this.declFile.Write(": ");
+            if (returnType) {
+                this.emitTypeSignature(funcDecl, returnType);
+            } else {
+                this.declFile.Write("any");
+            }
+
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitMethodSignature = function (funcDecl) {
+            var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+
+            var start = new Date().getTime();
+            var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl);
+
+            TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start;
+
+            this.emitDeclarationComments(funcDecl);
+
+            this.emitIndent();
+            this.declFile.Write(funcDecl.propertyName.text());
+            if (funcDecl.questionToken) {
+                this.declFile.Write("? ");
+            }
+
+            var funcSignature = funcPullDecl.getSignatureSymbol();
+            this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature);
+
+            this.declFile.Write("(");
+            this.emitParameters(false, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList));
+            this.declFile.Write(")");
+
+            var returnType = funcSignature.returnType;
+            this.declFile.Write(": ");
+            if (returnType) {
+                this.emitTypeSignature(funcDecl, returnType);
+            } else {
+                this.declFile.Write("any");
+            }
+
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForFunctionDeclaration = function (funcDecl) {
+            var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+
+            var start = new Date().getTime();
+            var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl);
+
+            TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start;
+
+            if (funcDecl.block) {
+                var funcTypeSymbol = funcSymbol.type;
+                var constructSignatures = funcTypeSymbol.getConstructSignatures();
+                if (constructSignatures && constructSignatures.length > 1) {
+                    return;
+                } else if (this.isOverloadedCallSignature(funcDecl)) {
+                    return;
+                }
+            }
+
+            if (!this.canEmitDeclarations(funcDecl)) {
+                return;
+            }
+
+            this.emitDeclarationComments(funcDecl);
+
+            var id = funcDecl.identifier.text();
+            this.emitDeclFlags(funcDecl, "function");
+            if (id !== "" || !funcDecl.identifier || funcDecl.identifier.text().length > 0) {
+                this.declFile.Write(id);
+            } else if (funcPullDecl.kind === 2097152 /* ConstructSignature */) {
+                this.declFile.Write("new");
+            }
+
+            var funcSignature = funcPullDecl.getSignatureSymbol();
+            this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature);
+
+            this.declFile.Write("(");
+            this.emitParameters(false, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList));
+            this.declFile.Write(")");
+
+            var returnType = funcSignature.returnType;
+            this.declFile.Write(": ");
+            if (returnType) {
+                this.emitTypeSignature(funcDecl, returnType);
+            } else {
+                this.declFile.Write("any");
+            }
+
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitIndexMemberDeclaration = function (funcDecl) {
+            this.emitDeclarationsForAST(funcDecl.indexSignature);
+        };
+
+        DeclarationEmitter.prototype.emitIndexSignature = function (funcDecl) {
+            if (!this.canEmitDeclarations(funcDecl)) {
+                return;
+            }
+
+            this.emitDeclarationComments(funcDecl);
+
+            this.emitIndent();
+            this.declFile.Write("[");
+            this.emitParameters(false, TypeScript.ASTHelpers.parametersFromParameter(funcDecl.parameter));
+            this.declFile.Write("]");
+
+            var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+            var funcSignature = funcPullDecl.getSignatureSymbol();
+            var returnType = funcSignature.returnType;
+            this.declFile.Write(": ");
+            this.emitTypeSignature(funcDecl, returnType);
+
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitBaseList = function (bases, useExtendsList) {
+            if (bases && (bases.nonSeparatorCount() > 0)) {
+                var qual = useExtendsList ? "extends" : "implements";
+                this.declFile.Write(" " + qual + " ");
+                var basesLen = bases.nonSeparatorCount();
+                for (var i = 0; i < basesLen; i++) {
+                    if (i > 0) {
+                        this.declFile.Write(", ");
+                    }
+                    var base = bases.nonSeparatorAt(i);
+                    var baseType = this.semanticInfoChain.getSymbolForAST(base);
+                    this.emitTypeSignature(base, baseType);
+                }
+            }
+        };
+
+        DeclarationEmitter.prototype.emitAccessorDeclarationComments = function (funcDecl) {
+            if (this.emitOptions.compilationSettings().removeComments()) {
+                return;
+            }
+
+            var start = new Date().getTime();
+            var accessors = TypeScript.PullHelpers.getGetterAndSetterFunction(funcDecl, this.semanticInfoChain);
+            TypeScript.declarationEmitGetAccessorFunctionTime += new Date().getTime();
+
+            var comments = [];
+            if (accessors.getter) {
+                comments = comments.concat(TypeScript.ASTHelpers.docComments(accessors.getter));
+            }
+            if (accessors.setter) {
+                comments = comments.concat(TypeScript.ASTHelpers.docComments(accessors.setter));
+            }
+
+            this.writeDeclarationComments(comments);
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForGetAccessor = function (funcDecl) {
+            this.emitMemberAccessorDeclaration(funcDecl, funcDecl.modifiers, funcDecl.propertyName);
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForSetAccessor = function (funcDecl) {
+            this.emitMemberAccessorDeclaration(funcDecl, funcDecl.modifiers, funcDecl.propertyName);
+        };
+
+        DeclarationEmitter.prototype.emitMemberAccessorDeclaration = function (funcDecl, modifiers, name) {
+            var start = new Date().getTime();
+            var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(funcDecl, this.semanticInfoChain);
+            TypeScript.declarationEmitGetAccessorFunctionTime += new Date().getTime();
+
+            if (funcDecl.kind() === 140 /* SetAccessor */ && accessorSymbol.getGetter()) {
+                return;
+            }
+
+            var isPrivate = TypeScript.hasModifier(modifiers, 2 /* Private */);
+            this.emitAccessorDeclarationComments(funcDecl);
+            this.declFile.Write(this.getIndentString());
+            this.emitClassElementModifiers(modifiers);
+            this.declFile.Write(name.text());
+            if (!isPrivate) {
+                this.declFile.Write(" : ");
+                var type = accessorSymbol.type;
+                this.emitTypeSignature(funcDecl, type);
+            }
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.emitClassMembersFromConstructorDefinition = function (funcDecl) {
+            var argsLen = funcDecl.callSignature.parameterList.parameters.nonSeparatorCount();
+            if (TypeScript.lastParameterIsRest(funcDecl.callSignature.parameterList)) {
+                argsLen--;
+            }
+
+            for (var i = 0; i < argsLen; i++) {
+                var parameter = funcDecl.callSignature.parameterList.parameters.nonSeparatorAt(i);
+                var parameterDecl = this.semanticInfoChain.getDeclForAST(parameter);
+                if (TypeScript.hasFlag(parameterDecl.flags, 8388608 /* PropertyParameter */)) {
+                    var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl);
+                    this.emitDeclarationComments(parameter);
+                    this.declFile.Write(this.getIndentString());
+                    this.emitClassElementModifiers(parameter.modifiers);
+                    this.declFile.Write(parameter.identifier.text());
+
+                    if (!TypeScript.hasModifier(parameter.modifiers, 2 /* Private */)) {
+                        this.emitTypeOfVariableDeclaratorOrParameter(parameter);
+                    }
+                    this.declFile.WriteLine(";");
+                }
+            }
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForClassDeclaration = function (classDecl) {
+            if (!this.canEmitDeclarations(classDecl)) {
+                return;
+            }
+
+            var className = classDecl.identifier.text();
+            this.emitDeclarationComments(classDecl);
+            var classPullDecl = this.semanticInfoChain.getDeclForAST(classDecl);
+            this.emitDeclFlags(classDecl, "class");
+            this.declFile.Write(className);
+
+            this.emitTypeParameters(classDecl.typeParameterList);
+            this.emitHeritageClauses(classDecl.heritageClauses);
+            this.declFile.WriteLine(" {");
+
+            this.indenter.increaseIndent();
+            var constructorDecl = TypeScript.getLastConstructor(classDecl);
+            if (constructorDecl) {
+                this.emitClassMembersFromConstructorDefinition(constructorDecl);
+            }
+
+            this.emitDeclarationsForList(classDecl.classElements);
+
+            this.indenter.decreaseIndent();
+
+            this.emitIndent();
+            this.declFile.WriteLine("}");
+        };
+
+        DeclarationEmitter.prototype.emitHeritageClauses = function (clauses) {
+            if (clauses) {
+                for (var i = 0, n = clauses.childCount(); i < n; i++) {
+                    this.emitHeritageClause(clauses.childAt(i));
+                }
+            }
+        };
+
+        DeclarationEmitter.prototype.emitHeritageClause = function (clause) {
+            this.emitBaseList(clause.typeNames, clause.kind() === 230 /* ExtendsHeritageClause */);
+        };
+
+        DeclarationEmitter.getEnclosingContainer = function (ast) {
+            var enclosingModule = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(ast);
+            if (TypeScript.ASTHelpers.isAnyNameOfModule(enclosingModule, ast)) {
+                ast = enclosingModule;
+            }
+
+            ast = ast.parent;
+            while (ast) {
+                if (ast.kind() === 131 /* ClassDeclaration */ || ast.kind() === 128 /* InterfaceDeclaration */ || ast.kind() === 130 /* ModuleDeclaration */ || ast.kind() === 120 /* SourceUnit */) {
+                    return ast;
+                }
+
+                ast = ast.parent;
+            }
+
+            return null;
+        };
+
+        DeclarationEmitter.prototype.emitTypeParameters = function (typeParams, funcSignature) {
+            if (!typeParams || !typeParams.typeParameters.nonSeparatorCount()) {
+                return;
+            }
+
+            this.declFile.Write("<");
+            var containerAst = DeclarationEmitter.getEnclosingContainer(typeParams);
+
+            var start = new Date().getTime();
+            var containerDecl = this.semanticInfoChain.getDeclForAST(containerAst);
+            var containerSymbol = containerDecl.getSymbol();
+            TypeScript.declarationEmitGetTypeParameterSymbolTime += new Date().getTime() - start;
+
+            var typars;
+            if (funcSignature) {
+                typars = funcSignature.getTypeParameters();
+            } else {
+                typars = containerSymbol.getTypeArgumentsOrTypeParameters();
+            }
+
+            for (var i = 0; i < typars.length; i++) {
+                if (i) {
+                    this.declFile.Write(", ");
+                }
+
+                var memberName = typars[i].getScopedNameEx(containerSymbol, false, true);
+                this.emitTypeNamesMember(memberName);
+            }
+
+            this.declFile.Write(">");
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForInterfaceDeclaration = function (interfaceDecl) {
+            if (!this.canEmitDeclarations(interfaceDecl)) {
+                return;
+            }
+
+            var interfaceName = interfaceDecl.identifier.text();
+            this.emitDeclarationComments(interfaceDecl);
+            var interfacePullDecl = this.semanticInfoChain.getDeclForAST(interfaceDecl);
+            this.emitDeclFlags(interfaceDecl, "interface");
+            this.declFile.Write(interfaceName);
+
+            this.emitTypeParameters(interfaceDecl.typeParameterList);
+            this.emitHeritageClauses(interfaceDecl.heritageClauses);
+            this.declFile.WriteLine(" {");
+
+            this.indenter.increaseIndent();
+
+            this.emitSeparatedList(interfaceDecl.body.typeMembers);
+
+            this.indenter.decreaseIndent();
+
+            this.emitIndent();
+            this.declFile.WriteLine("}");
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForImportDeclaration = function (importDeclAST) {
+            var importDecl = this.semanticInfoChain.getDeclForAST(importDeclAST);
+            var importSymbol = importDecl.getSymbol();
+            var isExportedImportDecl = TypeScript.hasModifier(importDeclAST.modifiers, 1 /* Exported */);
+
+            if (isExportedImportDecl || importSymbol.typeUsedExternally() || TypeScript.PullContainerSymbol.usedAsSymbol(importSymbol.getContainer(), importSymbol)) {
+                this.emitDeclarationComments(importDeclAST);
+                this.emitIndent();
+                if (isExportedImportDecl) {
+                    this.declFile.Write("export ");
+                }
+                this.declFile.Write("import ");
+                this.declFile.Write(importDeclAST.identifier.text() + " = ");
+                if (importDeclAST.moduleReference.kind() === 245 /* ExternalModuleReference */) {
+                    this.declFile.WriteLine("require(" + importDeclAST.moduleReference.stringLiteral.text() + ");");
+                } else {
+                    this.declFile.WriteLine(TypeScript.ASTHelpers.getNameOfIdenfierOrQualifiedName(importDeclAST.moduleReference.moduleName) + ";");
+                }
+            }
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForEnumDeclaration = function (moduleDecl) {
+            if (!this.canEmitDeclarations(moduleDecl)) {
+                return;
+            }
+
+            this.emitDeclarationComments(moduleDecl);
+            var modulePullDecl = this.semanticInfoChain.getDeclForAST(moduleDecl);
+            this.emitDeclFlags(moduleDecl, "enum");
+            this.declFile.WriteLine(moduleDecl.identifier.text() + " {");
+
+            this.indenter.increaseIndent();
+            var membersLen = moduleDecl.enumElements.nonSeparatorCount();
+            for (var j = 0; j < membersLen; j++) {
+                var memberDecl = moduleDecl.enumElements.nonSeparatorAt(j);
+                var enumElement = memberDecl;
+                var enumElementDecl = this.semanticInfoChain.getDeclForAST(enumElement);
+                this.emitDeclarationComments(enumElement);
+                this.emitIndent();
+                this.declFile.Write(enumElement.propertyName.text());
+                if (enumElementDecl.constantValue !== null) {
+                    this.declFile.Write(" = " + enumElementDecl.constantValue);
+                }
+                this.declFile.WriteLine(",");
+            }
+            this.indenter.decreaseIndent();
+
+            this.emitIndent();
+            this.declFile.WriteLine("}");
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForModuleDeclaration = function (moduleDecl) {
+            var name = moduleDecl.stringLiteral || TypeScript.ArrayUtilities.first(TypeScript.ASTHelpers.getModuleNames(moduleDecl.name));
+            if (!this.canEmitDeclarations(name)) {
+                return;
+            }
+
+            this.emitDeclarationComments(moduleDecl);
+            this.emitDeclFlags(name, "module");
+
+            if (moduleDecl.stringLiteral) {
+                this.declFile.Write(moduleDecl.stringLiteral.text());
+            } else {
+                this.declFile.Write(TypeScript.ASTHelpers.getNameOfIdenfierOrQualifiedName(moduleDecl.name));
+            }
+
+            this.declFile.WriteLine(" {");
+            this.indenter.increaseIndent();
+
+            this.emitDeclarationsForList(moduleDecl.moduleElements);
+
+            this.indenter.decreaseIndent();
+            this.emitIndent();
+            this.declFile.WriteLine("}");
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForExportAssignment = function (ast) {
+            this.emitIndent();
+            this.declFile.Write("export = ");
+            this.declFile.Write(ast.identifier.text());
+            this.declFile.WriteLine(";");
+        };
+
+        DeclarationEmitter.prototype.resolveScriptReference = function (document, reference) {
+            if (!this.emitOptions.compilationSettings().noResolve() || TypeScript.isRooted(reference)) {
+                return reference;
+            }
+
+            var documentDir = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(TypeScript.getRootFilePath(document.fileName)));
+            var resolvedReferencePath = this.emitOptions.resolvePath(documentDir + reference);
+            return resolvedReferencePath;
+        };
+
+        DeclarationEmitter.prototype.emitReferencePaths = function (sourceUnit) {
+            if (this.emittedReferencePaths) {
+                return;
+            }
+
+            var documents = [];
+            if (this.document.emitToOwnOutputFile()) {
+                var scriptReferences = this.document.referencedFiles;
+                var addedGlobalDocument = false;
+                for (var j = 0; j < scriptReferences.length; j++) {
+                    var currentReference = this.resolveScriptReference(this.document, scriptReferences[j]);
+                    var document = this.compiler.getDocument(currentReference);
+
+                    if (document && (document.emitToOwnOutputFile() || document.isDeclareFile() || !addedGlobalDocument)) {
+                        documents = documents.concat(document);
+
+                        if (!document.isDeclareFile() && document.isExternalModule()) {
+                            addedGlobalDocument = true;
+                        }
+                    }
+                }
+            } else {
+                var fileNames = this.compiler.fileNames();
+                for (var i = 0; i < fileNames.length; i++) {
+                    var doc = this.compiler.getDocument(fileNames[i]);
+                    if (!doc.isDeclareFile() && !doc.isExternalModule()) {
+                        var scriptReferences = doc.referencedFiles;
+                        for (var j = 0; j < scriptReferences.length; j++) {
+                            var currentReference = this.resolveScriptReference(doc, scriptReferences[j]);
+                            var document = this.compiler.getDocument(currentReference);
+
+                            if (document && (document.isDeclareFile() || document.isExternalModule())) {
+                                for (var k = 0; k < documents.length; k++) {
+                                    if (documents[k] === document) {
+                                        break;
+                                    }
+                                }
+
+                                if (k === documents.length) {
+                                    documents = documents.concat(document);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            var emittingFilePath = documents.length ? TypeScript.getRootFilePath(this.emittingFileName) : null;
+            for (var i = 0; i < documents.length; i++) {
+                var document = documents[i];
+                var declFileName;
+                if (document.isDeclareFile()) {
+                    declFileName = document.fileName;
+                } else {
+                    declFileName = this.compiler.mapOutputFileName(document, this.emitOptions, TypeScript.TypeScriptCompiler.mapToDTSFileName);
+                }
+
+                declFileName = TypeScript.getRelativePathToFixedPath(emittingFilePath, declFileName, false);
+                this.declFile.WriteLine('/// <reference path="' + declFileName + '" />');
+            }
+
+            this.emittedReferencePaths = true;
+        };
+
+        DeclarationEmitter.prototype.emitDeclarationsForSourceUnit = function (sourceUnit) {
+            this.emitReferencePaths(sourceUnit);
+            this.emitDeclarationsForList(sourceUnit.moduleElements);
+        };
+        return DeclarationEmitter;
+    })();
+    TypeScript.DeclarationEmitter = DeclarationEmitter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var BloomFilter = (function () {
+        function BloomFilter(expectedCount) {
+            var m = Math.max(1, BloomFilter.computeM(expectedCount));
+            var k = Math.max(1, BloomFilter.computeK(expectedCount));
+            ;
+
+            var sizeInEvenBytes = (m + 7) & ~7;
+
+            this.bitArray = [];
+            for (var i = 0, len = sizeInEvenBytes; i < len; i++) {
+                this.bitArray[i] = false;
+            }
+            this.hashFunctionCount = k;
+        }
+        BloomFilter.computeM = function (expectedCount) {
+            var p = BloomFilter.falsePositiveProbability;
+            var n = expectedCount;
+
+            var numerator = n * Math.log(p);
+            var denominator = Math.log(1.0 / Math.pow(2.0, Math.log(2.0)));
+            return Math.ceil(numerator / denominator);
+        };
+
+        BloomFilter.computeK = function (expectedCount) {
+            var n = expectedCount;
+            var m = BloomFilter.computeM(expectedCount);
+
+            var temp = Math.log(2.0) * m / n;
+            return Math.round(temp);
+        };
+
+        BloomFilter.prototype.computeHash = function (key, seed) {
+            return TypeScript.Hash.computeMurmur2StringHashCode(key, seed);
+        };
+
+        BloomFilter.prototype.addKeys = function (keys) {
+            for (var name in keys) {
+                if (keys[name]) {
+                    this.add(name);
+                }
+            }
+        };
+
+        BloomFilter.prototype.add = function (value) {
+            for (var i = 0; i < this.hashFunctionCount; i++) {
+                var hash = this.computeHash(value, i);
+                hash = hash % this.bitArray.length;
+                this.bitArray[Math.abs(hash)] = true;
+            }
+        };
+
+        BloomFilter.prototype.probablyContains = function (value) {
+            for (var i = 0; i < this.hashFunctionCount; i++) {
+                var hash = this.computeHash(value, i);
+                hash = hash % this.bitArray.length;
+                if (!this.bitArray[Math.abs(hash)]) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        BloomFilter.prototype.isEquivalent = function (filter) {
+            return BloomFilter.isEquivalent(this.bitArray, filter.bitArray) && this.hashFunctionCount === filter.hashFunctionCount;
+        };
+
+        BloomFilter.isEquivalent = function (array1, array2) {
+            if (array1.length !== array2.length) {
+                return false;
+            }
+
+            for (var i = 0; i < array1.length; i++) {
+                if (array1[i] !== array2[i]) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+        BloomFilter.falsePositiveProbability = 0.0001;
+        return BloomFilter;
+    })();
+    TypeScript.BloomFilter = BloomFilter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var IdentifierWalker = (function (_super) {
+        __extends(IdentifierWalker, _super);
+        function IdentifierWalker(list) {
+            _super.call(this);
+            this.list = list;
+        }
+        IdentifierWalker.prototype.visitToken = function (token) {
+            this.list[token.text()] = true;
+        };
+        return IdentifierWalker;
+    })(TypeScript.SyntaxWalker);
+    TypeScript.IdentifierWalker = IdentifierWalker;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var CompilationSettings = (function () {
+        function CompilationSettings() {
+            this.propagateEnumConstants = false;
+            this.removeComments = false;
+            this.watch = false;
+            this.noResolve = false;
+            this.allowAutomaticSemicolonInsertion = true;
+            this.noImplicitAny = false;
+            this.noLib = false;
+            this.codeGenTarget = 0 /* EcmaScript3 */;
+            this.moduleGenTarget = 0 /* Unspecified */;
+            this.outFileOption = "";
+            this.outDirOption = "";
+            this.mapSourceFiles = false;
+            this.mapRoot = "";
+            this.sourceRoot = "";
+            this.generateDeclarationFiles = false;
+            this.useCaseSensitiveFileResolution = false;
+            this.gatherDiagnostics = false;
+            this.codepage = null;
+            this.createFileLog = false;
+        }
+        return CompilationSettings;
+    })();
+    TypeScript.CompilationSettings = CompilationSettings;
+
+    var ImmutableCompilationSettings = (function () {
+        function ImmutableCompilationSettings(propagateEnumConstants, removeComments, watch, noResolve, allowAutomaticSemicolonInsertion, noImplicitAny, noLib, codeGenTarget, moduleGenTarget, outFileOption, outDirOption, mapSourceFiles, mapRoot, sourceRoot, generateDeclarationFiles, useCaseSensitiveFileResolution, gatherDiagnostics, codepage, createFileLog) {
+            this._propagateEnumConstants = propagateEnumConstants;
+            this._removeComments = removeComments;
+            this._watch = watch;
+            this._noResolve = noResolve;
+            this._allowAutomaticSemicolonInsertion = allowAutomaticSemicolonInsertion;
+            this._noImplicitAny = noImplicitAny;
+            this._noLib = noLib;
+            this._codeGenTarget = codeGenTarget;
+            this._moduleGenTarget = moduleGenTarget;
+            this._outFileOption = outFileOption;
+            this._outDirOption = outDirOption;
+            this._mapSourceFiles = mapSourceFiles;
+            this._mapRoot = mapRoot;
+            this._sourceRoot = sourceRoot;
+            this._generateDeclarationFiles = generateDeclarationFiles;
+            this._useCaseSensitiveFileResolution = useCaseSensitiveFileResolution;
+            this._gatherDiagnostics = gatherDiagnostics;
+            this._codepage = codepage;
+            this._createFileLog = createFileLog;
+        }
+        ImmutableCompilationSettings.prototype.propagateEnumConstants = function () {
+            return this._propagateEnumConstants;
+        };
+        ImmutableCompilationSettings.prototype.removeComments = function () {
+            return this._removeComments;
+        };
+        ImmutableCompilationSettings.prototype.watch = function () {
+            return this._watch;
+        };
+        ImmutableCompilationSettings.prototype.noResolve = function () {
+            return this._noResolve;
+        };
+        ImmutableCompilationSettings.prototype.allowAutomaticSemicolonInsertion = function () {
+            return this._allowAutomaticSemicolonInsertion;
+        };
+        ImmutableCompilationSettings.prototype.noImplicitAny = function () {
+            return this._noImplicitAny;
+        };
+        ImmutableCompilationSettings.prototype.noLib = function () {
+            return this._noLib;
+        };
+        ImmutableCompilationSettings.prototype.codeGenTarget = function () {
+            return this._codeGenTarget;
+        };
+        ImmutableCompilationSettings.prototype.moduleGenTarget = function () {
+            return this._moduleGenTarget;
+        };
+        ImmutableCompilationSettings.prototype.outFileOption = function () {
+            return this._outFileOption;
+        };
+        ImmutableCompilationSettings.prototype.outDirOption = function () {
+            return this._outDirOption;
+        };
+        ImmutableCompilationSettings.prototype.mapSourceFiles = function () {
+            return this._mapSourceFiles;
+        };
+        ImmutableCompilationSettings.prototype.mapRoot = function () {
+            return this._mapRoot;
+        };
+        ImmutableCompilationSettings.prototype.sourceRoot = function () {
+            return this._sourceRoot;
+        };
+        ImmutableCompilationSettings.prototype.generateDeclarationFiles = function () {
+            return this._generateDeclarationFiles;
+        };
+        ImmutableCompilationSettings.prototype.useCaseSensitiveFileResolution = function () {
+            return this._useCaseSensitiveFileResolution;
+        };
+        ImmutableCompilationSettings.prototype.gatherDiagnostics = function () {
+            return this._gatherDiagnostics;
+        };
+        ImmutableCompilationSettings.prototype.codepage = function () {
+            return this._codepage;
+        };
+        ImmutableCompilationSettings.prototype.createFileLog = function () {
+            return this._createFileLog;
+        };
+
+        ImmutableCompilationSettings.defaultSettings = function () {
+            if (!ImmutableCompilationSettings._defaultSettings) {
+                ImmutableCompilationSettings._defaultSettings = ImmutableCompilationSettings.fromCompilationSettings(new CompilationSettings());
+            }
+
+            return ImmutableCompilationSettings._defaultSettings;
+        };
+
+        ImmutableCompilationSettings.fromCompilationSettings = function (settings) {
+            return new ImmutableCompilationSettings(settings.propagateEnumConstants, settings.removeComments, settings.watch, settings.noResolve, settings.allowAutomaticSemicolonInsertion, settings.noImplicitAny, settings.noLib, settings.codeGenTarget, settings.moduleGenTarget, settings.outFileOption, settings.outDirOption, settings.mapSourceFiles, settings.mapRoot, settings.sourceRoot, settings.generateDeclarationFiles, settings.useCaseSensitiveFileResolution, settings.gatherDiagnostics, settings.codepage, settings.createFileLog);
+        };
+
+        ImmutableCompilationSettings.prototype.toCompilationSettings = function () {
+            var result = new CompilationSettings();
+
+            var thisAsIndexable = this;
+            var resultAsIndexable = result;
+            for (var name in this) {
+                if (this.hasOwnProperty(name) && TypeScript.StringUtilities.startsWith(name, "_")) {
+                    resultAsIndexable[name.substr(1)] = thisAsIndexable[name];
+                }
+            }
+
+            return result;
+        };
+        return ImmutableCompilationSettings;
+    })();
+    TypeScript.ImmutableCompilationSettings = ImmutableCompilationSettings;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (PullElementFlags) {
+        PullElementFlags[PullElementFlags["None"] = 0] = "None";
+        PullElementFlags[PullElementFlags["Exported"] = 1] = "Exported";
+        PullElementFlags[PullElementFlags["Private"] = 1 << 1] = "Private";
+        PullElementFlags[PullElementFlags["Public"] = 1 << 2] = "Public";
+        PullElementFlags[PullElementFlags["Ambient"] = 1 << 3] = "Ambient";
+        PullElementFlags[PullElementFlags["Static"] = 1 << 4] = "Static";
+        PullElementFlags[PullElementFlags["Optional"] = 1 << 7] = "Optional";
+        PullElementFlags[PullElementFlags["Signature"] = 1 << 11] = "Signature";
+        PullElementFlags[PullElementFlags["Enum"] = 1 << 12] = "Enum";
+        PullElementFlags[PullElementFlags["ArrowFunction"] = 1 << 13] = "ArrowFunction";
+
+        PullElementFlags[PullElementFlags["ClassConstructorVariable"] = 1 << 14] = "ClassConstructorVariable";
+        PullElementFlags[PullElementFlags["InitializedModule"] = 1 << 15] = "InitializedModule";
+        PullElementFlags[PullElementFlags["InitializedDynamicModule"] = 1 << 16] = "InitializedDynamicModule";
+
+        PullElementFlags[PullElementFlags["MustCaptureThis"] = 1 << 18] = "MustCaptureThis";
+
+        PullElementFlags[PullElementFlags["DeclaredInAWithBlock"] = 1 << 21] = "DeclaredInAWithBlock";
+
+        PullElementFlags[PullElementFlags["HasReturnStatement"] = 1 << 22] = "HasReturnStatement";
+
+        PullElementFlags[PullElementFlags["PropertyParameter"] = 1 << 23] = "PropertyParameter";
+
+        PullElementFlags[PullElementFlags["IsAnnotatedWithAny"] = 1 << 24] = "IsAnnotatedWithAny";
+
+        PullElementFlags[PullElementFlags["HasDefaultArgs"] = 1 << 25] = "HasDefaultArgs";
+
+        PullElementFlags[PullElementFlags["ConstructorParameter"] = 1 << 26] = "ConstructorParameter";
+
+        PullElementFlags[PullElementFlags["ImplicitVariable"] = PullElementFlags.ClassConstructorVariable | PullElementFlags.InitializedModule | PullElementFlags.InitializedDynamicModule | PullElementFlags.Enum] = "ImplicitVariable";
+        PullElementFlags[PullElementFlags["SomeInitializedModule"] = PullElementFlags.InitializedModule | PullElementFlags.InitializedDynamicModule | PullElementFlags.Enum] = "SomeInitializedModule";
+    })(TypeScript.PullElementFlags || (TypeScript.PullElementFlags = {}));
+    var PullElementFlags = TypeScript.PullElementFlags;
+
+    function hasModifier(modifiers, flag) {
+        for (var i = 0, n = modifiers.length; i < n; i++) {
+            if (TypeScript.hasFlag(modifiers[i], flag)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+    TypeScript.hasModifier = hasModifier;
+
+    (function (PullElementKind) {
+        PullElementKind[PullElementKind["None"] = 0] = "None";
+        PullElementKind[PullElementKind["Global"] = 0] = "Global";
+
+        PullElementKind[PullElementKind["Script"] = 1 << 0] = "Script";
+        PullElementKind[PullElementKind["Primitive"] = 1 << 1] = "Primitive";
+
+        PullElementKind[PullElementKind["Container"] = 1 << 2] = "Container";
+        PullElementKind[PullElementKind["Class"] = 1 << 3] = "Class";
+        PullElementKind[PullElementKind["Interface"] = 1 << 4] = "Interface";
+        PullElementKind[PullElementKind["DynamicModule"] = 1 << 5] = "DynamicModule";
+        PullElementKind[PullElementKind["Enum"] = 1 << 6] = "Enum";
+        PullElementKind[PullElementKind["TypeAlias"] = 1 << 7] = "TypeAlias";
+        PullElementKind[PullElementKind["ObjectLiteral"] = 1 << 8] = "ObjectLiteral";
+
+        PullElementKind[PullElementKind["Variable"] = 1 << 9] = "Variable";
+        PullElementKind[PullElementKind["CatchVariable"] = 1 << 10] = "CatchVariable";
+        PullElementKind[PullElementKind["Parameter"] = 1 << 11] = "Parameter";
+        PullElementKind[PullElementKind["Property"] = 1 << 12] = "Property";
+        PullElementKind[PullElementKind["TypeParameter"] = 1 << 13] = "TypeParameter";
+
+        PullElementKind[PullElementKind["Function"] = 1 << 14] = "Function";
+        PullElementKind[PullElementKind["ConstructorMethod"] = 1 << 15] = "ConstructorMethod";
+        PullElementKind[PullElementKind["Method"] = 1 << 16] = "Method";
+        PullElementKind[PullElementKind["FunctionExpression"] = 1 << 17] = "FunctionExpression";
+
+        PullElementKind[PullElementKind["GetAccessor"] = 1 << 18] = "GetAccessor";
+        PullElementKind[PullElementKind["SetAccessor"] = 1 << 19] = "SetAccessor";
+
+        PullElementKind[PullElementKind["CallSignature"] = 1 << 20] = "CallSignature";
+        PullElementKind[PullElementKind["ConstructSignature"] = 1 << 21] = "ConstructSignature";
+        PullElementKind[PullElementKind["IndexSignature"] = 1 << 22] = "IndexSignature";
+
+        PullElementKind[PullElementKind["ObjectType"] = 1 << 23] = "ObjectType";
+        PullElementKind[PullElementKind["FunctionType"] = 1 << 24] = "FunctionType";
+        PullElementKind[PullElementKind["ConstructorType"] = 1 << 25] = "ConstructorType";
+
+        PullElementKind[PullElementKind["EnumMember"] = 1 << 26] = "EnumMember";
+
+        PullElementKind[PullElementKind["WithBlock"] = 1 << 27] = "WithBlock";
+        PullElementKind[PullElementKind["CatchBlock"] = 1 << 28] = "CatchBlock";
+
+        PullElementKind[PullElementKind["All"] = PullElementKind.Script | PullElementKind.Global | PullElementKind.Primitive | PullElementKind.Container | PullElementKind.Class | PullElementKind.Interface | PullElementKind.DynamicModule | PullElementKind.Enum | PullElementKind.TypeAlias | PullElementKind.ObjectLiteral | PullElementKind.Variable | PullElementKind.Parameter | PullElementKind.Property | PullElementKind.TypeParameter | PullElementKind.Function | PullElementKind.ConstructorMethod | PullElementKind.Method | PullElementKind.FunctionExpression | PullElementKind.GetAccessor | PullElementKind.SetAccessor | PullElementKind.CallSignature | PullElementKind.ConstructSignature | PullElementKind.IndexSignature | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType | PullElementKind.EnumMember | PullElementKind.WithBlock | PullElementKind.CatchBlock] = "All";
+
+        PullElementKind[PullElementKind["SomeFunction"] = PullElementKind.Function | PullElementKind.ConstructorMethod | PullElementKind.Method | PullElementKind.FunctionExpression | PullElementKind.GetAccessor | PullElementKind.SetAccessor] = "SomeFunction";
+
+        PullElementKind[PullElementKind["SomeValue"] = PullElementKind.Variable | PullElementKind.Parameter | PullElementKind.Property | PullElementKind.EnumMember | PullElementKind.SomeFunction] = "SomeValue";
+
+        PullElementKind[PullElementKind["SomeType"] = PullElementKind.Script | PullElementKind.Global | PullElementKind.Primitive | PullElementKind.Class | PullElementKind.Interface | PullElementKind.Enum | PullElementKind.ObjectLiteral | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType | PullElementKind.TypeParameter] = "SomeType";
+
+        PullElementKind[PullElementKind["AcceptableAlias"] = PullElementKind.Variable | PullElementKind.SomeFunction | PullElementKind.Class | PullElementKind.Interface | PullElementKind.Enum | PullElementKind.Container | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType] = "AcceptableAlias";
+
+        PullElementKind[PullElementKind["SomeContainer"] = PullElementKind.Container | PullElementKind.DynamicModule | PullElementKind.TypeAlias] = "SomeContainer";
+
+        PullElementKind[PullElementKind["SomeSignature"] = PullElementKind.CallSignature | PullElementKind.ConstructSignature | PullElementKind.IndexSignature] = "SomeSignature";
+
+        PullElementKind[PullElementKind["SomeTypeReference"] = PullElementKind.Interface | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType] = "SomeTypeReference";
+
+        PullElementKind[PullElementKind["SomeInstantiatableType"] = PullElementKind.Class | PullElementKind.Interface | PullElementKind.TypeParameter] = "SomeInstantiatableType";
+    })(TypeScript.PullElementKind || (TypeScript.PullElementKind = {}));
+    var PullElementKind = TypeScript.PullElementKind;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var pullDeclID = 0;
+    var sentinelEmptyPullDeclArray = [];
+
+    var PullDecl = (function () {
+        function PullDecl(declName, displayName, kind, declFlags, semanticInfoChain) {
+            this.declID = pullDeclID++;
+            this.flags = 0 /* None */;
+            this.declGroups = null;
+            this.childDecls = null;
+            this.typeParameters = null;
+            this.synthesizedValDecl = null;
+            this.containerDecl = null;
+            this.childDeclTypeCache = null;
+            this.childDeclValueCache = null;
+            this.childDeclNamespaceCache = null;
+            this.childDeclTypeParameterCache = null;
+            this.name = declName;
+            this.kind = kind;
+            this.flags = declFlags;
+            this.semanticInfoChain = semanticInfoChain;
+
+            if (displayName !== this.name) {
+                this.declDisplayName = displayName;
+            }
+        }
+        PullDecl.prototype.fileName = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        PullDecl.prototype.getParentPath = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        PullDecl.prototype.getParentDecl = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        PullDecl.prototype.isExternalModule = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        PullDecl.prototype.getEnclosingDecl = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        PullDecl.prototype._getEnclosingDeclFromParentDecl = function () {
+            var decl = this;
+            while (decl) {
+                switch (decl.kind) {
+                    default:
+                        return decl;
+                    case 512 /* Variable */:
+                    case 8192 /* TypeParameter */:
+                    case 2048 /* Parameter */:
+                    case 128 /* TypeAlias */:
+                    case 67108864 /* EnumMember */:
+                }
+
+                decl = decl.getParentDecl();
+            }
+
+            TypeScript.Debug.fail();
+        };
+
+        PullDecl.prototype.getDisplayName = function () {
+            return this.declDisplayName === undefined ? this.name : this.declDisplayName;
+        };
+
+        PullDecl.prototype.setSymbol = function (symbol) {
+            this.semanticInfoChain.setSymbolForDecl(this, symbol);
+        };
+
+        PullDecl.prototype.ensureSymbolIsBound = function () {
+            if (!this.hasBeenBound() && this.kind !== 1 /* Script */) {
+                var binder = this.semanticInfoChain.getBinder();
+                binder.bindDeclToPullSymbol(this);
+            }
+        };
+
+        PullDecl.prototype.getSymbol = function () {
+            if (this.kind === 1 /* Script */) {
+                return null;
+            }
+
+            this.ensureSymbolIsBound();
+
+            return this.semanticInfoChain.getSymbolForDecl(this);
+        };
+
+        PullDecl.prototype.hasSymbol = function () {
+            var symbol = this.semanticInfoChain.getSymbolForDecl(this);
+            return !!symbol;
+        };
+
+        PullDecl.prototype.setSignatureSymbol = function (signatureSymbol) {
+            this.semanticInfoChain.setSignatureSymbolForDecl(this, signatureSymbol);
+        };
+
+        PullDecl.prototype.getSignatureSymbol = function () {
+            this.ensureSymbolIsBound();
+            return this.semanticInfoChain.getSignatureSymbolForDecl(this);
+        };
+
+        PullDecl.prototype.hasSignatureSymbol = function () {
+            var signatureSymbol = this.semanticInfoChain.getSignatureSymbolForDecl(this);
+            return !!signatureSymbol;
+        };
+
+        PullDecl.prototype.setFlags = function (flags) {
+            this.flags = flags;
+        };
+
+        PullDecl.prototype.setFlag = function (flags) {
+            this.flags |= flags;
+        };
+
+        PullDecl.prototype.setValueDecl = function (valDecl) {
+            this.synthesizedValDecl = valDecl;
+            valDecl.containerDecl = this;
+        };
+
+        PullDecl.prototype.getValueDecl = function () {
+            return this.synthesizedValDecl;
+        };
+
+        PullDecl.prototype.getContainerDecl = function () {
+            return this.containerDecl;
+        };
+
+        PullDecl.prototype.getChildDeclCache = function (declKind) {
+            if (declKind === 8192 /* TypeParameter */) {
+                if (!this.childDeclTypeParameterCache) {
+                    this.childDeclTypeParameterCache = TypeScript.createIntrinsicsObject();
+                }
+
+                return this.childDeclTypeParameterCache;
+            } else if (TypeScript.hasFlag(declKind, 164 /* SomeContainer */)) {
+                if (!this.childDeclNamespaceCache) {
+                    this.childDeclNamespaceCache = TypeScript.createIntrinsicsObject();
+                }
+
+                return this.childDeclNamespaceCache;
+            } else if (TypeScript.hasFlag(declKind, 58728795 /* SomeType */)) {
+                if (!this.childDeclTypeCache) {
+                    this.childDeclTypeCache = TypeScript.createIntrinsicsObject();
+                }
+
+                return this.childDeclTypeCache;
+            } else {
+                if (!this.childDeclValueCache) {
+                    this.childDeclValueCache = TypeScript.createIntrinsicsObject();
+                }
+
+                return this.childDeclValueCache;
+            }
+        };
+
+        PullDecl.prototype.addChildDecl = function (childDecl) {
+            if (childDecl.kind === 8192 /* TypeParameter */) {
+                if (!this.typeParameters) {
+                    this.typeParameters = [];
+                }
+                this.typeParameters[this.typeParameters.length] = childDecl;
+            } else {
+                if (!this.childDecls) {
+                    this.childDecls = [];
+                }
+                this.childDecls[this.childDecls.length] = childDecl;
+            }
+
+            var declName = childDecl.name;
+
+            if (!(childDecl.kind & 7340032 /* SomeSignature */)) {
+                var cache = this.getChildDeclCache(childDecl.kind);
+                var childrenOfName = cache[declName];
+                if (!childrenOfName) {
+                    childrenOfName = [];
+                }
+
+                childrenOfName.push(childDecl);
+                cache[declName] = childrenOfName;
+            }
+        };
+
+        PullDecl.prototype.searchChildDecls = function (declName, searchKind) {
+            var cacheVal = null;
+
+            if (searchKind & 58728795 /* SomeType */) {
+                cacheVal = this.childDeclTypeCache ? this.childDeclTypeCache[declName] : null;
+            } else if (searchKind & 164 /* SomeContainer */) {
+                cacheVal = this.childDeclNamespaceCache ? this.childDeclNamespaceCache[declName] : null;
+            } else {
+                cacheVal = this.childDeclValueCache ? this.childDeclValueCache[declName] : null;
+            }
+
+            if (cacheVal) {
+                return cacheVal;
+            } else {
+                if (searchKind & 58728795 /* SomeType */) {
+                    cacheVal = this.childDeclTypeParameterCache ? this.childDeclTypeParameterCache[declName] : null;
+
+                    if (cacheVal) {
+                        return cacheVal;
+                    }
+                }
+
+                return sentinelEmptyPullDeclArray;
+            }
+        };
+
+        PullDecl.prototype.getChildDecls = function () {
+            return this.childDecls || sentinelEmptyPullDeclArray;
+        };
+
+        PullDecl.prototype.getTypeParameters = function () {
+            return this.typeParameters || sentinelEmptyPullDeclArray;
+        };
+
+        PullDecl.prototype.addVariableDeclToGroup = function (decl) {
+            if (!this.declGroups) {
+                this.declGroups = TypeScript.createIntrinsicsObject();
+            }
+
+            var declGroup = this.declGroups[decl.name];
+            if (declGroup) {
+                declGroup.addDecl(decl);
+            } else {
+                declGroup = new PullDeclGroup(decl.name);
+                declGroup.addDecl(decl);
+                this.declGroups[decl.name] = declGroup;
+            }
+        };
+
+        PullDecl.prototype.getVariableDeclGroups = function () {
+            var declGroups = null;
+
+            if (this.declGroups) {
+                for (var declName in this.declGroups) {
+                    if (this.declGroups[declName]) {
+                        if (declGroups === null) {
+                            declGroups = [];
+                        }
+
+                        declGroups.push(this.declGroups[declName].getDecls());
+                    }
+                }
+            }
+
+            return declGroups || sentinelEmptyPullDeclArray;
+        };
+
+        PullDecl.prototype.hasBeenBound = function () {
+            return this.hasSymbol() || this.hasSignatureSymbol();
+        };
+
+        PullDecl.prototype.isSynthesized = function () {
+            return false;
+        };
+
+        PullDecl.prototype.ast = function () {
+            return this.semanticInfoChain.getASTForDecl(this);
+        };
+
+        PullDecl.prototype.isRootDecl = function () {
+            throw TypeScript.Errors.abstract();
+        };
+        return PullDecl;
+    })();
+    TypeScript.PullDecl = PullDecl;
+
+    var RootPullDecl = (function (_super) {
+        __extends(RootPullDecl, _super);
+        function RootPullDecl(name, fileName, kind, declFlags, semanticInfoChain, isExternalModule) {
+            _super.call(this, name, name, kind, declFlags, semanticInfoChain);
+            this.semanticInfoChain = semanticInfoChain;
+            this._isExternalModule = isExternalModule;
+            this._fileName = fileName;
+        }
+        RootPullDecl.prototype.fileName = function () {
+            return this._fileName;
+        };
+
+        RootPullDecl.prototype.getParentPath = function () {
+            return [this];
+        };
+
+        RootPullDecl.prototype.getParentDecl = function () {
+            return null;
+        };
+
+        RootPullDecl.prototype.isExternalModule = function () {
+            return this._isExternalModule;
+        };
+
+        RootPullDecl.prototype.getEnclosingDecl = function () {
+            return this;
+        };
+
+        RootPullDecl.prototype.isRootDecl = function () {
+            return true;
+        };
+        return RootPullDecl;
+    })(PullDecl);
+    TypeScript.RootPullDecl = RootPullDecl;
+
+    var NormalPullDecl = (function (_super) {
+        __extends(NormalPullDecl, _super);
+        function NormalPullDecl(declName, displayName, kind, declFlags, parentDecl, addToParent) {
+            if (typeof addToParent === "undefined") { addToParent = true; }
+            _super.call(this, declName, displayName, kind, declFlags, parentDecl ? parentDecl.semanticInfoChain : null);
+            this.parentDecl = null;
+            this.parentPath = null;
+
+            this.parentDecl = parentDecl;
+            if (addToParent) {
+                parentDecl.addChildDecl(this);
+            }
+
+            if (this.parentDecl) {
+                if (this.parentDecl.isRootDecl()) {
+                    this._rootDecl = this.parentDecl;
+                } else {
+                    this._rootDecl = this.parentDecl._rootDecl;
+                }
+            } else {
+                TypeScript.Debug.assert(this.isSynthesized());
+                this._rootDecl = null;
+            }
+        }
+        NormalPullDecl.prototype.fileName = function () {
+            return this._rootDecl.fileName();
+        };
+
+        NormalPullDecl.prototype.getParentDecl = function () {
+            return this.parentDecl;
+        };
+
+        NormalPullDecl.prototype.getParentPath = function () {
+            if (!this.parentPath) {
+                var path = [this];
+                var parentDecl = this.parentDecl;
+
+                while (parentDecl) {
+                    if (parentDecl && path[path.length - 1] !== parentDecl && !(parentDecl.kind & (256 /* ObjectLiteral */ | 8388608 /* ObjectType */))) {
+                        path.unshift(parentDecl);
+                    }
+
+                    parentDecl = parentDecl.getParentDecl();
+                }
+
+                this.parentPath = path;
+            }
+
+            return this.parentPath;
+        };
+
+        NormalPullDecl.prototype.isExternalModule = function () {
+            return false;
+        };
+
+        NormalPullDecl.prototype.getEnclosingDecl = function () {
+            return this.parentDecl && this.parentDecl._getEnclosingDeclFromParentDecl();
+        };
+
+        NormalPullDecl.prototype.isRootDecl = function () {
+            return false;
+        };
+        return NormalPullDecl;
+    })(PullDecl);
+    TypeScript.NormalPullDecl = NormalPullDecl;
+
+    var PullEnumElementDecl = (function (_super) {
+        __extends(PullEnumElementDecl, _super);
+        function PullEnumElementDecl(declName, displayName, parentDecl) {
+            _super.call(this, declName, displayName, 67108864 /* EnumMember */, 4 /* Public */, parentDecl);
+            this.constantValue = null;
+        }
+        return PullEnumElementDecl;
+    })(NormalPullDecl);
+    TypeScript.PullEnumElementDecl = PullEnumElementDecl;
+
+    var PullFunctionExpressionDecl = (function (_super) {
+        __extends(PullFunctionExpressionDecl, _super);
+        function PullFunctionExpressionDecl(expressionName, declFlags, parentDecl, displayName) {
+            if (typeof displayName === "undefined") { displayName = ""; }
+            _super.call(this, "", displayName, 131072 /* FunctionExpression */, declFlags, parentDecl);
+            this.functionExpressionName = expressionName;
+        }
+        PullFunctionExpressionDecl.prototype.getFunctionExpressionName = function () {
+            return this.functionExpressionName;
+        };
+        return PullFunctionExpressionDecl;
+    })(NormalPullDecl);
+    TypeScript.PullFunctionExpressionDecl = PullFunctionExpressionDecl;
+
+    var PullSynthesizedDecl = (function (_super) {
+        __extends(PullSynthesizedDecl, _super);
+        function PullSynthesizedDecl(declName, displayName, kind, declFlags, parentDecl, semanticInfoChain) {
+            _super.call(this, declName, displayName, kind, declFlags, parentDecl, false);
+            this.semanticInfoChain = semanticInfoChain;
+        }
+        PullSynthesizedDecl.prototype.isSynthesized = function () {
+            return true;
+        };
+
+        PullSynthesizedDecl.prototype.fileName = function () {
+            return this._rootDecl ? this._rootDecl.fileName() : "";
+        };
+        return PullSynthesizedDecl;
+    })(NormalPullDecl);
+    TypeScript.PullSynthesizedDecl = PullSynthesizedDecl;
+
+    var PullDeclGroup = (function () {
+        function PullDeclGroup(name) {
+            this.name = name;
+            this._decls = [];
+        }
+        PullDeclGroup.prototype.addDecl = function (decl) {
+            if (decl.name === this.name) {
+                this._decls[this._decls.length] = decl;
+            }
+        };
+
+        PullDeclGroup.prototype.getDecls = function () {
+            return this._decls;
+        };
+        return PullDeclGroup;
+    })();
+    TypeScript.PullDeclGroup = PullDeclGroup;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    TypeScript.pullSymbolID = 0;
+    TypeScript.sentinelEmptyArray = [];
+
+    var PullSymbol = (function () {
+        function PullSymbol(name, declKind) {
+            this.pullSymbolID = ++TypeScript.pullSymbolID;
+            this._container = null;
+            this.type = null;
+            this._declarations = null;
+            this.isResolved = false;
+            this.isOptional = false;
+            this.inResolution = false;
+            this.isSynthesized = false;
+            this.isVarArg = false;
+            this.rootSymbol = null;
+            this._enclosingSignature = null;
+            this._docComments = null;
+            this.isPrinting = false;
+            this.name = name;
+            this.kind = declKind;
+        }
+        PullSymbol.prototype.isAny = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.isType = function () {
+            return (this.kind & 58728795 /* SomeType */) !== 0;
+        };
+
+        PullSymbol.prototype.isTypeReference = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.isSignature = function () {
+            return (this.kind & 7340032 /* SomeSignature */) !== 0;
+        };
+
+        PullSymbol.prototype.isArrayNamedTypeReference = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.isPrimitive = function () {
+            return this.kind === 2 /* Primitive */;
+        };
+
+        PullSymbol.prototype.isAccessor = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.isError = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.isInterface = function () {
+            return this.kind === 16 /* Interface */;
+        };
+
+        PullSymbol.prototype.isMethod = function () {
+            return this.kind === 65536 /* Method */;
+        };
+
+        PullSymbol.prototype.isProperty = function () {
+            return this.kind === 4096 /* Property */;
+        };
+
+        PullSymbol.prototype.isAlias = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.isContainer = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.findAliasedType = function (scopeSymbol, skipScopeSymbolAliasesLookIn, lookIntoOnlyExportedAlias, aliasSymbols, visitedScopeDeclarations) {
+            if (typeof aliasSymbols === "undefined") { aliasSymbols = []; }
+            if (typeof visitedScopeDeclarations === "undefined") { visitedScopeDeclarations = []; }
+            var scopeDeclarations = scopeSymbol.getDeclarations();
+            var scopeSymbolAliasesToLookIn = [];
+
+            for (var i = 0; i < scopeDeclarations.length; i++) {
+                var scopeDecl = scopeDeclarations[i];
+                if (!TypeScript.ArrayUtilities.contains(visitedScopeDeclarations, scopeDecl)) {
+                    visitedScopeDeclarations.push(scopeDecl);
+
+                    var childDecls = scopeDecl.getChildDecls();
+                    for (var j = 0; j < childDecls.length; j++) {
+                        var childDecl = childDecls[j];
+                        if (childDecl.kind === 128 /* TypeAlias */ && (!lookIntoOnlyExportedAlias || (childDecl.flags & 1 /* Exported */))) {
+                            var symbol = childDecl.getSymbol();
+
+                            if (PullContainerSymbol.usedAsSymbol(symbol, this) || (this.rootSymbol && PullContainerSymbol.usedAsSymbol(symbol, this.rootSymbol))) {
+                                aliasSymbols.push(symbol);
+                                return aliasSymbols;
+                            }
+
+                            if (!skipScopeSymbolAliasesLookIn && PullSymbol._isExternalModuleReferenceAlias(symbol) && (!symbol.assignedContainer().hasExportAssignment() || (symbol.assignedContainer().getExportAssignedContainerSymbol() && symbol.assignedContainer().getExportAssignedContainerSymbol().kind === 32 /* DynamicModule */))) {
+                                scopeSymbolAliasesToLookIn.push(symbol);
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (var i = 0; i < scopeSymbolAliasesToLookIn.length; i++) {
+                var scopeSymbolAlias = scopeSymbolAliasesToLookIn[i];
+
+                aliasSymbols.push(scopeSymbolAlias);
+                var result = this.findAliasedType(scopeSymbolAlias.assignedContainer().hasExportAssignment() ? scopeSymbolAlias.assignedContainer().getExportAssignedContainerSymbol() : scopeSymbolAlias.assignedContainer(), false, true, aliasSymbols, visitedScopeDeclarations);
+                if (result) {
+                    return result;
+                }
+
+                aliasSymbols.pop();
+            }
+
+            return null;
+        };
+
+        PullSymbol.prototype.getExternalAliasedSymbols = function (scopeSymbol) {
+            if (!scopeSymbol) {
+                return null;
+            }
+
+            var scopePath = scopeSymbol.pathToRoot();
+            if (scopePath.length && scopePath[scopePath.length - 1].kind === 32 /* DynamicModule */) {
+                var symbols = this.findAliasedType(scopePath[scopePath.length - 1]);
+                return symbols;
+            }
+
+            return null;
+        };
+
+        PullSymbol._isExternalModuleReferenceAlias = function (aliasSymbol) {
+            if (aliasSymbol) {
+                if (aliasSymbol.assignedValue()) {
+                    return false;
+                }
+
+                if (aliasSymbol.assignedType() && aliasSymbol.assignedType() !== aliasSymbol.assignedContainer()) {
+                    return false;
+                }
+
+                if (aliasSymbol.assignedContainer() && aliasSymbol.assignedContainer().kind !== 32 /* DynamicModule */) {
+                    return false;
+                }
+
+                return true;
+            }
+
+            return false;
+        };
+
+        PullSymbol.prototype.getExportedInternalAliasSymbol = function (scopeSymbol) {
+            if (scopeSymbol) {
+                if (this.kind !== 128 /* TypeAlias */) {
+                    var scopePath = scopeSymbol.pathToRoot();
+                    for (var i = 0; i < scopePath.length; i++) {
+                        var internalAliases = this.findAliasedType(scopeSymbol, true, true);
+                        if (internalAliases) {
+                            TypeScript.Debug.assert(internalAliases.length === 1);
+                            return internalAliases[0];
+                        }
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        PullSymbol.prototype.getAliasSymbolName = function (scopeSymbol, aliasNameGetter, aliasPartsNameGetter, skipInternalAlias) {
+            if (!skipInternalAlias) {
+                var internalAlias = this.getExportedInternalAliasSymbol(scopeSymbol);
+                if (internalAlias) {
+                    return aliasNameGetter(internalAlias);
+                }
+            }
+
+            var externalAliases = this.getExternalAliasedSymbols(scopeSymbol);
+
+            if (externalAliases && PullSymbol._isExternalModuleReferenceAlias(externalAliases[externalAliases.length - 1])) {
+                var aliasFullName = aliasNameGetter(externalAliases[0]);
+                if (!aliasFullName) {
+                    return null;
+                }
+                for (var i = 1, symbolsLen = externalAliases.length; i < symbolsLen; i++) {
+                    aliasFullName = aliasFullName + "." + aliasPartsNameGetter(externalAliases[i]);
+                }
+                return aliasFullName;
+            }
+
+            return null;
+        };
+
+        PullSymbol.prototype._getResolver = function () {
+            TypeScript.Debug.assert(this._declarations && this._declarations.length > 0);
+            return this._declarations[0].semanticInfoChain.getResolver();
+        };
+
+        PullSymbol.prototype._resolveDeclaredSymbol = function () {
+            return this._getResolver().resolveDeclaredSymbol(this);
+        };
+
+        PullSymbol.prototype.getName = function (scopeSymbol, useConstraintInName) {
+            var aliasName = this.getAliasSymbolName(scopeSymbol, function (symbol) {
+                return symbol.getName(scopeSymbol, useConstraintInName);
+            }, function (symbol) {
+                return symbol.getName();
+            });
+            return aliasName || this.name;
+        };
+
+        PullSymbol.prototype.getDisplayName = function (scopeSymbol, useConstraintInName, skipInternalAliasName) {
+            var aliasDisplayName = this.getAliasSymbolName(scopeSymbol, function (symbol) {
+                return symbol.getDisplayName(scopeSymbol, useConstraintInName);
+            }, function (symbol) {
+                return symbol.getDisplayName();
+            }, skipInternalAliasName);
+            if (aliasDisplayName) {
+                return aliasDisplayName;
+            }
+
+            var decls = this.getDeclarations();
+            var name = decls.length && decls[0].getDisplayName();
+
+            return (name && name.length) ? name : this.name;
+        };
+
+        PullSymbol.prototype.getIsSpecialized = function () {
+            return false;
+        };
+
+        PullSymbol.prototype.getRootSymbol = function () {
+            if (!this.rootSymbol) {
+                return this;
+            }
+            return this.rootSymbol;
+        };
+        PullSymbol.prototype.setRootSymbol = function (symbol) {
+            this.rootSymbol = symbol;
+        };
+
+        PullSymbol.prototype.setIsSynthesized = function (value) {
+            if (typeof value === "undefined") { value = true; }
+            TypeScript.Debug.assert(this.rootSymbol == null);
+            this.isSynthesized = value;
+        };
+
+        PullSymbol.prototype.getIsSynthesized = function () {
+            if (this.rootSymbol) {
+                return this.rootSymbol.getIsSynthesized();
+            }
+            return this.isSynthesized;
+        };
+
+        PullSymbol.prototype.setEnclosingSignature = function (signature) {
+            this._enclosingSignature = signature;
+        };
+
+        PullSymbol.prototype.getEnclosingSignature = function () {
+            return this._enclosingSignature;
+        };
+
+        PullSymbol.prototype.addDeclaration = function (decl) {
+            TypeScript.Debug.assert(!!decl);
+
+            if (this.rootSymbol) {
+                return;
+            }
+
+            if (!this._declarations) {
+                this._declarations = [decl];
+            } else {
+                this._declarations[this._declarations.length] = decl;
+            }
+        };
+
+        PullSymbol.prototype.getDeclarations = function () {
+            if (this.rootSymbol) {
+                return this.rootSymbol.getDeclarations();
+            }
+
+            if (!this._declarations) {
+                this._declarations = [];
+            }
+
+            return this._declarations;
+        };
+
+        PullSymbol.prototype.hasDeclaration = function (decl) {
+            if (!this._declarations) {
+                return false;
+            }
+
+            return TypeScript.ArrayUtilities.any(this._declarations, function (eachDecl) {
+                return eachDecl === decl;
+            });
+        };
+
+        PullSymbol.prototype.setContainer = function (containerSymbol) {
+            if (this.rootSymbol) {
+                return;
+            }
+
+            this._container = containerSymbol;
+        };
+
+        PullSymbol.prototype.getContainer = function () {
+            if (this.rootSymbol) {
+                return this.rootSymbol.getContainer();
+            }
+
+            return this._container;
+        };
+
+        PullSymbol.prototype.setResolved = function () {
+            this.isResolved = true;
+            this.inResolution = false;
+        };
+
+        PullSymbol.prototype.startResolving = function () {
+            this.inResolution = true;
+        };
+
+        PullSymbol.prototype.setUnresolved = function () {
+            this.isResolved = false;
+            this.inResolution = false;
+        };
+
+        PullSymbol.prototype.anyDeclHasFlag = function (flag) {
+            var declarations = this.getDeclarations();
+            for (var i = 0, n = declarations.length; i < n; i++) {
+                if (TypeScript.hasFlag(declarations[i].flags, flag)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+
+        PullSymbol.prototype.allDeclsHaveFlag = function (flag) {
+            var declarations = this.getDeclarations();
+            for (var i = 0, n = declarations.length; i < n; i++) {
+                if (!TypeScript.hasFlag(declarations[i].flags, flag)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+
+        PullSymbol.prototype.pathToRoot = function () {
+            var path = [];
+            var node = this;
+            while (node) {
+                if (node.isType()) {
+                    var associatedContainerSymbol = node.getAssociatedContainerType();
+                    if (associatedContainerSymbol) {
+                        node = associatedContainerSymbol;
+                    }
+                }
+                path[path.length] = node;
+                var nodeKind = node.kind;
+                if (nodeKind === 2048 /* Parameter */) {
+                    break;
+                } else {
+                    node = node.getContainer();
+                }
+            }
+            return path;
+        };
+
+        PullSymbol.unqualifiedNameReferencesDifferentSymbolInScope = function (symbol, scopePath, endScopePathIndex) {
+            var declPath = scopePath[0].getDeclarations()[0].getParentPath();
+            for (var i = 0, declIndex = declPath.length - 1; i <= endScopePathIndex; i++, declIndex--) {
+                if (scopePath[i].isContainer()) {
+                    var scopeContainer = scopePath[i];
+                    if (symbol.isContainer()) {
+                        var memberSymbol = scopeContainer.findContainedNonMemberContainer(symbol.name, 164 /* SomeContainer */);
+                        if (memberSymbol && memberSymbol != symbol && memberSymbol.getDeclarations()[0].getParentDecl() == declPath[declIndex]) {
+                            return true;
+                        }
+
+                        var memberSymbol = scopeContainer.findNestedContainer(symbol.name, 164 /* SomeContainer */);
+                        if (memberSymbol && memberSymbol != symbol) {
+                            return true;
+                        }
+                    } else if (symbol.isType()) {
+                        var memberSymbol = scopeContainer.findContainedNonMemberType(symbol.name, 58728795 /* SomeType */);
+                        var symbolRootType = TypeScript.PullHelpers.getRootType(symbol);
+                        if (memberSymbol && TypeScript.PullHelpers.getRootType(memberSymbol) != symbolRootType && memberSymbol.getDeclarations()[0].getParentDecl() == declPath[declIndex]) {
+                            return true;
+                        }
+
+                        var memberSymbol = scopeContainer.findNestedType(symbol.name, 58728795 /* SomeType */);
+                        if (memberSymbol && TypeScript.PullHelpers.getRootType(memberSymbol) != symbolRootType) {
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        PullSymbol.prototype.findQualifyingSymbolPathInScopeSymbol = function (scopeSymbol) {
+            var thisPath = this.pathToRoot();
+            if (thisPath.length === 1) {
+                return thisPath;
+            }
+
+            var scopeSymbolPath;
+            if (scopeSymbol) {
+                scopeSymbolPath = scopeSymbol.pathToRoot();
+            } else {
+                return thisPath;
+            }
+
+            var thisCommonAncestorIndex = TypeScript.ArrayUtilities.indexOf(thisPath, function (thisNode) {
+                return TypeScript.ArrayUtilities.contains(scopeSymbolPath, thisNode);
+            });
+            if (thisCommonAncestorIndex > 0) {
+                var thisCommonAncestor = thisPath[thisCommonAncestorIndex];
+                var scopeCommonAncestorIndex = TypeScript.ArrayUtilities.indexOf(scopeSymbolPath, function (scopeNode) {
+                    return scopeNode === thisCommonAncestor;
+                });
+                TypeScript.Debug.assert(thisPath.length - thisCommonAncestorIndex === scopeSymbolPath.length - scopeCommonAncestorIndex);
+
+                for (; thisCommonAncestorIndex < thisPath.length; thisCommonAncestorIndex++, scopeCommonAncestorIndex++) {
+                    if (!PullSymbol.unqualifiedNameReferencesDifferentSymbolInScope(thisPath[thisCommonAncestorIndex - 1], scopeSymbolPath, scopeCommonAncestorIndex)) {
+                        break;
+                    }
+                }
+            }
+
+            if (thisCommonAncestorIndex >= 0 && thisCommonAncestorIndex < thisPath.length) {
+                return thisPath.slice(0, thisCommonAncestorIndex);
+            } else {
+                return thisPath;
+            }
+        };
+
+        PullSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) {
+            var str = this.getNameAndTypeName(scopeSymbol);
+            return str;
+        };
+
+        PullSymbol.prototype.getNamePartForFullName = function () {
+            return this.getDisplayName(null, true);
+        };
+
+        PullSymbol.prototype.fullName = function (scopeSymbol) {
+            var _this = this;
+            var path = this.pathToRoot();
+            var fullName = "";
+
+            var aliasFullName = this.getAliasSymbolName(scopeSymbol, function (symbol) {
+                return symbol.fullName(scopeSymbol);
+            }, function (symbol) {
+                return symbol.getNamePartForFullName();
+            });
+            if (aliasFullName) {
+                return aliasFullName;
+            }
+
+            for (var i = 1; i < path.length; i++) {
+                var aliasFullName = path[i].getAliasSymbolName(scopeSymbol, function (symbol) {
+                    return symbol === _this ? null : symbol.fullName(scopeSymbol);
+                }, function (symbol) {
+                    return symbol.getNamePartForFullName();
+                });
+                if (aliasFullName) {
+                    fullName = aliasFullName + "." + fullName;
+                    break;
+                }
+
+                var scopedName = path[i].getNamePartForFullName();
+                if (path[i].kind === 32 /* DynamicModule */ && !TypeScript.isQuoted(scopedName)) {
+                    break;
+                }
+
+                if (scopedName === "") {
+                    break;
+                }
+
+                fullName = scopedName + "." + fullName;
+            }
+
+            fullName = fullName + this.getNamePartForFullName();
+            return fullName;
+        };
+
+        PullSymbol.prototype.getScopedName = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName) {
+            var path = this.findQualifyingSymbolPathInScopeSymbol(scopeSymbol);
+            var fullName = "";
+
+            var aliasFullName = this.getAliasSymbolName(scopeSymbol, function (symbol) {
+                return symbol.getScopedName(scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName);
+            }, function (symbol) {
+                return symbol.getNamePartForFullName();
+            }, skipInternalAliasName);
+            if (aliasFullName) {
+                return aliasFullName;
+            }
+
+            for (var i = 1; i < path.length; i++) {
+                var kind = path[i].kind;
+                if (kind === 4 /* Container */ || kind === 32 /* DynamicModule */) {
+                    var aliasFullName = path[i].getAliasSymbolName(scopeSymbol, function (symbol) {
+                        return symbol.getScopedName(scopeSymbol, skipTypeParametersInName, false, skipInternalAliasName);
+                    }, function (symbol) {
+                        return symbol.getNamePartForFullName();
+                    }, skipInternalAliasName);
+                    if (aliasFullName) {
+                        fullName = aliasFullName + "." + fullName;
+                        break;
+                    }
+
+                    if (kind === 4 /* Container */) {
+                        fullName = path[i].getDisplayName() + "." + fullName;
+                    } else {
+                        var displayName = path[i].getDisplayName();
+                        if (TypeScript.isQuoted(displayName)) {
+                            fullName = displayName + "." + fullName;
+                        }
+                        break;
+                    }
+                } else {
+                    break;
+                }
+            }
+            fullName = fullName + this.getDisplayName(scopeSymbol, useConstraintInName, skipInternalAliasName);
+            return fullName;
+        };
+
+        PullSymbol.prototype.getScopedNameEx = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, getPrettyTypeName, getTypeParamMarkerInfo, skipInternalAliasName) {
+            var name = this.getScopedName(scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName);
+            return TypeScript.MemberName.create(name);
+        };
+
+        PullSymbol.prototype.getTypeName = function (scopeSymbol, getPrettyTypeName) {
+            var memberName = this.getTypeNameEx(scopeSymbol, getPrettyTypeName);
+            return memberName.toString();
+        };
+
+        PullSymbol.prototype.getTypeNameEx = function (scopeSymbol, getPrettyTypeName) {
+            var type = this.type;
+            if (type) {
+                var memberName = getPrettyTypeName ? this.getTypeNameForFunctionSignature("", scopeSymbol, getPrettyTypeName) : null;
+                if (!memberName) {
+                    memberName = type.getScopedNameEx(scopeSymbol, false, true, getPrettyTypeName);
+                }
+
+                return memberName;
+            }
+            return TypeScript.MemberName.create("");
+        };
+
+        PullSymbol.prototype.getTypeNameForFunctionSignature = function (prefix, scopeSymbol, getPrettyTypeName) {
+            var type = this.type;
+            if (type && !type.isNamedTypeSymbol() && this.kind !== 4096 /* Property */ && this.kind !== 512 /* Variable */ && this.kind !== 2048 /* Parameter */) {
+                var signatures = type.getCallSignatures();
+                if (signatures.length === 1 || (getPrettyTypeName && signatures.length)) {
+                    var typeName = new TypeScript.MemberNameArray();
+                    var signatureName = PullSignatureSymbol.getSignaturesTypeNameEx(signatures, prefix, false, false, scopeSymbol, getPrettyTypeName);
+                    typeName.addAll(signatureName);
+                    return typeName;
+                }
+            }
+
+            return null;
+        };
+
+        PullSymbol.prototype.getNameAndTypeName = function (scopeSymbol) {
+            var nameAndTypeName = this.getNameAndTypeNameEx(scopeSymbol);
+            return nameAndTypeName.toString();
+        };
+
+        PullSymbol.prototype.getNameAndTypeNameEx = function (scopeSymbol) {
+            var type = this.type;
+            var nameStr = this.getDisplayName(scopeSymbol);
+            if (type) {
+                nameStr = nameStr + (this.isOptional ? "?" : "");
+                var memberName = this.getTypeNameForFunctionSignature(nameStr, scopeSymbol);
+                if (!memberName) {
+                    var typeNameEx = type.getScopedNameEx(scopeSymbol);
+                    memberName = TypeScript.MemberName.create(typeNameEx, nameStr + ": ", "");
+                }
+                return memberName;
+            }
+            return TypeScript.MemberName.create(nameStr);
+        };
+
+        PullSymbol.getTypeParameterString = function (typars, scopeSymbol, useContraintInName) {
+            return PullSymbol.getTypeParameterStringEx(typars, scopeSymbol, undefined, useContraintInName).toString();
+        };
+
+        PullSymbol.getTypeParameterStringEx = function (typeParameters, scopeSymbol, getTypeParamMarkerInfo, useContraintInName) {
+            var builder = new TypeScript.MemberNameArray();
+            builder.prefix = "";
+
+            if (typeParameters && typeParameters.length) {
+                builder.add(TypeScript.MemberName.create("<"));
+
+                for (var i = 0; i < typeParameters.length; i++) {
+                    if (i) {
+                        builder.add(TypeScript.MemberName.create(", "));
+                    }
+
+                    if (getTypeParamMarkerInfo) {
+                        builder.add(new TypeScript.MemberName());
+                    }
+
+                    builder.add(typeParameters[i].getScopedNameEx(scopeSymbol, false, useContraintInName));
+
+                    if (getTypeParamMarkerInfo) {
+                        builder.add(new TypeScript.MemberName());
+                    }
+                }
+
+                builder.add(TypeScript.MemberName.create(">"));
+            }
+
+            return builder;
+        };
+
+        PullSymbol.getIsExternallyVisible = function (symbol, fromIsExternallyVisibleSymbol, inIsExternallyVisibleSymbols) {
+            if (inIsExternallyVisibleSymbols) {
+                for (var i = 0; i < inIsExternallyVisibleSymbols.length; i++) {
+                    if (inIsExternallyVisibleSymbols[i] === symbol) {
+                        return true;
+                    }
+                }
+            } else {
+                inIsExternallyVisibleSymbols = [];
+            }
+
+            if (fromIsExternallyVisibleSymbol === symbol) {
+                return true;
+            }
+
+            inIsExternallyVisibleSymbols.push(fromIsExternallyVisibleSymbol);
+
+            var result = symbol.isExternallyVisible(inIsExternallyVisibleSymbols);
+
+            TypeScript.Debug.assert(TypeScript.ArrayUtilities.last(inIsExternallyVisibleSymbols) === fromIsExternallyVisibleSymbol);
+            inIsExternallyVisibleSymbols.pop();
+
+            return result;
+        };
+
+        PullSymbol.prototype.isExternallyVisible = function (inIsExternallyVisibleSymbols) {
+            var kind = this.kind;
+            if (kind === 2 /* Primitive */) {
+                return true;
+            }
+
+            if (this.rootSymbol) {
+                return PullSymbol.getIsExternallyVisible(this.rootSymbol, this, inIsExternallyVisibleSymbols);
+            }
+
+            if (this.isType()) {
+                var associatedContainerSymbol = this.getAssociatedContainerType();
+                if (associatedContainerSymbol) {
+                    return PullSymbol.getIsExternallyVisible(associatedContainerSymbol, this, inIsExternallyVisibleSymbols);
+                }
+            }
+
+            if (this.anyDeclHasFlag(2 /* Private */)) {
+                return false;
+            }
+
+            var container = this.getContainer();
+            if (container === null) {
+                var decls = this.getDeclarations();
+                if (decls.length) {
+                    var parentDecl = decls[0].getParentDecl();
+                    if (parentDecl) {
+                        var parentSymbol = parentDecl.getSymbol();
+                        if (!parentSymbol || parentDecl.kind === 1 /* Script */) {
+                            return true;
+                        }
+
+                        return PullSymbol.getIsExternallyVisible(parentSymbol, this, inIsExternallyVisibleSymbols);
+                    }
+                }
+
+                return true;
+            }
+
+            if (container.kind === 32 /* DynamicModule */ || (container.getAssociatedContainerType() && container.getAssociatedContainerType().kind === 32 /* DynamicModule */)) {
+                var containerSymbol = container.kind === 32 /* DynamicModule */ ? container : container.getAssociatedContainerType();
+                if (PullContainerSymbol.usedAsSymbol(containerSymbol, this)) {
+                    return true;
+                }
+            }
+
+            if (!this.anyDeclHasFlag(1 /* Exported */) && kind !== 4096 /* Property */ && kind !== 65536 /* Method */) {
+                return false;
+            }
+
+            return PullSymbol.getIsExternallyVisible(container, this, inIsExternallyVisibleSymbols);
+        };
+
+        PullSymbol.prototype.getDocCommentsOfDecl = function (decl) {
+            var ast = decl.ast();
+
+            if (ast) {
+                var enclosingModuleDeclaration = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(ast);
+                if (TypeScript.ASTHelpers.isLastNameOfModule(enclosingModuleDeclaration, ast)) {
+                    return TypeScript.ASTHelpers.docComments(enclosingModuleDeclaration);
+                }
+
+                if (ast.kind() !== 130 /* ModuleDeclaration */ || decl.kind !== 512 /* Variable */) {
+                    return TypeScript.ASTHelpers.docComments(ast);
+                }
+            }
+
+            return [];
+        };
+
+        PullSymbol.prototype.getDocCommentArray = function (symbol) {
+            var docComments = [];
+            if (!symbol) {
+                return docComments;
+            }
+
+            var isParameter = symbol.kind === 2048 /* Parameter */;
+            var decls = symbol.getDeclarations();
+            for (var i = 0; i < decls.length; i++) {
+                if (isParameter && decls[i].kind === 4096 /* Property */) {
+                    continue;
+                }
+                docComments = docComments.concat(this.getDocCommentsOfDecl(decls[i]));
+            }
+            return docComments;
+        };
+
+        PullSymbol.getDefaultConstructorSymbolForDocComments = function (classSymbol) {
+            if (classSymbol.getHasDefaultConstructor()) {
+                var extendedTypes = classSymbol.getExtendedTypes();
+                if (extendedTypes.length) {
+                    return PullSymbol.getDefaultConstructorSymbolForDocComments(extendedTypes[0]);
+                }
+            }
+
+            return classSymbol.type.getConstructSignatures()[0];
+        };
+
+        PullSymbol.prototype.getDocCommentText = function (comments) {
+            var docCommentText = new Array();
+            for (var c = 0; c < comments.length; c++) {
+                var commentText = this.getDocCommentTextValue(comments[c]);
+                if (commentText !== "") {
+                    docCommentText.push(commentText);
+                }
+            }
+            return docCommentText.join("\n");
+        };
+
+        PullSymbol.prototype.getDocCommentTextValue = function (comment) {
+            return this.cleanJSDocComment(comment.fullText());
+        };
+
+        PullSymbol.prototype.docComments = function (useConstructorAsClass) {
+            var decls = this.getDeclarations();
+            if (useConstructorAsClass && decls.length && decls[0].kind === 32768 /* ConstructorMethod */) {
+                var classDecl = decls[0].getParentDecl();
+                return this.getDocCommentText(this.getDocCommentsOfDecl(classDecl));
+            }
+
+            if (this._docComments === null) {
+                var docComments = "";
+                if (!useConstructorAsClass && this.kind === 2097152 /* ConstructSignature */ && decls.length && decls[0].kind === 8 /* Class */) {
+                    var classSymbol = this.returnType;
+                    var extendedTypes = classSymbol.getExtendedTypes();
+                    if (extendedTypes.length) {
+                        docComments = extendedTypes[0].getConstructorMethod().docComments();
+                    } else {
+                        docComments = "";
+                    }
+                } else if (this.kind === 2048 /* Parameter */) {
+                    var parameterComments = [];
+
+                    var funcContainer = this.getEnclosingSignature();
+                    var funcDocComments = this.getDocCommentArray(funcContainer);
+                    var paramComment = this.getParameterDocCommentText(this.getDisplayName(), funcDocComments);
+                    if (paramComment != "") {
+                        parameterComments.push(paramComment);
+                    }
+
+                    var paramSelfComment = this.getDocCommentText(this.getDocCommentArray(this));
+                    if (paramSelfComment != "") {
+                        parameterComments.push(paramSelfComment);
+                    }
+                    docComments = parameterComments.join("\n");
+                } else {
+                    var getSymbolComments = true;
+                    if (this.kind === 16777216 /* FunctionType */) {
+                        var functionSymbol = this.getFunctionSymbol();
+
+                        if (functionSymbol) {
+                            docComments = functionSymbol._docComments || "";
+                            getSymbolComments = false;
+                        } else {
+                            var declarationList = this.getDeclarations();
+                            if (declarationList.length > 0) {
+                                docComments = declarationList[0].getSymbol()._docComments || "";
+                                getSymbolComments = false;
+                            }
+                        }
+                    }
+                    if (getSymbolComments) {
+                        docComments = this.getDocCommentText(this.getDocCommentArray(this));
+                        if (docComments === "") {
+                            if (this.kind === 1048576 /* CallSignature */) {
+                                var callTypeSymbol = this.functionType;
+                                if (callTypeSymbol && callTypeSymbol.getCallSignatures().length === 1) {
+                                    docComments = callTypeSymbol.docComments();
+                                }
+                            }
+                        }
+                    }
+                }
+
+                this._docComments = docComments;
+            }
+
+            return this._docComments;
+        };
+
+        PullSymbol.prototype.getParameterDocCommentText = function (param, fncDocComments) {
+            if (fncDocComments.length === 0 || fncDocComments[0].kind() !== 6 /* MultiLineCommentTrivia */) {
+                return "";
+            }
+
+            for (var i = 0; i < fncDocComments.length; i++) {
+                var commentContents = fncDocComments[i].fullText();
+                for (var j = commentContents.indexOf("@param", 0); 0 <= j; j = commentContents.indexOf("@param", j)) {
+                    j += 6;
+                    if (!this.isSpaceChar(commentContents, j)) {
+                        continue;
+                    }
+
+                    j = this.consumeLeadingSpace(commentContents, j);
+                    if (j === -1) {
+                        break;
+                    }
+
+                    if (commentContents.charCodeAt(j) === 123 /* openBrace */) {
+                        j++;
+
+                        var charCode = 0;
+                        for (var curlies = 1; j < commentContents.length; j++) {
+                            charCode = commentContents.charCodeAt(j);
+
+                            if (charCode === 123 /* openBrace */) {
+                                curlies++;
+                                continue;
+                            }
+
+                            if (charCode === 125 /* closeBrace */) {
+                                curlies--;
+                                if (curlies === 0) {
+                                    break;
+                                } else {
+                                    continue;
+                                }
+                            }
+
+                            if (charCode === 64 /* at */) {
+                                break;
+                            }
+                        }
+
+                        if (j === commentContents.length) {
+                            break;
+                        }
+
+                        if (charCode === 64 /* at */) {
+                            continue;
+                        }
+
+                        j = this.consumeLeadingSpace(commentContents, j + 1);
+                        if (j === -1) {
+                            break;
+                        }
+                    }
+
+                    if (param !== commentContents.substr(j, param.length) || !this.isSpaceChar(commentContents, j + param.length)) {
+                        continue;
+                    }
+
+                    j = this.consumeLeadingSpace(commentContents, j + param.length);
+                    if (j === -1) {
+                        return "";
+                    }
+
+                    var endOfParam = commentContents.indexOf("@", j);
+                    var paramHelpString = commentContents.substring(j, endOfParam < 0 ? commentContents.length : endOfParam);
+
+                    var paramSpacesToRemove = undefined;
+                    var paramLineIndex = commentContents.substring(0, j).lastIndexOf("\n") + 1;
+                    if (paramLineIndex !== 0) {
+                        if (paramLineIndex < j && commentContents.charAt(paramLineIndex + 1) === "\r") {
+                            paramLineIndex++;
+                        }
+                    }
+                    var startSpaceRemovalIndex = this.consumeLeadingSpace(commentContents, paramLineIndex);
+                    if (startSpaceRemovalIndex !== j && commentContents.charAt(startSpaceRemovalIndex) === "*") {
+                        paramSpacesToRemove = j - startSpaceRemovalIndex - 1;
+                    }
+
+                    return this.cleanJSDocComment(paramHelpString, paramSpacesToRemove);
+                }
+            }
+
+            return "";
+        };
+
+        PullSymbol.prototype.cleanJSDocComment = function (content, spacesToRemove) {
+            var docCommentLines = new Array();
+            content = content.replace("/**", "");
+            if (content.length >= 2 && content.charAt(content.length - 1) === "/" && content.charAt(content.length - 2) === "*") {
+                content = content.substring(0, content.length - 2);
+            }
+            var lines = content.split("\n");
+            var inParamTag = false;
+            for (var l = 0; l < lines.length; l++) {
+                var line = lines[l];
+                var cleanLinePos = this.cleanDocCommentLine(line, true, spacesToRemove);
+                if (!cleanLinePos) {
+                    continue;
+                }
+
+                var docCommentText = "";
+                var prevPos = cleanLinePos.start;
+                for (var i = line.indexOf("@", cleanLinePos.start); 0 <= i && i < cleanLinePos.end; i = line.indexOf("@", i + 1)) {
+                    var wasInParamtag = inParamTag;
+
+                    if (line.indexOf("param", i + 1) === i + 1 && this.isSpaceChar(line, i + 6)) {
+                        if (!wasInParamtag) {
+                            docCommentText += line.substring(prevPos, i);
+                        }
+
+                        prevPos = i;
+                        inParamTag = true;
+                    } else if (wasInParamtag) {
+                        prevPos = i;
+                        inParamTag = false;
+                    }
+                }
+
+                if (!inParamTag) {
+                    docCommentText += line.substring(prevPos, cleanLinePos.end);
+                }
+
+                var newCleanPos = this.cleanDocCommentLine(docCommentText, false);
+                if (newCleanPos) {
+                    if (spacesToRemove === undefined) {
+                        spacesToRemove = cleanLinePos.jsDocSpacesRemoved;
+                    }
+                    docCommentLines.push(docCommentText);
+                }
+            }
+
+            return docCommentLines.join("\n");
+        };
+
+        PullSymbol.prototype.consumeLeadingSpace = function (line, startIndex, maxSpacesToRemove) {
+            var endIndex = line.length;
+            if (maxSpacesToRemove !== undefined) {
+                endIndex = TypeScript.MathPrototype.min(startIndex + maxSpacesToRemove, endIndex);
+            }
+
+            for (; startIndex < endIndex; startIndex++) {
+                var charCode = line.charCodeAt(startIndex);
+                if (charCode !== 32 /* space */ && charCode !== 9 /* tab */) {
+                    return startIndex;
+                }
+            }
+
+            if (endIndex !== line.length) {
+                return endIndex;
+            }
+
+            return -1;
+        };
+
+        PullSymbol.prototype.isSpaceChar = function (line, index) {
+            var length = line.length;
+            if (index < length) {
+                var charCode = line.charCodeAt(index);
+
+                return charCode === 32 /* space */ || charCode === 9 /* tab */;
+            }
+
+            return index === length;
+        };
+
+        PullSymbol.prototype.cleanDocCommentLine = function (line, jsDocStyleComment, jsDocLineSpaceToRemove) {
+            var nonSpaceIndex = this.consumeLeadingSpace(line, 0);
+            if (nonSpaceIndex !== -1) {
+                var jsDocSpacesRemoved = nonSpaceIndex;
+                if (jsDocStyleComment && line.charAt(nonSpaceIndex) === '*') {
+                    var startIndex = nonSpaceIndex + 1;
+                    nonSpaceIndex = this.consumeLeadingSpace(line, startIndex, jsDocLineSpaceToRemove);
+
+                    if (nonSpaceIndex !== -1) {
+                        jsDocSpacesRemoved = nonSpaceIndex - startIndex;
+                    } else {
+                        return null;
+                    }
+                }
+
+                return {
+                    start: nonSpaceIndex,
+                    end: line.charAt(line.length - 1) === "\r" ? line.length - 1 : line.length,
+                    jsDocSpacesRemoved: jsDocSpacesRemoved
+                };
+            }
+
+            return null;
+        };
+        return PullSymbol;
+    })();
+    TypeScript.PullSymbol = PullSymbol;
+
+    
+
+    var PullSignatureSymbol = (function (_super) {
+        __extends(PullSignatureSymbol, _super);
+        function PullSignatureSymbol(kind, _isDefinition) {
+            if (typeof _isDefinition === "undefined") { _isDefinition = false; }
+            _super.call(this, "", kind);
+            this._isDefinition = _isDefinition;
+            this._memberTypeParameterNameCache = null;
+            this._stringConstantOverload = undefined;
+            this.parameters = TypeScript.sentinelEmptyArray;
+            this._typeParameters = null;
+            this.returnType = null;
+            this.functionType = null;
+            this.hasOptionalParam = false;
+            this.nonOptionalParamCount = 0;
+            this.hasVarArgs = false;
+            this._allowedToReferenceTypeParameters = null;
+            this._instantiationCache = null;
+            this.hasBeenChecked = false;
+            this.inWrapCheck = false;
+            this.inWrapInfiniteExpandingReferenceCheck = false;
+        }
+        PullSignatureSymbol.prototype.isDefinition = function () {
+            return this._isDefinition;
+        };
+
+        PullSignatureSymbol.prototype.isGeneric = function () {
+            var typeParameters = this.getTypeParameters();
+            return !!typeParameters && typeParameters.length !== 0;
+        };
+
+        PullSignatureSymbol.prototype.addParameter = function (parameter, isOptional) {
+            if (typeof isOptional === "undefined") { isOptional = false; }
+            if (this.parameters === TypeScript.sentinelEmptyArray) {
+                this.parameters = [];
+            }
+
+            this.parameters[this.parameters.length] = parameter;
+            this.hasOptionalParam = isOptional;
+
+            if (!parameter.getEnclosingSignature()) {
+                parameter.setEnclosingSignature(this);
+            }
+
+            if (!isOptional) {
+                this.nonOptionalParamCount++;
+            }
+        };
+
+        PullSignatureSymbol.prototype.addTypeParameter = function (typeParameter) {
+            if (!this._typeParameters) {
+                this._typeParameters = [];
+            }
+
+            if (!this._memberTypeParameterNameCache) {
+                this._memberTypeParameterNameCache = TypeScript.createIntrinsicsObject();
+            }
+
+            this._typeParameters[this._typeParameters.length] = typeParameter;
+
+            this._memberTypeParameterNameCache[typeParameter.getName()] = typeParameter;
+        };
+
+        PullSignatureSymbol.prototype.addTypeParametersFromReturnType = function () {
+            var typeParameters = this.returnType.getTypeParameters();
+            for (var i = 0; i < typeParameters.length; i++) {
+                this.addTypeParameter(typeParameters[i]);
+            }
+        };
+
+        PullSignatureSymbol.prototype.getTypeParameters = function () {
+            if (!this._typeParameters) {
+                this._typeParameters = [];
+            }
+
+            return this._typeParameters;
+        };
+
+        PullSignatureSymbol.prototype.findTypeParameter = function (name) {
+            var memberSymbol;
+
+            if (!this._memberTypeParameterNameCache) {
+                this._memberTypeParameterNameCache = TypeScript.createIntrinsicsObject();
+
+                for (var i = 0; i < this.getTypeParameters().length; i++) {
+                    this._memberTypeParameterNameCache[this._typeParameters[i].getName()] = this._typeParameters[i];
+                }
+            }
+
+            memberSymbol = this._memberTypeParameterNameCache[name];
+
+            return memberSymbol;
+        };
+
+        PullSignatureSymbol.prototype.getTypeParameterArgumentMap = function () {
+            return null;
+        };
+
+        PullSignatureSymbol.prototype.getAllowedToReferenceTypeParameters = function () {
+            TypeScript.Debug.assert(this.getRootSymbol() == this);
+            if (!this._allowedToReferenceTypeParameters) {
+                this._allowedToReferenceTypeParameters = TypeScript.PullInstantiationHelpers.getAllowedToReferenceTypeParametersFromDecl(this.getDeclarations()[0]);
+            }
+
+            return this._allowedToReferenceTypeParameters;
+        };
+
+        PullSignatureSymbol.prototype.addSpecialization = function (specializedVersionOfThisSignature, typeArgumentMap) {
+            TypeScript.Debug.assert(this.getRootSymbol() == this);
+            if (!this._instantiationCache) {
+                this._instantiationCache = TypeScript.createIntrinsicsObject();
+            }
+
+            this._instantiationCache[getIDForTypeSubstitutions(this, typeArgumentMap)] = specializedVersionOfThisSignature;
+        };
+
+        PullSignatureSymbol.prototype.getSpecialization = function (typeArgumentMap) {
+            TypeScript.Debug.assert(this.getRootSymbol() == this);
+            if (!this._instantiationCache) {
+                return null;
+            }
+
+            var result = this._instantiationCache[getIDForTypeSubstitutions(this, typeArgumentMap)];
+            return result || null;
+        };
+
+        PullSignatureSymbol.prototype.isStringConstantOverloadSignature = function () {
+            if (this._stringConstantOverload === undefined) {
+                var params = this.parameters;
+                this._stringConstantOverload = false;
+                for (var i = 0; i < params.length; i++) {
+                    var paramType = params[i].type;
+                    if (paramType && paramType.isPrimitive() && paramType.isStringConstant()) {
+                        this._stringConstantOverload = true;
+                    }
+                }
+            }
+
+            return this._stringConstantOverload;
+        };
+
+        PullSignatureSymbol.prototype.getParameterTypeAtIndex = function (iParam) {
+            if (iParam < this.parameters.length - 1 || (iParam < this.parameters.length && !this.hasVarArgs)) {
+                return this.parameters[iParam].type;
+            } else if (this.hasVarArgs) {
+                var paramType = this.parameters[this.parameters.length - 1].type;
+                if (paramType.isArrayNamedTypeReference()) {
+                    paramType = paramType.getElementType();
+                }
+                return paramType;
+            }
+
+            return null;
+        };
+
+        PullSignatureSymbol.getSignatureTypeMemberName = function (candidateSignature, signatures, scopeSymbol) {
+            var allMemberNames = new TypeScript.MemberNameArray();
+            var signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(signatures, "", false, false, scopeSymbol, true, candidateSignature);
+            allMemberNames.addAll(signatureMemberName);
+            return allMemberNames;
+        };
+
+        PullSignatureSymbol.getSignaturesTypeNameEx = function (signatures, prefix, shortform, brackets, scopeSymbol, getPrettyTypeName, candidateSignature) {
+            var result = [];
+            if (!signatures) {
+                return result;
+            }
+
+            var len = signatures.length;
+            if (!getPrettyTypeName && len > 1) {
+                shortform = false;
+            }
+
+            var foundDefinition = false;
+            if (candidateSignature && candidateSignature.isDefinition() && len > 1) {
+                candidateSignature = null;
+            }
+
+            for (var i = 0; i < len; i++) {
+                if (len > 1 && signatures[i].isDefinition()) {
+                    foundDefinition = true;
+                    continue;
+                }
+
+                var signature = signatures[i];
+                if (getPrettyTypeName && candidateSignature) {
+                    signature = candidateSignature;
+                }
+
+                result.push(signature.getSignatureTypeNameEx(prefix, shortform, brackets, scopeSymbol));
+                if (getPrettyTypeName) {
+                    break;
+                }
+            }
+
+            if (getPrettyTypeName && result.length && len > 1) {
+                var lastMemberName = result[result.length - 1];
+                for (var i = i + 1; i < len; i++) {
+                    if (signatures[i].isDefinition()) {
+                        foundDefinition = true;
+                        break;
+                    }
+                }
+                var overloadString = TypeScript.getLocalizedText(TypeScript.DiagnosticCode._0_overload_s, [foundDefinition ? len - 2 : len - 1]);
+                lastMemberName.add(TypeScript.MemberName.create(overloadString));
+            }
+
+            return result;
+        };
+
+        PullSignatureSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) {
+            var s = this.getSignatureTypeNameEx(this.getScopedNameEx().toString(), false, false, scopeSymbol, undefined, useConstraintInName).toString();
+            return s;
+        };
+
+        PullSignatureSymbol.prototype.getSignatureTypeNameEx = function (prefix, shortform, brackets, scopeSymbol, getParamMarkerInfo, getTypeParamMarkerInfo) {
+            var typeParamterBuilder = new TypeScript.MemberNameArray();
+
+            typeParamterBuilder.add(PullSymbol.getTypeParameterStringEx(this.getTypeParameters(), scopeSymbol, getTypeParamMarkerInfo, true));
+
+            if (brackets) {
+                typeParamterBuilder.add(TypeScript.MemberName.create("["));
+            } else {
+                typeParamterBuilder.add(TypeScript.MemberName.create("("));
+            }
+
+            var builder = new TypeScript.MemberNameArray();
+            builder.prefix = prefix;
+
+            if (getTypeParamMarkerInfo) {
+                builder.prefix = prefix;
+                builder.addAll(typeParamterBuilder.entries);
+            } else {
+                builder.prefix = prefix + typeParamterBuilder.toString();
+            }
+
+            var params = this.parameters;
+            var paramLen = params.length;
+            for (var i = 0; i < paramLen; i++) {
+                var paramType = params[i].type;
+                var typeString = paramType ? ": " : "";
+                var paramIsVarArg = params[i].isVarArg;
+                var varArgPrefix = paramIsVarArg ? "..." : "";
+                var optionalString = (!paramIsVarArg && params[i].isOptional) ? "?" : "";
+                if (getParamMarkerInfo) {
+                    builder.add(new TypeScript.MemberName());
+                }
+                builder.add(TypeScript.MemberName.create(varArgPrefix + params[i].getScopedNameEx(scopeSymbol).toString() + optionalString + typeString));
+                if (paramType) {
+                    builder.add(paramType.getScopedNameEx(scopeSymbol));
+                }
+                if (getParamMarkerInfo) {
+                    builder.add(new TypeScript.MemberName());
+                }
+                if (i < paramLen - 1) {
+                    builder.add(TypeScript.MemberName.create(", "));
+                }
+            }
+
+            if (shortform) {
+                if (brackets) {
+                    builder.add(TypeScript.MemberName.create("] => "));
+                } else {
+                    builder.add(TypeScript.MemberName.create(") => "));
+                }
+            } else {
+                if (brackets) {
+                    builder.add(TypeScript.MemberName.create("]: "));
+                } else {
+                    builder.add(TypeScript.MemberName.create("): "));
+                }
+            }
+
+            if (this.returnType) {
+                builder.add(this.returnType.getScopedNameEx(scopeSymbol));
+            } else {
+                builder.add(TypeScript.MemberName.create("any"));
+            }
+
+            return builder;
+        };
+
+        PullSignatureSymbol.prototype.forAllParameterTypes = function (length, predicate) {
+            if (this.parameters.length < length && !this.hasVarArgs) {
+                length = this.parameters.length;
+            }
+
+            for (var i = 0; i < length; i++) {
+                var paramType = this.getParameterTypeAtIndex(i);
+                if (!predicate(paramType, i)) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullSignatureSymbol.prototype.forAllCorrespondingParameterTypesInThisAndOtherSignature = function (otherSignature, predicate) {
+            var length;
+            if (this.hasVarArgs) {
+                length = otherSignature.hasVarArgs ? Math.max(this.parameters.length, otherSignature.parameters.length) : otherSignature.parameters.length;
+            } else {
+                length = otherSignature.hasVarArgs ? this.parameters.length : Math.min(this.parameters.length, otherSignature.parameters.length);
+            }
+
+            for (var i = 0; i < length; i++) {
+                var thisParamType = this.getParameterTypeAtIndex(i);
+                var otherParamType = otherSignature.getParameterTypeAtIndex(i);
+                if (!predicate(thisParamType, otherParamType, i)) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullSignatureSymbol.prototype.wrapsSomeTypeParameter = function (typeParameterArgumentMap) {
+            return this.getWrappingTypeParameterID(typeParameterArgumentMap) !== 0;
+        };
+
+        PullSignatureSymbol.prototype.getWrappingTypeParameterID = function (typeParameterArgumentMap) {
+            var signature = this;
+            if (signature.inWrapCheck) {
+                return 0;
+            }
+
+            this._wrapsTypeParameterCache = this._wrapsTypeParameterCache || new TypeScript.WrapsTypeParameterCache();
+
+            var wrappingTypeParameterID = this._wrapsTypeParameterCache.getWrapsTypeParameter(typeParameterArgumentMap);
+            if (wrappingTypeParameterID === undefined) {
+                wrappingTypeParameterID = this.getWrappingTypeParameterIDWorker(typeParameterArgumentMap);
+                this._wrapsTypeParameterCache.setWrapsTypeParameter(typeParameterArgumentMap, wrappingTypeParameterID);
+            }
+
+            return wrappingTypeParameterID;
+        };
+
+        PullSignatureSymbol.prototype.getWrappingTypeParameterIDWorker = function (typeParameterArgumentMap) {
+            var signature = this;
+            signature.inWrapCheck = true;
+            TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(signature);
+            var wrappingTypeParameterID = signature.returnType ? signature.returnType.getWrappingTypeParameterID(typeParameterArgumentMap) : 0;
+
+            var parameters = signature.parameters;
+            for (var i = 0; !wrappingTypeParameterID && i < parameters.length; i++) {
+                TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(parameters[i]);
+                wrappingTypeParameterID = parameters[i].type.getWrappingTypeParameterID(typeParameterArgumentMap);
+            }
+
+            signature.inWrapCheck = false;
+
+            return wrappingTypeParameterID;
+        };
+
+        PullSignatureSymbol.prototype._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReference = function (enclosingType, knownWrapMap) {
+            var wrapsIntoInfinitelyExpandingTypeReference = knownWrapMap.valueAt(this.pullSymbolID, enclosingType.pullSymbolID);
+            if (wrapsIntoInfinitelyExpandingTypeReference != undefined) {
+                return wrapsIntoInfinitelyExpandingTypeReference;
+            }
+
+            if (this.inWrapInfiniteExpandingReferenceCheck) {
+                return false;
+            }
+
+            this.inWrapInfiniteExpandingReferenceCheck = true;
+            wrapsIntoInfinitelyExpandingTypeReference = this._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceWorker(enclosingType, knownWrapMap);
+            knownWrapMap.setValueAt(this.pullSymbolID, enclosingType.pullSymbolID, wrapsIntoInfinitelyExpandingTypeReference);
+            this.inWrapInfiniteExpandingReferenceCheck = false;
+
+            return wrapsIntoInfinitelyExpandingTypeReference;
+        };
+
+        PullSignatureSymbol.prototype._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceWorker = function (enclosingType, knownWrapMap) {
+            if (this.returnType && this.returnType._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceRecurse(enclosingType, knownWrapMap)) {
+                return true;
+            }
+
+            var parameters = this.parameters;
+
+            for (var i = 0; i < parameters.length; i++) {
+                if (parameters[i].type && parameters[i].type._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceRecurse(enclosingType, knownWrapMap)) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+        return PullSignatureSymbol;
+    })(PullSymbol);
+    TypeScript.PullSignatureSymbol = PullSignatureSymbol;
+
+    var PullTypeSymbol = (function (_super) {
+        __extends(PullTypeSymbol, _super);
+        function PullTypeSymbol(name, kind) {
+            _super.call(this, name, kind);
+            this._members = TypeScript.sentinelEmptyArray;
+            this._enclosedMemberTypes = null;
+            this._enclosedMemberContainers = null;
+            this._typeParameters = null;
+            this._allowedToReferenceTypeParameters = null;
+            this._specializedVersionsOfThisType = null;
+            this._arrayVersionOfThisType = null;
+            this._implementedTypes = null;
+            this._extendedTypes = null;
+            this._typesThatExplicitlyImplementThisType = null;
+            this._typesThatExtendThisType = null;
+            this._callSignatures = null;
+            this._allCallSignatures = null;
+            this._constructSignatures = null;
+            this._allConstructSignatures = null;
+            this._indexSignatures = null;
+            this._allIndexSignatures = null;
+            this._allIndexSignaturesOfAugmentedType = null;
+            this._memberNameCache = null;
+            this._enclosedTypeNameCache = null;
+            this._enclosedContainerCache = null;
+            this._typeParameterNameCache = null;
+            this._containedNonMemberNameCache = null;
+            this._containedNonMemberTypeNameCache = null;
+            this._containedNonMemberContainerCache = null;
+            this._simpleInstantiationCache = null;
+            this._complexInstantiationCache = null;
+            this._hasGenericSignature = false;
+            this._hasGenericMember = false;
+            this._hasBaseTypeConflict = false;
+            this._knownBaseTypeCount = 0;
+            this._associatedContainerTypeSymbol = null;
+            this._constructorMethod = null;
+            this._hasDefaultConstructor = false;
+            this._functionSymbol = null;
+            this._inMemberTypeNameEx = false;
+            this.inSymbolPrivacyCheck = false;
+            this.inWrapCheck = false;
+            this.inWrapInfiniteExpandingReferenceCheck = false;
+            this.typeReference = null;
+            this._widenedType = null;
+            this._isArrayNamedTypeReference = undefined;
+            this.type = this;
+        }
+        PullTypeSymbol.prototype.isArrayNamedTypeReference = function () {
+            if (this._isArrayNamedTypeReference === undefined) {
+                this._isArrayNamedTypeReference = this.computeIsArrayNamedTypeReference();
+            }
+
+            return this._isArrayNamedTypeReference;
+        };
+
+        PullTypeSymbol.prototype.computeIsArrayNamedTypeReference = function () {
+            var typeArgs = this.getTypeArguments();
+            if (typeArgs && this.getTypeArguments().length === 1 && this.name === "Array") {
+                var declaration = this.getDeclarations()[0];
+
+                if (declaration && declaration.getParentDecl() && declaration.getParentDecl().getParentDecl() === null) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeSymbol.prototype.isType = function () {
+            return true;
+        };
+        PullTypeSymbol.prototype.isClass = function () {
+            return this.kind === 8 /* Class */ || (this._constructorMethod !== null);
+        };
+        PullTypeSymbol.prototype.isFunction = function () {
+            return (this.kind & (33554432 /* ConstructorType */ | 16777216 /* FunctionType */)) !== 0;
+        };
+        PullTypeSymbol.prototype.isConstructor = function () {
+            return this.kind === 33554432 /* ConstructorType */ || (this._associatedContainerTypeSymbol && this._associatedContainerTypeSymbol.isClass());
+        };
+        PullTypeSymbol.prototype.isTypeParameter = function () {
+            return false;
+        };
+        PullTypeSymbol.prototype.isTypeVariable = function () {
+            return false;
+        };
+        PullTypeSymbol.prototype.isError = function () {
+            return false;
+        };
+        PullTypeSymbol.prototype.isEnum = function () {
+            return this.kind === 64 /* Enum */;
+        };
+
+        PullTypeSymbol.prototype.getTypeParameterArgumentMap = function () {
+            return null;
+        };
+
+        PullTypeSymbol.prototype.isObject = function () {
+            return TypeScript.hasFlag(this.kind, 8 /* Class */ | 33554432 /* ConstructorType */ | 64 /* Enum */ | 16777216 /* FunctionType */ | 16 /* Interface */ | 8388608 /* ObjectType */ | 256 /* ObjectLiteral */);
+        };
+
+        PullTypeSymbol.prototype.isFunctionType = function () {
+            return this.getCallSignatures().length > 0 || this.getConstructSignatures().length > 0;
+        };
+
+        PullTypeSymbol.prototype.getKnownBaseTypeCount = function () {
+            return this._knownBaseTypeCount;
+        };
+        PullTypeSymbol.prototype.resetKnownBaseTypeCount = function () {
+            this._knownBaseTypeCount = 0;
+        };
+        PullTypeSymbol.prototype.incrementKnownBaseCount = function () {
+            this._knownBaseTypeCount++;
+        };
+
+        PullTypeSymbol.prototype.setHasBaseTypeConflict = function () {
+            this._hasBaseTypeConflict = true;
+        };
+        PullTypeSymbol.prototype.hasBaseTypeConflict = function () {
+            return this._hasBaseTypeConflict;
+        };
+
+        PullTypeSymbol.prototype.hasMembers = function () {
+            if (this._members !== TypeScript.sentinelEmptyArray) {
+                return true;
+            }
+
+            var parents = this.getExtendedTypes();
+
+            for (var i = 0; i < parents.length; i++) {
+                if (parents[i].hasMembers()) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeSymbol.prototype.setHasGenericSignature = function () {
+            this._hasGenericSignature = true;
+        };
+        PullTypeSymbol.prototype.getHasGenericSignature = function () {
+            return this._hasGenericSignature;
+        };
+
+        PullTypeSymbol.prototype.setHasGenericMember = function () {
+            this._hasGenericMember = true;
+        };
+        PullTypeSymbol.prototype.getHasGenericMember = function () {
+            return this._hasGenericMember;
+        };
+
+        PullTypeSymbol.prototype.setAssociatedContainerType = function (type) {
+            this._associatedContainerTypeSymbol = type;
+        };
+
+        PullTypeSymbol.prototype.getAssociatedContainerType = function () {
+            return this._associatedContainerTypeSymbol;
+        };
+
+        PullTypeSymbol.prototype.getArrayType = function () {
+            return this._arrayVersionOfThisType;
+        };
+
+        PullTypeSymbol.prototype.getElementType = function () {
+            return null;
+        };
+
+        PullTypeSymbol.prototype.setArrayType = function (arrayType) {
+            this._arrayVersionOfThisType = arrayType;
+        };
+
+        PullTypeSymbol.prototype.getFunctionSymbol = function () {
+            return this._functionSymbol;
+        };
+
+        PullTypeSymbol.prototype.setFunctionSymbol = function (symbol) {
+            if (symbol) {
+                this._functionSymbol = symbol;
+            }
+        };
+
+        PullTypeSymbol.prototype.findContainedNonMember = function (name) {
+            if (!this._containedNonMemberNameCache) {
+                return null;
+            }
+
+            return this._containedNonMemberNameCache[name];
+        };
+
+        PullTypeSymbol.prototype.findContainedNonMemberType = function (typeName, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            if (!this._containedNonMemberTypeNameCache) {
+                return null;
+            }
+
+            var nonMemberSymbol = this._containedNonMemberTypeNameCache[typeName];
+
+            if (nonMemberSymbol && kind !== 0 /* None */) {
+                nonMemberSymbol = TypeScript.hasFlag(nonMemberSymbol.kind, kind) ? nonMemberSymbol : null;
+            }
+
+            return nonMemberSymbol;
+        };
+
+        PullTypeSymbol.prototype.findContainedNonMemberContainer = function (containerName, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            if (!this._containedNonMemberContainerCache) {
+                return null;
+            }
+
+            var nonMemberSymbol = this._containedNonMemberContainerCache[containerName];
+
+            if (nonMemberSymbol && kind !== 0 /* None */) {
+                nonMemberSymbol = TypeScript.hasFlag(nonMemberSymbol.kind, kind) ? nonMemberSymbol : null;
+            }
+
+            return nonMemberSymbol;
+        };
+
+        PullTypeSymbol.prototype.addMember = function (memberSymbol) {
+            if (!memberSymbol) {
+                return;
+            }
+
+            memberSymbol.setContainer(this);
+
+            if (!this._memberNameCache) {
+                this._memberNameCache = TypeScript.createIntrinsicsObject();
+            }
+
+            if (this._members === TypeScript.sentinelEmptyArray) {
+                this._members = [];
+            }
+
+            this._members.push(memberSymbol);
+            this._memberNameCache[memberSymbol.name] = memberSymbol;
+        };
+
+        PullTypeSymbol.prototype.addEnclosedMemberType = function (enclosedType) {
+            if (!enclosedType) {
+                return;
+            }
+
+            enclosedType.setContainer(this);
+
+            if (!this._enclosedTypeNameCache) {
+                this._enclosedTypeNameCache = TypeScript.createIntrinsicsObject();
+            }
+
+            if (!this._enclosedMemberTypes) {
+                this._enclosedMemberTypes = [];
+            }
+
+            this._enclosedMemberTypes[this._enclosedMemberTypes.length] = enclosedType;
+            this._enclosedTypeNameCache[enclosedType.name] = enclosedType;
+        };
+
+        PullTypeSymbol.prototype.addEnclosedMemberContainer = function (enclosedContainer) {
+            if (!enclosedContainer) {
+                return;
+            }
+
+            enclosedContainer.setContainer(this);
+
+            if (!this._enclosedContainerCache) {
+                this._enclosedContainerCache = TypeScript.createIntrinsicsObject();
+            }
+
+            if (!this._enclosedMemberContainers) {
+                this._enclosedMemberContainers = [];
+            }
+
+            this._enclosedMemberContainers[this._enclosedMemberContainers.length] = enclosedContainer;
+            this._enclosedContainerCache[enclosedContainer.name] = enclosedContainer;
+        };
+
+        PullTypeSymbol.prototype.addEnclosedNonMember = function (enclosedNonMember) {
+            if (!enclosedNonMember) {
+                return;
+            }
+
+            enclosedNonMember.setContainer(this);
+
+            if (!this._containedNonMemberNameCache) {
+                this._containedNonMemberNameCache = TypeScript.createIntrinsicsObject();
+            }
+
+            this._containedNonMemberNameCache[enclosedNonMember.name] = enclosedNonMember;
+        };
+
+        PullTypeSymbol.prototype.addEnclosedNonMemberType = function (enclosedNonMemberType) {
+            if (!enclosedNonMemberType) {
+                return;
+            }
+
+            enclosedNonMemberType.setContainer(this);
+
+            if (!this._containedNonMemberTypeNameCache) {
+                this._containedNonMemberTypeNameCache = TypeScript.createIntrinsicsObject();
+            }
+
+            this._containedNonMemberTypeNameCache[enclosedNonMemberType.name] = enclosedNonMemberType;
+        };
+
+        PullTypeSymbol.prototype.addEnclosedNonMemberContainer = function (enclosedNonMemberContainer) {
+            if (!enclosedNonMemberContainer) {
+                return;
+            }
+
+            enclosedNonMemberContainer.setContainer(this);
+
+            if (!this._containedNonMemberContainerCache) {
+                this._containedNonMemberContainerCache = TypeScript.createIntrinsicsObject();
+            }
+
+            this._containedNonMemberContainerCache[enclosedNonMemberContainer.name] = enclosedNonMemberContainer;
+        };
+
+        PullTypeSymbol.prototype.addTypeParameter = function (typeParameter) {
+            if (!typeParameter) {
+                return;
+            }
+
+            if (!typeParameter.getContainer()) {
+                typeParameter.setContainer(this);
+            }
+
+            if (!this._typeParameterNameCache) {
+                this._typeParameterNameCache = TypeScript.createIntrinsicsObject();
+            }
+
+            if (!this._typeParameters) {
+                this._typeParameters = [];
+            }
+
+            this._typeParameters[this._typeParameters.length] = typeParameter;
+            this._typeParameterNameCache[typeParameter.getName()] = typeParameter;
+        };
+
+        PullTypeSymbol.prototype.getMembers = function () {
+            return this._members;
+        };
+
+        PullTypeSymbol.prototype.setHasDefaultConstructor = function (hasOne) {
+            if (typeof hasOne === "undefined") { hasOne = true; }
+            this._hasDefaultConstructor = hasOne;
+        };
+
+        PullTypeSymbol.prototype.getHasDefaultConstructor = function () {
+            return this._hasDefaultConstructor;
+        };
+
+        PullTypeSymbol.prototype.getConstructorMethod = function () {
+            return this._constructorMethod;
+        };
+
+        PullTypeSymbol.prototype.setConstructorMethod = function (constructorMethod) {
+            this._constructorMethod = constructorMethod;
+        };
+
+        PullTypeSymbol.prototype.getTypeParameters = function () {
+            if (!this._typeParameters) {
+                return TypeScript.sentinelEmptyArray;
+            }
+
+            return this._typeParameters;
+        };
+
+        PullTypeSymbol.prototype.getAllowedToReferenceTypeParameters = function () {
+            if (!!(this.kind && 8216 /* SomeInstantiatableType */) && this.isNamedTypeSymbol() && !this.isTypeParameter()) {
+                return this.getTypeParameters();
+            }
+
+            if (!this._allowedToReferenceTypeParameters) {
+                this._allowedToReferenceTypeParameters = TypeScript.PullInstantiationHelpers.getAllowedToReferenceTypeParametersFromDecl(this.getDeclarations()[0]);
+            }
+
+            return this._allowedToReferenceTypeParameters;
+        };
+
+        PullTypeSymbol.prototype.isGeneric = function () {
+            return (this._typeParameters && this._typeParameters.length > 0) || this._hasGenericSignature || this._hasGenericMember || this.isArrayNamedTypeReference();
+        };
+
+        PullTypeSymbol.prototype.canUseSimpleInstantiationCache = function (typeArgumentMap) {
+            if (this.isTypeParameter()) {
+                return true;
+            }
+
+            var typeParameters = this.getTypeParameters();
+            return typeArgumentMap && this.isNamedTypeSymbol() && typeParameters.length === 1 && typeArgumentMap[typeParameters[0].pullSymbolID].kind !== 8388608 /* ObjectType */;
+        };
+
+        PullTypeSymbol.prototype.getSimpleInstantiationCacheId = function (typeArgumentMap) {
+            if (this.isTypeParameter()) {
+                return typeArgumentMap[0].pullSymbolID;
+            }
+
+            return typeArgumentMap[this.getTypeParameters()[0].pullSymbolID].pullSymbolID;
+        };
+
+        PullTypeSymbol.prototype.addSpecialization = function (specializedVersionOfThisType, typeArgumentMap) {
+            if (this.canUseSimpleInstantiationCache(typeArgumentMap)) {
+                if (!this._simpleInstantiationCache) {
+                    this._simpleInstantiationCache = [];
+                }
+
+                this._simpleInstantiationCache[this.getSimpleInstantiationCacheId(typeArgumentMap)] = specializedVersionOfThisType;
+            } else {
+                if (!this._complexInstantiationCache) {
+                    this._complexInstantiationCache = TypeScript.createIntrinsicsObject();
+                }
+
+                this._complexInstantiationCache[getIDForTypeSubstitutions(this, typeArgumentMap)] = specializedVersionOfThisType;
+            }
+
+            if (!this._specializedVersionsOfThisType) {
+                this._specializedVersionsOfThisType = [];
+            }
+
+            this._specializedVersionsOfThisType.push(specializedVersionOfThisType);
+        };
+
+        PullTypeSymbol.prototype.getSpecialization = function (typeArgumentMap) {
+            if (this.canUseSimpleInstantiationCache(typeArgumentMap)) {
+                if (!this._simpleInstantiationCache) {
+                    return null;
+                }
+
+                var result = this._simpleInstantiationCache[this.getSimpleInstantiationCacheId(typeArgumentMap)];
+                return result || null;
+            } else {
+                if (!this._complexInstantiationCache) {
+                    return null;
+                }
+
+                if (this.getAllowedToReferenceTypeParameters().length == 0) {
+                    return this;
+                }
+
+                var result = this._complexInstantiationCache[getIDForTypeSubstitutions(this, typeArgumentMap)];
+                return result || null;
+            }
+        };
+
+        PullTypeSymbol.prototype.getKnownSpecializations = function () {
+            if (!this._specializedVersionsOfThisType) {
+                return TypeScript.sentinelEmptyArray;
+            }
+
+            return this._specializedVersionsOfThisType;
+        };
+
+        PullTypeSymbol.prototype.getTypeArguments = function () {
+            return null;
+        };
+
+        PullTypeSymbol.prototype.getTypeArgumentsOrTypeParameters = function () {
+            return this.getTypeParameters();
+        };
+
+        PullTypeSymbol.prototype.addCallOrConstructSignaturePrerequisiteBase = function (signature) {
+            if (signature.isGeneric()) {
+                this._hasGenericSignature = true;
+            }
+
+            signature.functionType = this;
+        };
+
+        PullTypeSymbol.prototype.addCallSignaturePrerequisite = function (callSignature) {
+            if (!this._callSignatures) {
+                this._callSignatures = [];
+            }
+
+            this.addCallOrConstructSignaturePrerequisiteBase(callSignature);
+        };
+
+        PullTypeSymbol.prototype.appendCallSignature = function (callSignature) {
+            this.addCallSignaturePrerequisite(callSignature);
+            this._callSignatures.push(callSignature);
+        };
+
+        PullTypeSymbol.prototype.insertCallSignatureAtIndex = function (callSignature, index) {
+            this.addCallSignaturePrerequisite(callSignature);
+            TypeScript.Debug.assert(index <= this._callSignatures.length);
+            if (index === this._callSignatures.length) {
+                this._callSignatures.push(callSignature);
+            } else {
+                this._callSignatures.splice(index, 0, callSignature);
+            }
+        };
+
+        PullTypeSymbol.prototype.addConstructSignaturePrerequisite = function (constructSignature) {
+            if (!this._constructSignatures) {
+                this._constructSignatures = [];
+            }
+
+            this.addCallOrConstructSignaturePrerequisiteBase(constructSignature);
+        };
+
+        PullTypeSymbol.prototype.appendConstructSignature = function (constructSignature) {
+            this.addConstructSignaturePrerequisite(constructSignature);
+            this._constructSignatures.push(constructSignature);
+        };
+
+        PullTypeSymbol.prototype.insertConstructSignatureAtIndex = function (constructSignature, index) {
+            this.addConstructSignaturePrerequisite(constructSignature);
+            TypeScript.Debug.assert(index <= this._constructSignatures.length);
+            if (index === this._constructSignatures.length) {
+                this._constructSignatures.push(constructSignature);
+            } else {
+                this._constructSignatures.splice(index, 0, constructSignature);
+            }
+        };
+
+        PullTypeSymbol.prototype.addIndexSignature = function (indexSignature) {
+            if (!this._indexSignatures) {
+                this._indexSignatures = [];
+            }
+
+            this._indexSignatures[this._indexSignatures.length] = indexSignature;
+
+            if (indexSignature.isGeneric()) {
+                this._hasGenericSignature = true;
+            }
+
+            indexSignature.functionType = this;
+        };
+
+        PullTypeSymbol.prototype.hasOwnCallSignatures = function () {
+            return this._callSignatures !== null;
+        };
+
+        PullTypeSymbol.prototype.getOwnCallSignatures = function () {
+            return this._callSignatures || TypeScript.sentinelEmptyArray;
+        };
+
+        PullTypeSymbol.prototype.getCallSignatures = function () {
+            if (this._allCallSignatures) {
+                return this._allCallSignatures;
+            }
+
+            var signatures = [];
+
+            if (this._callSignatures) {
+                signatures = signatures.concat(this._callSignatures);
+            }
+
+            if (this._extendedTypes && this.kind === 16 /* Interface */) {
+                for (var i = 0; i < this._extendedTypes.length; i++) {
+                    if (this._extendedTypes[i].hasBase(this)) {
+                        continue;
+                    }
+
+                    this._getResolver()._addUnhiddenSignaturesFromBaseType(this._callSignatures, this._extendedTypes[i].getCallSignatures(), signatures);
+                }
+            }
+
+            this._allCallSignatures = signatures;
+
+            return signatures;
+        };
+
+        PullTypeSymbol.prototype.hasOwnConstructSignatures = function () {
+            return this._constructSignatures !== null;
+        };
+
+        PullTypeSymbol.prototype.getOwnDeclaredConstructSignatures = function () {
+            return this._constructSignatures || TypeScript.sentinelEmptyArray;
+        };
+
+        PullTypeSymbol.prototype.getConstructSignatures = function () {
+            if (this._allConstructSignatures) {
+                return this._allConstructSignatures;
+            }
+
+            var signatures = [];
+
+            if (this._constructSignatures) {
+                signatures = signatures.concat(this._constructSignatures);
+            } else if (this.isConstructor()) {
+                if (this._extendedTypes && this._extendedTypes.length > 0) {
+                    signatures = this.getBaseClassConstructSignatures(this._extendedTypes[0]);
+                } else {
+                    signatures = [this.getDefaultClassConstructSignature()];
+                }
+            }
+
+            if (this._extendedTypes && this.kind === 16 /* Interface */) {
+                for (var i = 0; i < this._extendedTypes.length; i++) {
+                    if (this._extendedTypes[i].hasBase(this)) {
+                        continue;
+                    }
+
+                    this._getResolver()._addUnhiddenSignaturesFromBaseType(this._constructSignatures, this._extendedTypes[i].getConstructSignatures(), signatures);
+                }
+            }
+
+            this._allConstructSignatures = signatures;
+
+            return signatures;
+        };
+
+        PullTypeSymbol.prototype.hasOwnIndexSignatures = function () {
+            return this._indexSignatures !== null;
+        };
+
+        PullTypeSymbol.prototype.getOwnIndexSignatures = function () {
+            return this._indexSignatures || TypeScript.sentinelEmptyArray;
+        };
+
+        PullTypeSymbol.prototype.getIndexSignatures = function () {
+            if (this._allIndexSignatures) {
+                return this._allIndexSignatures;
+            }
+
+            var signatures = [];
+
+            if (this._indexSignatures) {
+                signatures = signatures.concat(this._indexSignatures);
+            }
+
+            if (this._extendedTypes) {
+                for (var i = 0; i < this._extendedTypes.length; i++) {
+                    if (this._extendedTypes[i].hasBase(this)) {
+                        continue;
+                    }
+
+                    this._getResolver()._addUnhiddenSignaturesFromBaseType(this._indexSignatures, this._extendedTypes[i].getIndexSignatures(), signatures);
+                }
+            }
+
+            this._allIndexSignatures = signatures;
+
+            return signatures;
+        };
+
+        PullTypeSymbol.prototype.getIndexSignaturesOfAugmentedType = function (resolver, globalFunctionInterface, globalObjectInterface) {
+            if (!this._allIndexSignaturesOfAugmentedType) {
+                var initialIndexSignatures = this.getIndexSignatures();
+                var shouldAddFunctionSignatures = false;
+                var shouldAddObjectSignatures = false;
+
+                if (globalFunctionInterface && this.isFunctionType() && this !== globalFunctionInterface) {
+                    var functionIndexSignatures = globalFunctionInterface.getIndexSignatures();
+                    if (functionIndexSignatures.length) {
+                        shouldAddFunctionSignatures = true;
+                    }
+                }
+
+                if (globalObjectInterface && this !== globalObjectInterface) {
+                    var objectIndexSignatures = globalObjectInterface.getIndexSignatures();
+                    if (objectIndexSignatures.length) {
+                        shouldAddObjectSignatures = true;
+                    }
+                }
+
+                if (shouldAddFunctionSignatures || shouldAddObjectSignatures) {
+                    this._allIndexSignaturesOfAugmentedType = initialIndexSignatures.slice(0);
+                    if (shouldAddFunctionSignatures) {
+                        resolver._addUnhiddenSignaturesFromBaseType(initialIndexSignatures, functionIndexSignatures, this._allIndexSignaturesOfAugmentedType);
+                    }
+                    if (shouldAddObjectSignatures) {
+                        if (shouldAddFunctionSignatures) {
+                            initialIndexSignatures = initialIndexSignatures.concat(functionIndexSignatures);
+                        }
+                        resolver._addUnhiddenSignaturesFromBaseType(initialIndexSignatures, objectIndexSignatures, this._allIndexSignaturesOfAugmentedType);
+                    }
+                } else {
+                    this._allIndexSignaturesOfAugmentedType = initialIndexSignatures;
+                }
+            }
+
+            return this._allIndexSignaturesOfAugmentedType;
+        };
+
+        PullTypeSymbol.prototype.getBaseClassConstructSignatures = function (baseType) {
+            TypeScript.Debug.assert(this.isConstructor() && baseType.isConstructor());
+            var instanceTypeSymbol = this.getAssociatedContainerType();
+            TypeScript.Debug.assert(instanceTypeSymbol.getDeclarations().length === 1);
+            if (baseType.hasBase(this)) {
+                return null;
+            }
+
+            var baseConstructSignatures = baseType.getConstructSignatures();
+            var signatures = [];
+            for (var i = 0; i < baseConstructSignatures.length; i++) {
+                var baseSignature = baseConstructSignatures[i];
+                var currentSignature = new PullSignatureSymbol(2097152 /* ConstructSignature */, baseSignature.isDefinition());
+                currentSignature.returnType = instanceTypeSymbol;
+                currentSignature.addTypeParametersFromReturnType();
+                for (var j = 0; j < baseSignature.parameters.length; j++) {
+                    currentSignature.addParameter(baseSignature.parameters[j], baseSignature.parameters[j].isOptional);
+                }
+                if (baseSignature.parameters.length > 0) {
+                    currentSignature.hasVarArgs = baseSignature.parameters[baseSignature.parameters.length - 1].isVarArg;
+                }
+
+                currentSignature.addDeclaration(instanceTypeSymbol.getDeclarations()[0]);
+                this.addCallOrConstructSignaturePrerequisiteBase(currentSignature);
+                signatures.push(currentSignature);
+            }
+
+            return signatures;
+        };
+
+        PullTypeSymbol.prototype.getDefaultClassConstructSignature = function () {
+            TypeScript.Debug.assert(this.isConstructor());
+            var instanceTypeSymbol = this.getAssociatedContainerType();
+            TypeScript.Debug.assert(instanceTypeSymbol.getDeclarations().length == 1);
+            var signature = new PullSignatureSymbol(2097152 /* ConstructSignature */, true);
+            signature.returnType = instanceTypeSymbol;
+            signature.addTypeParametersFromReturnType();
+            signature.addDeclaration(instanceTypeSymbol.getDeclarations()[0]);
+            this.addCallOrConstructSignaturePrerequisiteBase(signature);
+
+            return signature;
+        };
+
+        PullTypeSymbol.prototype.addImplementedType = function (implementedType) {
+            if (!implementedType) {
+                return;
+            }
+
+            if (!this._implementedTypes) {
+                this._implementedTypes = [];
+            }
+
+            this._implementedTypes[this._implementedTypes.length] = implementedType;
+
+            implementedType.addTypeThatExplicitlyImplementsThisType(this);
+        };
+
+        PullTypeSymbol.prototype.getImplementedTypes = function () {
+            if (!this._implementedTypes) {
+                return TypeScript.sentinelEmptyArray;
+            }
+
+            return this._implementedTypes;
+        };
+
+        PullTypeSymbol.prototype.addExtendedType = function (extendedType) {
+            if (!extendedType) {
+                return;
+            }
+
+            if (!this._extendedTypes) {
+                this._extendedTypes = [];
+            }
+
+            this._extendedTypes[this._extendedTypes.length] = extendedType;
+
+            extendedType.addTypeThatExtendsThisType(this);
+        };
+
+        PullTypeSymbol.prototype.getExtendedTypes = function () {
+            if (!this._extendedTypes) {
+                return TypeScript.sentinelEmptyArray;
+            }
+
+            return this._extendedTypes;
+        };
+
+        PullTypeSymbol.prototype.addTypeThatExtendsThisType = function (type) {
+            if (!type) {
+                return;
+            }
+
+            if (!this._typesThatExtendThisType) {
+                this._typesThatExtendThisType = [];
+            }
+
+            this._typesThatExtendThisType[this._typesThatExtendThisType.length] = type;
+        };
+
+        PullTypeSymbol.prototype.getTypesThatExtendThisType = function () {
+            if (!this._typesThatExtendThisType) {
+                this._typesThatExtendThisType = [];
+            }
+
+            return this._typesThatExtendThisType;
+        };
+
+        PullTypeSymbol.prototype.addTypeThatExplicitlyImplementsThisType = function (type) {
+            if (!type) {
+                return;
+            }
+
+            if (!this._typesThatExplicitlyImplementThisType) {
+                this._typesThatExplicitlyImplementThisType = [];
+            }
+
+            this._typesThatExplicitlyImplementThisType[this._typesThatExplicitlyImplementThisType.length] = type;
+        };
+
+        PullTypeSymbol.prototype.getTypesThatExplicitlyImplementThisType = function () {
+            if (!this._typesThatExplicitlyImplementThisType) {
+                this._typesThatExplicitlyImplementThisType = [];
+            }
+
+            return this._typesThatExplicitlyImplementThisType;
+        };
+
+        PullTypeSymbol.prototype.hasBase = function (potentialBase, visited) {
+            if (typeof visited === "undefined") { visited = []; }
+            if (this === potentialBase || this.getRootSymbol() === potentialBase || this === potentialBase.getRootSymbol()) {
+                return true;
+            }
+
+            if (TypeScript.ArrayUtilities.contains(visited, this)) {
+                return true;
+            }
+
+            visited.push(this);
+
+            var extendedTypes = this.getExtendedTypes();
+
+            for (var i = 0; i < extendedTypes.length; i++) {
+                if (extendedTypes[i].hasBase(potentialBase, visited)) {
+                    return true;
+                }
+            }
+
+            var implementedTypes = this.getImplementedTypes();
+
+            for (var i = 0; i < implementedTypes.length; i++) {
+                if (implementedTypes[i].hasBase(potentialBase, visited)) {
+                    return true;
+                }
+            }
+
+            visited.pop();
+
+            return false;
+        };
+
+        PullTypeSymbol.prototype.isValidBaseKind = function (baseType, isExtendedType) {
+            if (baseType.isError()) {
+                return false;
+            }
+
+            var thisIsClass = this.isClass();
+            if (isExtendedType) {
+                if (thisIsClass) {
+                    return baseType.kind === 8 /* Class */;
+                }
+            } else {
+                if (!thisIsClass) {
+                    return false;
+                }
+            }
+
+            return !!(baseType.kind & (16 /* Interface */ | 8 /* Class */));
+        };
+
+        PullTypeSymbol.prototype.findMember = function (name, lookInParent) {
+            var memberSymbol = null;
+
+            if (this._memberNameCache) {
+                memberSymbol = this._memberNameCache[name];
+            }
+
+            if (memberSymbol || !lookInParent) {
+                return memberSymbol;
+            }
+
+            if (this._extendedTypes) {
+                for (var i = 0; i < this._extendedTypes.length; i++) {
+                    memberSymbol = this._extendedTypes[i].findMember(name, lookInParent);
+
+                    if (memberSymbol) {
+                        return memberSymbol;
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        PullTypeSymbol.prototype.findNestedType = function (name, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            var memberSymbol;
+
+            if (!this._enclosedTypeNameCache) {
+                return null;
+            }
+
+            memberSymbol = this._enclosedTypeNameCache[name];
+
+            if (memberSymbol && kind !== 0 /* None */) {
+                memberSymbol = TypeScript.hasFlag(memberSymbol.kind, kind) ? memberSymbol : null;
+            }
+
+            return memberSymbol;
+        };
+
+        PullTypeSymbol.prototype.findNestedContainer = function (name, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            var memberSymbol;
+
+            if (!this._enclosedContainerCache) {
+                return null;
+            }
+
+            memberSymbol = this._enclosedContainerCache[name];
+
+            if (memberSymbol && kind !== 0 /* None */) {
+                memberSymbol = TypeScript.hasFlag(memberSymbol.kind, kind) ? memberSymbol : null;
+            }
+
+            return memberSymbol;
+        };
+
+        PullTypeSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisiblity) {
+            var allMembers = [];
+
+            if (this._members !== TypeScript.sentinelEmptyArray) {
+                for (var i = 0, n = this._members.length; i < n; i++) {
+                    var member = this._members[i];
+                    if ((member.kind & searchDeclKind) && (memberVisiblity !== 2 /* externallyVisible */ || !member.anyDeclHasFlag(2 /* Private */))) {
+                        allMembers[allMembers.length] = member;
+                    }
+                }
+            }
+
+            if (this._extendedTypes) {
+                var extenedMembersVisibility = memberVisiblity !== 0 /* all */ ? 2 /* externallyVisible */ : 0 /* all */;
+
+                for (var i = 0, n = this._extendedTypes.length; i < n; i++) {
+                    var extendedMembers = this._extendedTypes[i].getAllMembers(searchDeclKind, extenedMembersVisibility);
+
+                    for (var j = 0, m = extendedMembers.length; j < m; j++) {
+                        var extendedMember = extendedMembers[j];
+                        if (!(this._memberNameCache && this._memberNameCache[extendedMember.name])) {
+                            allMembers[allMembers.length] = extendedMember;
+                        }
+                    }
+                }
+            }
+
+            if (this.isContainer()) {
+                if (this._enclosedMemberTypes) {
+                    for (var i = 0; i < this._enclosedMemberTypes.length; i++) {
+                        allMembers[allMembers.length] = this._enclosedMemberTypes[i];
+                    }
+                }
+                if (this._enclosedMemberContainers) {
+                    for (var i = 0; i < this._enclosedMemberContainers.length; i++) {
+                        allMembers[allMembers.length] = this._enclosedMemberContainers[i];
+                    }
+                }
+            }
+
+            return allMembers;
+        };
+
+        PullTypeSymbol.prototype.findTypeParameter = function (name) {
+            if (!this._typeParameterNameCache) {
+                return null;
+            }
+
+            return this._typeParameterNameCache[name];
+        };
+
+        PullTypeSymbol.prototype.setResolved = function () {
+            _super.prototype.setResolved.call(this);
+        };
+
+        PullTypeSymbol.prototype.getNamePartForFullName = function () {
+            var name = _super.prototype.getNamePartForFullName.call(this);
+
+            var typars = this.getTypeArgumentsOrTypeParameters();
+            var typarString = PullSymbol.getTypeParameterString(typars, this, true);
+            return name + typarString;
+        };
+
+        PullTypeSymbol.prototype.getScopedName = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName) {
+            return this.getScopedNameEx(scopeSymbol, skipTypeParametersInName, useConstraintInName, false, false, skipInternalAliasName).toString();
+        };
+
+        PullTypeSymbol.prototype.isNamedTypeSymbol = function () {
+            var kind = this.kind;
+            if (kind === 2 /* Primitive */ || kind === 8 /* Class */ || kind === 4 /* Container */ || kind === 32 /* DynamicModule */ || kind === 128 /* TypeAlias */ || kind === 64 /* Enum */ || kind === 8192 /* TypeParameter */ || ((kind === 16 /* Interface */ || kind === 8388608 /* ObjectType */) && this.name !== "")) {
+                return true;
+            }
+
+            return false;
+        };
+
+        PullTypeSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) {
+            var s = this.getScopedNameEx(scopeSymbol, false, useConstraintInName).toString();
+            return s;
+        };
+
+        PullTypeSymbol.prototype.getScopedNameEx = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, getPrettyTypeName, getTypeParamMarkerInfo, skipInternalAliasName, shouldAllowArrayType) {
+            if (typeof shouldAllowArrayType === "undefined") { shouldAllowArrayType = true; }
+            if (this.isArrayNamedTypeReference() && shouldAllowArrayType) {
+                var elementType = this.getElementType();
+                var elementMemberName = elementType ? (elementType.isArrayNamedTypeReference() || elementType.isNamedTypeSymbol() ? elementType.getScopedNameEx(scopeSymbol, false, false, getPrettyTypeName, getTypeParamMarkerInfo, skipInternalAliasName) : elementType.getMemberTypeNameEx(false, scopeSymbol, getPrettyTypeName)) : TypeScript.MemberName.create("any");
+                return TypeScript.MemberName.create(elementMemberName, "", "[]");
+            }
+
+            if (!this.isNamedTypeSymbol()) {
+                return this.getMemberTypeNameEx(true, scopeSymbol, getPrettyTypeName);
+            }
+
+            if (skipTypeParametersInName) {
+                return TypeScript.MemberName.create(_super.prototype.getScopedName.call(this, scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName));
+            } else {
+                var builder = new TypeScript.MemberNameArray();
+                builder.prefix = _super.prototype.getScopedName.call(this, scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName);
+
+                var typars = this.getTypeArgumentsOrTypeParameters();
+                builder.add(PullSymbol.getTypeParameterStringEx(typars, scopeSymbol, getTypeParamMarkerInfo, useConstraintInName));
+
+                return builder;
+            }
+        };
+
+        PullTypeSymbol.prototype.hasOnlyOverloadCallSignatures = function () {
+            var members = this.getMembers();
+            var callSignatures = this.getCallSignatures();
+            var constructSignatures = this.getConstructSignatures();
+            return members.length === 0 && constructSignatures.length === 0 && callSignatures.length > 1;
+        };
+
+        PullTypeSymbol.prototype.getTypeOfSymbol = function () {
+            var associatedContainerType = this.getAssociatedContainerType();
+            if (associatedContainerType && associatedContainerType.isNamedTypeSymbol()) {
+                return associatedContainerType;
+            }
+
+            var functionSymbol = this.getFunctionSymbol();
+            if (functionSymbol && functionSymbol.kind === 16384 /* Function */ && !TypeScript.PullHelpers.isSymbolLocal(functionSymbol)) {
+                return TypeScript.PullHelpers.isExportedSymbolInClodule(functionSymbol) ? null : functionSymbol;
+            }
+
+            return null;
+        };
+
+        PullTypeSymbol.prototype.getMemberTypeNameEx = function (topLevel, scopeSymbol, getPrettyTypeName) {
+            var members = this.getMembers();
+            var callSignatures = this.getCallSignatures();
+            var constructSignatures = this.getConstructSignatures();
+            var indexSignatures = this.getIndexSignatures();
+
+            var typeOfSymbol = this.getTypeOfSymbol();
+            if (typeOfSymbol) {
+                var nameForTypeOf = typeOfSymbol.getScopedNameEx(scopeSymbol, true);
+                return TypeScript.MemberName.create(nameForTypeOf, "typeof ", "");
+            }
+
+            if (members.length > 0 || callSignatures.length > 0 || constructSignatures.length > 0 || indexSignatures.length > 0) {
+                if (this._inMemberTypeNameEx) {
+                    return TypeScript.MemberName.create("any");
+                }
+
+                this._inMemberTypeNameEx = true;
+
+                var allMemberNames = new TypeScript.MemberNameArray();
+                var curlies = !topLevel || indexSignatures.length !== 0;
+                var delim = "; ";
+                for (var i = 0; i < members.length; i++) {
+                    if (members[i].kind === 65536 /* Method */ && members[i].type.hasOnlyOverloadCallSignatures()) {
+                        var methodCallSignatures = members[i].type.getCallSignatures();
+                        var nameStr = members[i].getDisplayName(scopeSymbol) + (members[i].isOptional ? "?" : "");
+                        ;
+                        var methodMemberNames = PullSignatureSymbol.getSignaturesTypeNameEx(methodCallSignatures, nameStr, false, false, scopeSymbol);
+                        allMemberNames.addAll(methodMemberNames);
+                    } else {
+                        var memberTypeName = members[i].getNameAndTypeNameEx(scopeSymbol);
+                        if (memberTypeName.isArray() && memberTypeName.delim === delim) {
+                            allMemberNames.addAll(memberTypeName.entries);
+                        } else {
+                            allMemberNames.add(memberTypeName);
+                        }
+                    }
+                    curlies = true;
+                }
+
+                var getPrettyFunctionOverload = getPrettyTypeName && !curlies && this.hasOnlyOverloadCallSignatures();
+
+                var signatureCount = callSignatures.length + constructSignatures.length + indexSignatures.length;
+                var useShortFormSignature = !curlies && (signatureCount === 1);
+                var signatureMemberName;
+
+                if (callSignatures.length > 0) {
+                    signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(callSignatures, "", useShortFormSignature, false, scopeSymbol, getPrettyFunctionOverload);
+                    allMemberNames.addAll(signatureMemberName);
+                }
+
+                if (constructSignatures.length > 0) {
+                    signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(constructSignatures, "new", useShortFormSignature, false, scopeSymbol);
+                    allMemberNames.addAll(signatureMemberName);
+                }
+
+                if (indexSignatures.length > 0) {
+                    signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(indexSignatures, "", useShortFormSignature, true, scopeSymbol);
+                    allMemberNames.addAll(signatureMemberName);
+                }
+
+                if ((curlies) || (!getPrettyFunctionOverload && (signatureCount > 1) && topLevel)) {
+                    allMemberNames.prefix = "{ ";
+                    allMemberNames.suffix = "}";
+                    allMemberNames.delim = delim;
+                } else if (allMemberNames.entries.length > 1) {
+                    allMemberNames.delim = delim;
+                }
+
+                this._inMemberTypeNameEx = false;
+
+                return allMemberNames;
+            }
+
+            return TypeScript.MemberName.create("{}");
+        };
+
+        PullTypeSymbol.prototype.getGenerativeTypeClassification = function (enclosingType) {
+            return 2 /* Closed */;
+        };
+
+        PullTypeSymbol.prototype.wrapsSomeTypeParameter = function (typeParameterArgumentMap, skipTypeArgumentCheck) {
+            return this.getWrappingTypeParameterID(typeParameterArgumentMap, skipTypeArgumentCheck) != 0;
+        };
+
+        PullTypeSymbol.prototype.getWrappingTypeParameterID = function (typeParameterArgumentMap, skipTypeArgumentCheck) {
+            var type = this;
+
+            if (type.isTypeParameter()) {
+                if (typeParameterArgumentMap[type.pullSymbolID] || typeParameterArgumentMap[type.getRootSymbol().pullSymbolID]) {
+                    return type.pullSymbolID;
+                }
+
+                var constraint = type.getConstraint();
+                var wrappingTypeParameterID = constraint ? constraint.getWrappingTypeParameterID(typeParameterArgumentMap) : 0;
+                return wrappingTypeParameterID;
+            }
+
+            if (type.inWrapCheck) {
+                return 0;
+            }
+
+            this._wrapsTypeParameterCache = this._wrapsTypeParameterCache || new TypeScript.WrapsTypeParameterCache();
+            var wrappingTypeParameterID = this._wrapsTypeParameterCache.getWrapsTypeParameter(typeParameterArgumentMap);
+            if (wrappingTypeParameterID === undefined) {
+                wrappingTypeParameterID = this.getWrappingTypeParameterIDWorker(typeParameterArgumentMap, skipTypeArgumentCheck);
+
+                this._wrapsTypeParameterCache.setWrapsTypeParameter(typeParameterArgumentMap, wrappingTypeParameterID);
+            }
+            return wrappingTypeParameterID;
+        };
+
+        PullTypeSymbol.prototype.getWrappingTypeParameterIDFromSignatures = function (signatures, typeParameterArgumentMap) {
+            for (var i = 0; i < signatures.length; i++) {
+                var wrappingTypeParameterID = signatures[i].getWrappingTypeParameterID(typeParameterArgumentMap);
+                if (wrappingTypeParameterID !== 0) {
+                    return wrappingTypeParameterID;
+                }
+            }
+
+            return 0;
+        };
+
+        PullTypeSymbol.prototype.getWrappingTypeParameterIDWorker = function (typeParameterArgumentMap, skipTypeArgumentCheck) {
+            var type = this;
+            var wrappingTypeParameterID = 0;
+
+            if (!skipTypeArgumentCheck) {
+                type.inWrapCheck = true;
+
+                var typeArguments = type.getTypeArguments();
+
+                if (type.isGeneric() && !typeArguments) {
+                    typeArguments = type.getTypeParameters();
+                }
+
+                if (typeArguments) {
+                    for (var i = 0; !wrappingTypeParameterID && i < typeArguments.length; i++) {
+                        wrappingTypeParameterID = typeArguments[i].getWrappingTypeParameterID(typeParameterArgumentMap);
+                    }
+                }
+            }
+
+            if (skipTypeArgumentCheck || !(type.kind & 8216 /* SomeInstantiatableType */) || !type.name) {
+                var members = type.getAllMembers(68147712 /* SomeValue */, 0 /* all */);
+                for (var i = 0; !wrappingTypeParameterID && i < members.length; i++) {
+                    TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(members[i]);
+                    wrappingTypeParameterID = members[i].type.getWrappingTypeParameterID(typeParameterArgumentMap);
+                }
+
+                wrappingTypeParameterID = wrappingTypeParameterID || this.getWrappingTypeParameterIDFromSignatures(type.getCallSignatures(), typeParameterArgumentMap) || this.getWrappingTypeParameterIDFromSignatures(type.getConstructSignatures(), typeParameterArgumentMap) || this.getWrappingTypeParameterIDFromSignatures(type.getIndexSignatures(), typeParameterArgumentMap);
+            }
+
+            if (!skipTypeArgumentCheck) {
+                type.inWrapCheck = false;
+            }
+
+            return wrappingTypeParameterID;
+        };
+
+        PullTypeSymbol.prototype.wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReference = function (enclosingType) {
+            TypeScript.Debug.assert(this.isNamedTypeSymbol());
+            TypeScript.Debug.assert(TypeScript.PullHelpers.getRootType(enclosingType) == enclosingType);
+            var knownWrapMap = TypeScript.BitMatrix.getBitMatrix(true);
+            var wrapsIntoInfinitelyExpandingTypeReference = this._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceRecurse(enclosingType, knownWrapMap);
+            knownWrapMap.release();
+            return wrapsIntoInfinitelyExpandingTypeReference;
+        };
+
+        PullTypeSymbol.prototype._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceRecurse = function (enclosingType, knownWrapMap) {
+            var wrapsIntoInfinitelyExpandingTypeReference = knownWrapMap.valueAt(this.pullSymbolID, enclosingType.pullSymbolID);
+            if (wrapsIntoInfinitelyExpandingTypeReference != undefined) {
+                return wrapsIntoInfinitelyExpandingTypeReference;
+            }
+
+            if (this.inWrapInfiniteExpandingReferenceCheck) {
+                return false;
+            }
+
+            this.inWrapInfiniteExpandingReferenceCheck = true;
+            wrapsIntoInfinitelyExpandingTypeReference = this._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceWorker(enclosingType, knownWrapMap);
+            knownWrapMap.setValueAt(this.pullSymbolID, enclosingType.pullSymbolID, wrapsIntoInfinitelyExpandingTypeReference);
+            this.inWrapInfiniteExpandingReferenceCheck = false;
+
+            return wrapsIntoInfinitelyExpandingTypeReference;
+        };
+
+        PullTypeSymbol.prototype._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceWorker = function (enclosingType, knownWrapMap) {
+            var thisRootType = TypeScript.PullHelpers.getRootType(this);
+
+            if (thisRootType != enclosingType) {
+                var thisIsNamedType = this.isNamedTypeSymbol();
+
+                if (thisIsNamedType) {
+                    if (thisRootType.inWrapInfiniteExpandingReferenceCheck) {
+                        return false;
+                    }
+
+                    thisRootType.inWrapInfiniteExpandingReferenceCheck = true;
+                }
+
+                var wrapsIntoInfinitelyExpandingTypeReference = this._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceStructure(enclosingType, knownWrapMap);
+
+                if (thisIsNamedType) {
+                    thisRootType.inWrapInfiniteExpandingReferenceCheck = false;
+                }
+
+                return wrapsIntoInfinitelyExpandingTypeReference;
+            }
+
+            var enclosingTypeParameters = enclosingType.getTypeParameters();
+            var typeArguments = this.getTypeArguments();
+            for (var i = 0; i < typeArguments.length; i++) {
+                if (TypeScript.ArrayUtilities.contains(enclosingTypeParameters, typeArguments[i])) {
+                    continue;
+                }
+
+                if (typeArguments[i].wrapsSomeTypeParameter(this.getTypeParameterArgumentMap())) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeSymbol.prototype._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceStructure = function (enclosingType, knownWrapMap) {
+            var members = this.getAllMembers(68147712 /* SomeValue */, 0 /* all */);
+            for (var i = 0; i < members.length; i++) {
+                if (members[i].type && members[i].type._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReferenceRecurse(enclosingType, knownWrapMap)) {
+                    return true;
+                }
+            }
+
+            var sigs = this.getCallSignatures();
+            for (var i = 0; i < sigs.length; i++) {
+                if (sigs[i]._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReference(enclosingType, knownWrapMap)) {
+                    return true;
+                }
+            }
+
+            sigs = this.getConstructSignatures();
+            for (var i = 0; i < sigs.length; i++) {
+                if (sigs[i]._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReference(enclosingType, knownWrapMap)) {
+                    return true;
+                }
+            }
+
+            sigs = this.getIndexSignatures();
+            for (var i = 0; i < sigs.length; i++) {
+                if (sigs[i]._wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReference(enclosingType, knownWrapMap)) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeSymbol.prototype.widenedType = function (resolver, ast, context) {
+            if (!this._widenedType) {
+                this._widenedType = resolver.widenType(this, ast, context);
+            }
+            return this._widenedType;
+        };
+        return PullTypeSymbol;
+    })(PullSymbol);
+    TypeScript.PullTypeSymbol = PullTypeSymbol;
+
+    var PullPrimitiveTypeSymbol = (function (_super) {
+        __extends(PullPrimitiveTypeSymbol, _super);
+        function PullPrimitiveTypeSymbol(name) {
+            _super.call(this, name, 2 /* Primitive */);
+
+            this.isResolved = true;
+        }
+        PullPrimitiveTypeSymbol.prototype.isAny = function () {
+            return !this.isStringConstant() && this.name === "any";
+        };
+
+        PullPrimitiveTypeSymbol.prototype.isNull = function () {
+            return !this.isStringConstant() && this.name === "null";
+        };
+
+        PullPrimitiveTypeSymbol.prototype.isUndefined = function () {
+            return !this.isStringConstant() && this.name === "undefined";
+        };
+
+        PullPrimitiveTypeSymbol.prototype.isStringConstant = function () {
+            return false;
+        };
+
+        PullPrimitiveTypeSymbol.prototype.setUnresolved = function () {
+        };
+
+        PullPrimitiveTypeSymbol.prototype.getDisplayName = function () {
+            if (this.isNull() || this.isUndefined()) {
+                return "any";
+            } else {
+                return _super.prototype.getDisplayName.call(this);
+            }
+        };
+        return PullPrimitiveTypeSymbol;
+    })(PullTypeSymbol);
+    TypeScript.PullPrimitiveTypeSymbol = PullPrimitiveTypeSymbol;
+
+    var PullStringConstantTypeSymbol = (function (_super) {
+        __extends(PullStringConstantTypeSymbol, _super);
+        function PullStringConstantTypeSymbol(name) {
+            _super.call(this, name);
+        }
+        PullStringConstantTypeSymbol.prototype.isStringConstant = function () {
+            return true;
+        };
+        return PullStringConstantTypeSymbol;
+    })(PullPrimitiveTypeSymbol);
+    TypeScript.PullStringConstantTypeSymbol = PullStringConstantTypeSymbol;
+
+    var PullErrorTypeSymbol = (function (_super) {
+        __extends(PullErrorTypeSymbol, _super);
+        function PullErrorTypeSymbol(_anyType, name) {
+            _super.call(this, name);
+            this._anyType = _anyType;
+
+            TypeScript.Debug.assert(this._anyType);
+            this.isResolved = true;
+        }
+        PullErrorTypeSymbol.prototype.isError = function () {
+            return true;
+        };
+
+        PullErrorTypeSymbol.prototype._getResolver = function () {
+            return this._anyType._getResolver();
+        };
+
+        PullErrorTypeSymbol.prototype.getName = function (scopeSymbol, useConstraintInName) {
+            return this._anyType.getName(scopeSymbol, useConstraintInName);
+        };
+
+        PullErrorTypeSymbol.prototype.getDisplayName = function (scopeSymbol, useConstraintInName, skipInternalAliasName) {
+            return this._anyType.getName(scopeSymbol, useConstraintInName);
+        };
+
+        PullErrorTypeSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) {
+            return this._anyType.getName(scopeSymbol, useConstraintInName);
+        };
+        return PullErrorTypeSymbol;
+    })(PullPrimitiveTypeSymbol);
+    TypeScript.PullErrorTypeSymbol = PullErrorTypeSymbol;
+
+    var PullContainerSymbol = (function (_super) {
+        __extends(PullContainerSymbol, _super);
+        function PullContainerSymbol(name, kind) {
+            _super.call(this, name, kind);
+            this.instanceSymbol = null;
+            this.assignedValue = null;
+            this.assignedType = null;
+            this.assignedContainer = null;
+        }
+        PullContainerSymbol.prototype.isContainer = function () {
+            return true;
+        };
+
+        PullContainerSymbol.prototype.setInstanceSymbol = function (symbol) {
+            this.instanceSymbol = symbol;
+        };
+
+        PullContainerSymbol.prototype.getInstanceSymbol = function () {
+            return this.instanceSymbol;
+        };
+
+        PullContainerSymbol.prototype.setExportAssignedValueSymbol = function (symbol) {
+            this.assignedValue = symbol;
+        };
+
+        PullContainerSymbol.prototype.getExportAssignedValueSymbol = function () {
+            return this.assignedValue;
+        };
+
+        PullContainerSymbol.prototype.setExportAssignedTypeSymbol = function (type) {
+            this.assignedType = type;
+        };
+
+        PullContainerSymbol.prototype.getExportAssignedTypeSymbol = function () {
+            return this.assignedType;
+        };
+
+        PullContainerSymbol.prototype.setExportAssignedContainerSymbol = function (container) {
+            this.assignedContainer = container;
+        };
+
+        PullContainerSymbol.prototype.getExportAssignedContainerSymbol = function () {
+            return this.assignedContainer;
+        };
+
+        PullContainerSymbol.prototype.hasExportAssignment = function () {
+            return !!this.assignedValue || !!this.assignedType || !!this.assignedContainer;
+        };
+
+        PullContainerSymbol.usedAsSymbol = function (containerSymbol, symbol) {
+            if (!containerSymbol || !containerSymbol.isContainer()) {
+                return false;
+            }
+
+            if (!containerSymbol.isAlias() && containerSymbol.type === symbol) {
+                return true;
+            }
+
+            var moduleSymbol = containerSymbol;
+            var valueExportSymbol = moduleSymbol.getExportAssignedValueSymbol();
+            var typeExportSymbol = moduleSymbol.getExportAssignedTypeSymbol();
+            var containerExportSymbol = moduleSymbol.getExportAssignedContainerSymbol();
+            if (valueExportSymbol || typeExportSymbol || containerExportSymbol) {
+                return valueExportSymbol === symbol || typeExportSymbol == symbol || containerExportSymbol == symbol || PullContainerSymbol.usedAsSymbol(containerExportSymbol, symbol);
+            }
+
+            return false;
+        };
+
+        PullContainerSymbol.prototype.getInstanceType = function () {
+            return this.instanceSymbol ? this.instanceSymbol.type : null;
+        };
+        return PullContainerSymbol;
+    })(PullTypeSymbol);
+    TypeScript.PullContainerSymbol = PullContainerSymbol;
+
+    var PullTypeAliasSymbol = (function (_super) {
+        __extends(PullTypeAliasSymbol, _super);
+        function PullTypeAliasSymbol(name) {
+            _super.call(this, name, 128 /* TypeAlias */);
+            this._assignedValue = null;
+            this._assignedType = null;
+            this._assignedContainer = null;
+            this._isUsedAsValue = false;
+            this._typeUsedExternally = false;
+            this._isUsedInExportAlias = false;
+            this.retrievingExportAssignment = false;
+            this.linkedAliasSymbols = null;
+        }
+        PullTypeAliasSymbol.prototype.isUsedInExportedAlias = function () {
+            this._resolveDeclaredSymbol();
+            return this._isUsedInExportAlias;
+        };
+
+        PullTypeAliasSymbol.prototype.typeUsedExternally = function () {
+            this._resolveDeclaredSymbol();
+            return this._typeUsedExternally;
+        };
+
+        PullTypeAliasSymbol.prototype.isUsedAsValue = function () {
+            this._resolveDeclaredSymbol();
+            return this._isUsedAsValue;
+        };
+
+        PullTypeAliasSymbol.prototype.setTypeUsedExternally = function () {
+            this._typeUsedExternally = true;
+        };
+
+        PullTypeAliasSymbol.prototype.setIsUsedInExportedAlias = function () {
+            this._isUsedInExportAlias = true;
+            if (this.linkedAliasSymbols) {
+                this.linkedAliasSymbols.forEach(function (s) {
+                    return s.setIsUsedInExportedAlias();
+                });
+            }
+        };
+
+        PullTypeAliasSymbol.prototype.addLinkedAliasSymbol = function (contingentValueSymbol) {
+            if (!this.linkedAliasSymbols) {
+                this.linkedAliasSymbols = [contingentValueSymbol];
+            } else {
+                this.linkedAliasSymbols.push(contingentValueSymbol);
+            }
+        };
+
+        PullTypeAliasSymbol.prototype.setIsUsedAsValue = function () {
+            this._isUsedAsValue = true;
+            if (this.linkedAliasSymbols) {
+                this.linkedAliasSymbols.forEach(function (s) {
+                    return s.setIsUsedAsValue();
+                });
+            }
+        };
+
+        PullTypeAliasSymbol.prototype.assignedValue = function () {
+            this._resolveDeclaredSymbol();
+            return this._assignedValue;
+        };
+
+        PullTypeAliasSymbol.prototype.assignedType = function () {
+            this._resolveDeclaredSymbol();
+            return this._assignedType;
+        };
+
+        PullTypeAliasSymbol.prototype.assignedContainer = function () {
+            this._resolveDeclaredSymbol();
+            return this._assignedContainer;
+        };
+
+        PullTypeAliasSymbol.prototype.isAlias = function () {
+            return true;
+        };
+        PullTypeAliasSymbol.prototype.isContainer = function () {
+            return true;
+        };
+
+        PullTypeAliasSymbol.prototype.setAssignedValueSymbol = function (symbol) {
+            this._assignedValue = symbol;
+        };
+
+        PullTypeAliasSymbol.prototype.getExportAssignedValueSymbol = function () {
+            if (this._assignedValue) {
+                return this._assignedValue;
+            }
+
+            if (this.retrievingExportAssignment) {
+                return null;
+            }
+
+            if (this._assignedContainer) {
+                if (this._assignedContainer.hasExportAssignment()) {
+                    this.retrievingExportAssignment = true;
+                    var sym = this._assignedContainer.getExportAssignedValueSymbol();
+                    this.retrievingExportAssignment = false;
+                    return sym;
+                }
+
+                return this._assignedContainer.getInstanceSymbol();
+            }
+
+            return null;
+        };
+
+        PullTypeAliasSymbol.prototype.setAssignedTypeSymbol = function (type) {
+            this._assignedType = type;
+        };
+
+        PullTypeAliasSymbol.prototype.getExportAssignedTypeSymbol = function () {
+            if (this.retrievingExportAssignment) {
+                return null;
+            }
+
+            if (this._assignedType) {
+                if (this._assignedType.isAlias()) {
+                    this.retrievingExportAssignment = true;
+                    var sym = this._assignedType.getExportAssignedTypeSymbol();
+                    this.retrievingExportAssignment = false;
+                } else if (this._assignedType !== this._assignedContainer) {
+                    return this._assignedType;
+                }
+            }
+
+            if (this._assignedContainer) {
+                this.retrievingExportAssignment = true;
+                var sym = this._assignedContainer.getExportAssignedTypeSymbol();
+                this.retrievingExportAssignment = false;
+                if (sym) {
+                    return sym;
+                }
+            }
+
+            return this._assignedContainer;
+        };
+
+        PullTypeAliasSymbol.prototype.setAssignedContainerSymbol = function (container) {
+            this._assignedContainer = container;
+        };
+
+        PullTypeAliasSymbol.prototype.getExportAssignedContainerSymbol = function () {
+            if (this.retrievingExportAssignment) {
+                return null;
+            }
+
+            if (this._assignedContainer) {
+                this.retrievingExportAssignment = true;
+                var sym = this._assignedContainer.getExportAssignedContainerSymbol();
+                this.retrievingExportAssignment = false;
+                if (sym) {
+                    return sym;
+                }
+            }
+
+            return this._assignedContainer;
+        };
+
+        PullTypeAliasSymbol.prototype.getMembers = function () {
+            if (this._assignedType) {
+                return this._assignedType.getMembers();
+            }
+
+            return TypeScript.sentinelEmptyArray;
+        };
+
+        PullTypeAliasSymbol.prototype.getCallSignatures = function () {
+            if (this._assignedType) {
+                return this._assignedType.getCallSignatures();
+            }
+
+            return TypeScript.sentinelEmptyArray;
+        };
+
+        PullTypeAliasSymbol.prototype.getConstructSignatures = function () {
+            if (this._assignedType) {
+                return this._assignedType.getConstructSignatures();
+            }
+
+            return TypeScript.sentinelEmptyArray;
+        };
+
+        PullTypeAliasSymbol.prototype.getIndexSignatures = function () {
+            if (this._assignedType) {
+                return this._assignedType.getIndexSignatures();
+            }
+
+            return TypeScript.sentinelEmptyArray;
+        };
+
+        PullTypeAliasSymbol.prototype.findMember = function (name) {
+            if (this._assignedType) {
+                return this._assignedType.findMember(name, true);
+            }
+
+            return null;
+        };
+
+        PullTypeAliasSymbol.prototype.findNestedType = function (name) {
+            if (this._assignedType) {
+                return this._assignedType.findNestedType(name);
+            }
+
+            return null;
+        };
+
+        PullTypeAliasSymbol.prototype.findNestedContainer = function (name) {
+            if (this._assignedType) {
+                return this._assignedType.findNestedContainer(name);
+            }
+
+            return null;
+        };
+
+        PullTypeAliasSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisibility) {
+            if (this._assignedType) {
+                return this._assignedType.getAllMembers(searchDeclKind, memberVisibility);
+            }
+
+            return TypeScript.sentinelEmptyArray;
+        };
+        return PullTypeAliasSymbol;
+    })(PullTypeSymbol);
+    TypeScript.PullTypeAliasSymbol = PullTypeAliasSymbol;
+
+    var PullTypeParameterSymbol = (function (_super) {
+        __extends(PullTypeParameterSymbol, _super);
+        function PullTypeParameterSymbol(name) {
+            _super.call(this, name, 8192 /* TypeParameter */);
+            this._constraint = null;
+        }
+        PullTypeParameterSymbol.prototype.isTypeParameter = function () {
+            return true;
+        };
+
+        PullTypeParameterSymbol.prototype.setConstraint = function (constraintType) {
+            this._constraint = constraintType;
+        };
+
+        PullTypeParameterSymbol.prototype.getConstraint = function () {
+            return this._constraint;
+        };
+
+        PullTypeParameterSymbol.prototype.getBaseConstraint = function (semanticInfoChain) {
+            var preBaseConstraint = this.getConstraintRecursively({});
+            TypeScript.Debug.assert(preBaseConstraint === null || !preBaseConstraint.isTypeParameter());
+            return preBaseConstraint || semanticInfoChain.emptyTypeSymbol;
+        };
+
+        PullTypeParameterSymbol.prototype.getConstraintRecursively = function (visitedTypeParameters) {
+            var constraint = this.getConstraint();
+
+            if (constraint) {
+                if (constraint.isTypeParameter()) {
+                    var constraintAsTypeParameter = constraint;
+                    if (!visitedTypeParameters[constraintAsTypeParameter.pullSymbolID]) {
+                        visitedTypeParameters[constraintAsTypeParameter.pullSymbolID] = constraintAsTypeParameter;
+                        return constraintAsTypeParameter.getConstraintRecursively(visitedTypeParameters);
+                    }
+                } else {
+                    return constraint;
+                }
+            }
+
+            return null;
+        };
+
+        PullTypeParameterSymbol.prototype.getDefaultConstraint = function (semanticInfoChain) {
+            return this._constraint || semanticInfoChain.emptyTypeSymbol;
+        };
+
+        PullTypeParameterSymbol.prototype.getCallSignatures = function () {
+            if (this._constraint) {
+                return this._constraint.getCallSignatures();
+            }
+
+            return _super.prototype.getCallSignatures.call(this);
+        };
+
+        PullTypeParameterSymbol.prototype.getConstructSignatures = function () {
+            if (this._constraint) {
+                return this._constraint.getConstructSignatures();
+            }
+
+            return _super.prototype.getConstructSignatures.call(this);
+        };
+
+        PullTypeParameterSymbol.prototype.getIndexSignatures = function () {
+            if (this._constraint) {
+                return this._constraint.getIndexSignatures();
+            }
+
+            return _super.prototype.getIndexSignatures.call(this);
+        };
+
+        PullTypeParameterSymbol.prototype.isGeneric = function () {
+            return true;
+        };
+
+        PullTypeParameterSymbol.prototype.fullName = function (scopeSymbol) {
+            var name = this.getDisplayName(scopeSymbol);
+            var container = this.getContainer();
+            if (container) {
+                var containerName = container.fullName(scopeSymbol);
+                name = name + " in " + containerName;
+            }
+
+            return name;
+        };
+
+        PullTypeParameterSymbol.prototype.getName = function (scopeSymbol, useConstraintInName) {
+            var name = _super.prototype.getName.call(this, scopeSymbol);
+
+            if (this.isPrinting) {
+                return name;
+            }
+
+            this.isPrinting = true;
+
+            if (useConstraintInName && this._constraint) {
+                name += " extends " + this._constraint.toString(scopeSymbol);
+            }
+
+            this.isPrinting = false;
+
+            return name;
+        };
+
+        PullTypeParameterSymbol.prototype.getDisplayName = function (scopeSymbol, useConstraintInName, skipInternalAliasName) {
+            var name = _super.prototype.getDisplayName.call(this, scopeSymbol, useConstraintInName, skipInternalAliasName);
+
+            if (this.isPrinting) {
+                return name;
+            }
+
+            this.isPrinting = true;
+
+            if (useConstraintInName && this._constraint) {
+                name += " extends " + this._constraint.toString(scopeSymbol);
+            }
+
+            this.isPrinting = false;
+
+            return name;
+        };
+
+        PullTypeParameterSymbol.prototype.isExternallyVisible = function (inIsExternallyVisibleSymbols) {
+            return true;
+        };
+        return PullTypeParameterSymbol;
+    })(PullTypeSymbol);
+    TypeScript.PullTypeParameterSymbol = PullTypeParameterSymbol;
+
+    var PullAccessorSymbol = (function (_super) {
+        __extends(PullAccessorSymbol, _super);
+        function PullAccessorSymbol(name) {
+            _super.call(this, name, 4096 /* Property */);
+            this._getterSymbol = null;
+            this._setterSymbol = null;
+        }
+        PullAccessorSymbol.prototype.isAccessor = function () {
+            return true;
+        };
+
+        PullAccessorSymbol.prototype.setSetter = function (setter) {
+            if (!setter) {
+                return;
+            }
+
+            this._setterSymbol = setter;
+        };
+
+        PullAccessorSymbol.prototype.getSetter = function () {
+            return this._setterSymbol;
+        };
+
+        PullAccessorSymbol.prototype.setGetter = function (getter) {
+            if (!getter) {
+                return;
+            }
+
+            this._getterSymbol = getter;
+        };
+
+        PullAccessorSymbol.prototype.getGetter = function () {
+            return this._getterSymbol;
+        };
+        return PullAccessorSymbol;
+    })(PullSymbol);
+    TypeScript.PullAccessorSymbol = PullAccessorSymbol;
+
+    function getIDForTypeSubstitutions(instantiatingTypeOrSignature, typeArgumentMap) {
+        var substitution = "";
+        var members = null;
+
+        var allowedToReferenceTypeParameters = instantiatingTypeOrSignature.getAllowedToReferenceTypeParameters();
+        for (var i = 0; i < allowedToReferenceTypeParameters.length; i++) {
+            var typeParameter = allowedToReferenceTypeParameters[i];
+            var typeParameterID = typeParameter.pullSymbolID;
+            var typeArg = typeArgumentMap[typeParameterID];
+            if (!typeArg) {
+                typeArg = typeParameter;
+            }
+            substitution += typeParameterID + ":" + getIDForTypeSubstitutionsOfType(typeArg);
+        }
+
+        return substitution;
+    }
+    TypeScript.getIDForTypeSubstitutions = getIDForTypeSubstitutions;
+
+    function getIDForTypeSubstitutionsOfType(type) {
+        var structure;
+        if (type.isError()) {
+            structure = "E" + getIDForTypeSubstitutionsOfType(type._anyType);
+        } else if (!type.isNamedTypeSymbol()) {
+            structure = getIDForTypeSubstitutionsFromObjectType(type);
+        }
+
+        if (!structure) {
+            structure = type.pullSymbolID + "#";
+        }
+
+        return structure;
+    }
+
+    function getIDForTypeSubstitutionsFromObjectType(type) {
+        if (type.isResolved) {
+            var getIDForTypeSubStitutionWalker = new GetIDForTypeSubStitutionWalker();
+            TypeScript.PullHelpers.walkPullTypeSymbolStructure(type, getIDForTypeSubStitutionWalker);
+        }
+
+        return null;
+    }
+
+    var GetIDForTypeSubStitutionWalker = (function () {
+        function GetIDForTypeSubStitutionWalker() {
+            this.structure = "";
+        }
+        GetIDForTypeSubStitutionWalker.prototype.memberSymbolWalk = function (memberSymbol) {
+            this.structure += memberSymbol.name + "@" + getIDForTypeSubstitutionsOfType(memberSymbol.type);
+            return true;
+        };
+        GetIDForTypeSubStitutionWalker.prototype.callSignatureWalk = function (signatureSymbol) {
+            this.structure += "(";
+            return true;
+        };
+        GetIDForTypeSubStitutionWalker.prototype.constructSignatureWalk = function (signatureSymbol) {
+            this.structure += "new(";
+            return true;
+        };
+        GetIDForTypeSubStitutionWalker.prototype.indexSignatureWalk = function (signatureSymbol) {
+            this.structure += "[](";
+            return true;
+        };
+        GetIDForTypeSubStitutionWalker.prototype.signatureParameterWalk = function (parameterSymbol) {
+            this.structure += parameterSymbol.name + "@" + getIDForTypeSubstitutionsOfType(parameterSymbol.type);
+            return true;
+        };
+        GetIDForTypeSubStitutionWalker.prototype.signatureReturnTypeWalk = function (returnType) {
+            this.structure += ")" + getIDForTypeSubstitutionsOfType(returnType);
+            return true;
+        };
+        return GetIDForTypeSubStitutionWalker;
+    })();
+
+    (function (GetAllMembersVisiblity) {
+        GetAllMembersVisiblity[GetAllMembersVisiblity["all"] = 0] = "all";
+
+        GetAllMembersVisiblity[GetAllMembersVisiblity["internallyVisible"] = 1] = "internallyVisible";
+
+        GetAllMembersVisiblity[GetAllMembersVisiblity["externallyVisible"] = 2] = "externallyVisible";
+    })(TypeScript.GetAllMembersVisiblity || (TypeScript.GetAllMembersVisiblity = {}));
+    var GetAllMembersVisiblity = TypeScript.GetAllMembersVisiblity;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var PullTypeEnclosingTypeWalker = (function () {
+        function PullTypeEnclosingTypeWalker() {
+            this.currentSymbols = null;
+        }
+        PullTypeEnclosingTypeWalker.prototype.getEnclosingType = function () {
+            if (this.currentSymbols && this.currentSymbols.length > 0) {
+                return this.currentSymbols[0];
+            }
+
+            return null;
+        };
+
+        PullTypeEnclosingTypeWalker.prototype._canWalkStructure = function () {
+            var enclosingType = this.getEnclosingType();
+            return !!enclosingType && enclosingType.isGeneric();
+        };
+
+        PullTypeEnclosingTypeWalker.prototype._getCurrentSymbol = function () {
+            if (this.currentSymbols && this.currentSymbols.length) {
+                return this.currentSymbols[this.currentSymbols.length - 1];
+            }
+
+            return null;
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.getGenerativeClassification = function () {
+            if (this._canWalkStructure()) {
+                var currentType = this.currentSymbols[this.currentSymbols.length - 1];
+                if (!currentType) {
+                    return 0 /* Unknown */;
+                }
+
+                var variableNeededToFixNodeJitterBug = this.getEnclosingType();
+
+                return currentType.getGenerativeTypeClassification(variableNeededToFixNodeJitterBug);
+            }
+
+            return 2 /* Closed */;
+        };
+
+        PullTypeEnclosingTypeWalker.prototype._pushSymbol = function (symbol) {
+            return this.currentSymbols.push(symbol);
+        };
+
+        PullTypeEnclosingTypeWalker.prototype._popSymbol = function () {
+            return this.currentSymbols.pop();
+        };
+
+        PullTypeEnclosingTypeWalker.prototype._setEnclosingTypeOfParentDecl = function (decl, setSignature) {
+            var parentDecl = decl.getParentDecl();
+            if (parentDecl) {
+                if (parentDecl.kind & 8216 /* SomeInstantiatableType */) {
+                    this._setEnclosingTypeWorker(parentDecl.getSymbol(), true);
+                } else {
+                    this._setEnclosingTypeOfParentDecl(parentDecl, true);
+                }
+
+                if (this._canWalkStructure()) {
+                    var symbol = decl.getSymbol();
+                    if (symbol) {
+                        if (!symbol.isType() && !symbol.isSignature()) {
+                            symbol = symbol.type;
+                        }
+
+                        this._pushSymbol(symbol);
+                    }
+
+                    if (setSignature) {
+                        var signature = decl.getSignatureSymbol();
+                        if (signature) {
+                            this._pushSymbol(signature);
+                        }
+                    }
+                }
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype._setEnclosingTypeWorker = function (symbol, setSignature) {
+            if (symbol.isType() && symbol.isNamedTypeSymbol()) {
+                this.currentSymbols = [TypeScript.PullHelpers.getRootType(symbol)];
+                return;
+            }
+
+            var decls = symbol.getDeclarations();
+            for (var i = 0; i < decls.length; i++) {
+                var decl = decls[i];
+                this._setEnclosingTypeOfParentDecl(decl, setSignature);
+                if (this._canWalkStructure()) {
+                    return;
+                }
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.setCurrentSymbol = function (symbol) {
+            TypeScript.Debug.assert(this._canWalkStructure());
+            this.currentSymbols[this.currentSymbols.length - 1] = symbol;
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.startWalkingType = function (symbol) {
+            var currentSymbols = this.currentSymbols;
+
+            var setEnclosingType = !this.getEnclosingType() || symbol.isNamedTypeSymbol();
+            if (setEnclosingType) {
+                this.currentSymbols = null;
+                this.setEnclosingType(symbol);
+            }
+            return currentSymbols;
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.endWalkingType = function (currentSymbolsWhenStartedWalkingTypes) {
+            this.currentSymbols = currentSymbolsWhenStartedWalkingTypes;
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.setEnclosingType = function (symbol) {
+            TypeScript.Debug.assert(!this.getEnclosingType());
+            this._setEnclosingTypeWorker(symbol, symbol.isSignature());
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.walkMemberType = function (memberName, resolver) {
+            if (this._canWalkStructure()) {
+                var currentType = this._getCurrentSymbol();
+                var memberSymbol = currentType ? resolver._getNamedPropertySymbolOfAugmentedType(memberName, currentType) : null;
+                this._pushSymbol(memberSymbol ? memberSymbol.type : null);
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.postWalkMemberType = function () {
+            if (this._canWalkStructure()) {
+                this._popSymbol();
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.walkSignature = function (kind, index) {
+            if (this._canWalkStructure()) {
+                var currentType = this._getCurrentSymbol();
+                var signatures;
+                if (currentType) {
+                    if (kind == 1048576 /* CallSignature */) {
+                        signatures = currentType.getCallSignatures();
+                    } else if (kind == 2097152 /* ConstructSignature */) {
+                        signatures = currentType.getConstructSignatures();
+                    } else {
+                        signatures = currentType.getIndexSignatures();
+                    }
+                }
+
+                this._pushSymbol(signatures ? signatures[index] : null);
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.postWalkSignature = function () {
+            if (this._canWalkStructure()) {
+                this._popSymbol();
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.walkTypeArgument = function (index) {
+            if (this._canWalkStructure()) {
+                var typeArgument = null;
+                var currentType = this._getCurrentSymbol();
+                if (currentType) {
+                    var typeArguments = currentType.getTypeArguments();
+                    typeArgument = typeArguments ? typeArguments[index] : null;
+                }
+                this._pushSymbol(typeArgument);
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.postWalkTypeArgument = function () {
+            if (this._canWalkStructure()) {
+                this._popSymbol();
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.walkTypeParameterConstraint = function (index) {
+            if (this._canWalkStructure()) {
+                var typeParameters;
+                var currentSymbol = this._getCurrentSymbol();
+                if (currentSymbol) {
+                    if (currentSymbol.isSignature()) {
+                        typeParameters = currentSymbol.getTypeParameters();
+                    } else {
+                        TypeScript.Debug.assert(currentSymbol.isType());
+                        typeParameters = currentSymbol.getTypeParameters();
+                    }
+                }
+                this._pushSymbol(typeParameters ? typeParameters[index].getConstraint() : null);
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.postWalkTypeParameterConstraint = function () {
+            if (this._canWalkStructure()) {
+                this._popSymbol();
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.walkReturnType = function () {
+            if (this._canWalkStructure()) {
+                var currentSignature = this._getCurrentSymbol();
+                this._pushSymbol(currentSignature ? currentSignature.returnType : null);
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.postWalkReturnType = function () {
+            if (this._canWalkStructure()) {
+                this._popSymbol();
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.walkParameterType = function (iParam) {
+            if (this._canWalkStructure()) {
+                var currentSignature = this._getCurrentSymbol();
+                this._pushSymbol(currentSignature ? currentSignature.getParameterTypeAtIndex(iParam) : null);
+            }
+        };
+        PullTypeEnclosingTypeWalker.prototype.postWalkParameterType = function () {
+            if (this._canWalkStructure()) {
+                this._popSymbol();
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.getBothKindOfIndexSignatures = function (resolver, context, includeAugmentedType) {
+            if (this._canWalkStructure()) {
+                var currentType = this._getCurrentSymbol();
+                if (currentType) {
+                    return resolver._getBothKindsOfIndexSignatures(currentType, context, includeAugmentedType);
+                }
+            }
+            return null;
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.walkIndexSignatureReturnType = function (indexSigInfo, useStringIndexSignature, onlySignature) {
+            if (this._canWalkStructure()) {
+                var indexSig = indexSigInfo ? (useStringIndexSignature ? indexSigInfo.stringSignature : indexSigInfo.numericSignature) : null;
+                this._pushSymbol(indexSig);
+                if (!onlySignature) {
+                    this._pushSymbol(indexSig ? indexSig.returnType : null);
+                }
+            }
+        };
+
+        PullTypeEnclosingTypeWalker.prototype.postWalkIndexSignatureReturnType = function (onlySignature) {
+            if (this._canWalkStructure()) {
+                if (!onlySignature) {
+                    this._popSymbol();
+                }
+                this._popSymbol();
+            }
+        };
+        return PullTypeEnclosingTypeWalker;
+    })();
+    TypeScript.PullTypeEnclosingTypeWalker = PullTypeEnclosingTypeWalker;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var CandidateInferenceInfo = (function () {
+        function CandidateInferenceInfo() {
+            this.typeParameter = null;
+            this._inferredTypeAfterFixing = null;
+            this.inferenceCandidates = [];
+        }
+        CandidateInferenceInfo.prototype.addCandidate = function (candidate) {
+            if (!this._inferredTypeAfterFixing) {
+                this.inferenceCandidates[this.inferenceCandidates.length] = candidate;
+            }
+        };
+
+        CandidateInferenceInfo.prototype.isFixed = function () {
+            return !!this._inferredTypeAfterFixing;
+        };
+
+        CandidateInferenceInfo.prototype.fixTypeParameter = function (resolver, context) {
+            var _this = this;
+            if (!this._inferredTypeAfterFixing) {
+                var collection = {
+                    getLength: function () {
+                        return _this.inferenceCandidates.length;
+                    },
+                    getTypeAtIndex: function (index) {
+                        return _this.inferenceCandidates[index].type;
+                    }
+                };
+
+                var bestCommonType = resolver.findBestCommonType(collection, context, new TypeScript.TypeComparisonInfo());
+                this._inferredTypeAfterFixing = bestCommonType.widenedType(resolver, null, context);
+            }
+        };
+        return CandidateInferenceInfo;
+    })();
+    TypeScript.CandidateInferenceInfo = CandidateInferenceInfo;
+
+    var TypeArgumentInferenceContext = (function () {
+        function TypeArgumentInferenceContext(resolver, context, signatureBeingInferred) {
+            this.resolver = resolver;
+            this.context = context;
+            this.signatureBeingInferred = signatureBeingInferred;
+            this.inferenceCache = TypeScript.BitMatrix.getBitMatrix(false);
+            this.candidateCache = [];
+            var typeParameters = signatureBeingInferred.getTypeParameters();
+            for (var i = 0; i < typeParameters.length; i++) {
+                this.addInferenceRoot(typeParameters[i]);
+            }
+        }
+        TypeArgumentInferenceContext.prototype.alreadyRelatingTypes = function (objectType, parameterType) {
+            if (this.inferenceCache.valueAt(objectType.pullSymbolID, parameterType.pullSymbolID)) {
+                return true;
+            } else {
+                this.inferenceCache.setValueAt(objectType.pullSymbolID, parameterType.pullSymbolID, true);
+                return false;
+            }
+        };
+
+        TypeArgumentInferenceContext.prototype.resetRelationshipCache = function () {
+            this.inferenceCache.release();
+            this.inferenceCache = TypeScript.BitMatrix.getBitMatrix(false);
+        };
+
+        TypeArgumentInferenceContext.prototype.addInferenceRoot = function (param) {
+            var info = this.candidateCache[param.pullSymbolID];
+
+            if (!info) {
+                info = new CandidateInferenceInfo();
+                info.typeParameter = param;
+                this.candidateCache[param.pullSymbolID] = info;
+            }
+        };
+
+        TypeArgumentInferenceContext.prototype.getInferenceInfo = function (param) {
+            return this.candidateCache[param.pullSymbolID];
+        };
+
+        TypeArgumentInferenceContext.prototype.addCandidateForInference = function (param, candidate) {
+            var info = this.getInferenceInfo(param);
+
+            if (info && candidate && info.inferenceCandidates.indexOf(candidate) < 0) {
+                info.addCandidate(candidate);
+            }
+        };
+
+        TypeArgumentInferenceContext.prototype.inferTypeArguments = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        TypeArgumentInferenceContext.prototype.fixTypeParameter = function (typeParameter) {
+            var candidateInfo = this.candidateCache[typeParameter.pullSymbolID];
+            if (candidateInfo) {
+                candidateInfo.fixTypeParameter(this.resolver, this.context);
+            }
+        };
+
+        TypeArgumentInferenceContext.prototype._finalizeInferredTypeArguments = function () {
+            var results = [];
+            var typeParameters = this.signatureBeingInferred.getTypeParameters();
+            for (var i = 0; i < typeParameters.length; i++) {
+                var info = this.candidateCache[typeParameters[i].pullSymbolID];
+
+                info.fixTypeParameter(this.resolver, this.context);
+
+                for (var i = 0; i < results.length; i++) {
+                    if (results[i].type === info.typeParameter) {
+                        results[i].type = info._inferredTypeAfterFixing;
+                    }
+                }
+
+                results.push(info._inferredTypeAfterFixing);
+            }
+
+            return results;
+        };
+
+        TypeArgumentInferenceContext.prototype.isInvocationInferenceContext = function () {
+            throw TypeScript.Errors.abstract();
+        };
+        return TypeArgumentInferenceContext;
+    })();
+    TypeScript.TypeArgumentInferenceContext = TypeArgumentInferenceContext;
+
+    var InvocationTypeArgumentInferenceContext = (function (_super) {
+        __extends(InvocationTypeArgumentInferenceContext, _super);
+        function InvocationTypeArgumentInferenceContext(resolver, context, signatureBeingInferred, argumentASTs) {
+            _super.call(this, resolver, context, signatureBeingInferred);
+            this.argumentASTs = argumentASTs;
+        }
+        InvocationTypeArgumentInferenceContext.prototype.isInvocationInferenceContext = function () {
+            return true;
+        };
+
+        InvocationTypeArgumentInferenceContext.prototype.inferTypeArguments = function () {
+            var _this = this;
+            this.signatureBeingInferred.forAllParameterTypes(this.argumentASTs.nonSeparatorCount(), function (parameterType, argumentIndex) {
+                var argumentAST = _this.argumentASTs.nonSeparatorAt(argumentIndex);
+
+                _this.context.pushInferentialType(parameterType, _this);
+                var argumentType = _this.resolver.resolveAST(argumentAST, true, _this.context).type;
+                _this.resolver.relateTypeToTypeParametersWithNewEnclosingTypes(argumentType, parameterType, _this, _this.context);
+                _this.context.popAnyContextualType();
+
+                return true;
+            });
+
+            return this._finalizeInferredTypeArguments();
+        };
+        return InvocationTypeArgumentInferenceContext;
+    })(TypeArgumentInferenceContext);
+    TypeScript.InvocationTypeArgumentInferenceContext = InvocationTypeArgumentInferenceContext;
+
+    var ContextualSignatureInstantiationTypeArgumentInferenceContext = (function (_super) {
+        __extends(ContextualSignatureInstantiationTypeArgumentInferenceContext, _super);
+        function ContextualSignatureInstantiationTypeArgumentInferenceContext(resolver, context, signatureBeingInferred, contextualSignature, shouldFixContextualSignatureParameterTypes) {
+            _super.call(this, resolver, context, signatureBeingInferred);
+            this.contextualSignature = contextualSignature;
+            this.shouldFixContextualSignatureParameterTypes = shouldFixContextualSignatureParameterTypes;
+        }
+        ContextualSignatureInstantiationTypeArgumentInferenceContext.prototype.isInvocationInferenceContext = function () {
+            return false;
+        };
+
+        ContextualSignatureInstantiationTypeArgumentInferenceContext.prototype.inferTypeArguments = function () {
+            var _this = this;
+            var relateTypesCallback = function (parameterTypeBeingInferred, contextualParameterType) {
+                if (_this.shouldFixContextualSignatureParameterTypes) {
+                    contextualParameterType = _this.context.fixAllTypeParametersReferencedByType(contextualParameterType, _this.resolver, _this);
+                }
+                _this.resolver.relateTypeToTypeParametersWithNewEnclosingTypes(contextualParameterType, parameterTypeBeingInferred, _this, _this.context);
+
+                return true;
+            };
+
+            this.signatureBeingInferred.forAllCorrespondingParameterTypesInThisAndOtherSignature(this.contextualSignature, relateTypesCallback);
+
+            return this._finalizeInferredTypeArguments();
+        };
+        return ContextualSignatureInstantiationTypeArgumentInferenceContext;
+    })(TypeArgumentInferenceContext);
+    TypeScript.ContextualSignatureInstantiationTypeArgumentInferenceContext = ContextualSignatureInstantiationTypeArgumentInferenceContext;
+
+    var PullContextualTypeContext = (function () {
+        function PullContextualTypeContext(contextualType, provisional, isInferentiallyTyping, typeArgumentInferenceContext) {
+            this.contextualType = contextualType;
+            this.provisional = provisional;
+            this.isInferentiallyTyping = isInferentiallyTyping;
+            this.typeArgumentInferenceContext = typeArgumentInferenceContext;
+            this.provisionallyTypedSymbols = [];
+            this.hasProvisionalErrors = false;
+            this.astSymbolMap = [];
+        }
+        PullContextualTypeContext.prototype.recordProvisionallyTypedSymbol = function (symbol) {
+            this.provisionallyTypedSymbols[this.provisionallyTypedSymbols.length] = symbol;
+        };
+
+        PullContextualTypeContext.prototype.invalidateProvisionallyTypedSymbols = function () {
+            for (var i = 0; i < this.provisionallyTypedSymbols.length; i++) {
+                this.provisionallyTypedSymbols[i].setUnresolved();
+            }
+        };
+
+        PullContextualTypeContext.prototype.setSymbolForAST = function (ast, symbol) {
+            this.astSymbolMap[ast.syntaxID()] = symbol;
+        };
+
+        PullContextualTypeContext.prototype.getSymbolForAST = function (ast) {
+            return this.astSymbolMap[ast.syntaxID()];
+        };
+        return PullContextualTypeContext;
+    })();
+    TypeScript.PullContextualTypeContext = PullContextualTypeContext;
+
+    var PullTypeResolutionContext = (function () {
+        function PullTypeResolutionContext(resolver, inTypeCheck, fileName) {
+            if (typeof inTypeCheck === "undefined") { inTypeCheck = false; }
+            if (typeof fileName === "undefined") { fileName = null; }
+            this.resolver = resolver;
+            this.inTypeCheck = inTypeCheck;
+            this.fileName = fileName;
+            this.contextStack = [];
+            this.typeCheckedNodes = null;
+            this.enclosingTypeWalker1 = null;
+            this.enclosingTypeWalker2 = null;
+            this.inBaseTypeResolution = false;
+            if (inTypeCheck) {
+                TypeScript.Debug.assert(fileName, "A file name must be provided if you are typechecking");
+                this.typeCheckedNodes = TypeScript.BitVector.getBitVector(false);
+            }
+        }
+        PullTypeResolutionContext.prototype.setTypeChecked = function (ast) {
+            if (!this.inProvisionalResolution()) {
+                this.typeCheckedNodes.setValueAt(ast.syntaxID(), true);
+            }
+        };
+
+        PullTypeResolutionContext.prototype.canTypeCheckAST = function (ast) {
+            return this.typeCheck() && !this.typeCheckedNodes.valueAt(ast.syntaxID()) && this.fileName === ast.fileName();
+        };
+
+        PullTypeResolutionContext.prototype._pushAnyContextualType = function (type, provisional, isInferentiallyTyping, argContext) {
+            this.contextStack.push(new PullContextualTypeContext(type, provisional, isInferentiallyTyping, argContext));
+        };
+
+        PullTypeResolutionContext.prototype.pushNewContextualType = function (type) {
+            this._pushAnyContextualType(type, this.inProvisionalResolution(), false, null);
+        };
+
+        PullTypeResolutionContext.prototype.propagateContextualType = function (type) {
+            this._pushAnyContextualType(type, this.inProvisionalResolution(), this.isInferentiallyTyping(), this.getCurrentTypeArgumentInferenceContext());
+        };
+
+        PullTypeResolutionContext.prototype.pushInferentialType = function (type, typeArgumentInferenceContext) {
+            this._pushAnyContextualType(type, true, true, typeArgumentInferenceContext);
+        };
+
+        PullTypeResolutionContext.prototype.pushProvisionalType = function (type) {
+            this._pushAnyContextualType(type, true, false, null);
+        };
+
+        PullTypeResolutionContext.prototype.popAnyContextualType = function () {
+            var tc = this.contextStack.pop();
+
+            tc.invalidateProvisionallyTypedSymbols();
+
+            if (tc.hasProvisionalErrors && this.inProvisionalResolution()) {
+                this.contextStack[this.contextStack.length - 1].hasProvisionalErrors = true;
+            }
+
+            return tc;
+        };
+
+        PullTypeResolutionContext.prototype.hasProvisionalErrors = function () {
+            return this.contextStack.length ? this.contextStack[this.contextStack.length - 1].hasProvisionalErrors : false;
+        };
+
+        PullTypeResolutionContext.prototype.getContextualType = function () {
+            var context = !this.contextStack.length ? null : this.contextStack[this.contextStack.length - 1];
+
+            if (context) {
+                var type = context.contextualType;
+
+                if (!type) {
+                    return null;
+                }
+
+                return type;
+            }
+
+            return null;
+        };
+
+        PullTypeResolutionContext.prototype.fixAllTypeParametersReferencedByType = function (type, resolver, argContext) {
+            var argContext = this.getCurrentTypeArgumentInferenceContext();
+            if (type.wrapsSomeTypeParameter(argContext.candidateCache)) {
+                var typeParameterArgumentMap = [];
+
+                for (var n in argContext.candidateCache) {
+                    var typeParameter = argContext.candidateCache[n] && argContext.candidateCache[n].typeParameter;
+                    if (typeParameter) {
+                        var dummyMap = [];
+                        dummyMap[typeParameter.pullSymbolID] = typeParameter;
+                        if (type.wrapsSomeTypeParameter(dummyMap)) {
+                            argContext.fixTypeParameter(typeParameter);
+                            TypeScript.Debug.assert(argContext.candidateCache[n]._inferredTypeAfterFixing);
+                            typeParameterArgumentMap[typeParameter.pullSymbolID] = argContext.candidateCache[n]._inferredTypeAfterFixing;
+                        }
+                    }
+                }
+
+                return resolver.instantiateType(type, typeParameterArgumentMap);
+            }
+
+            return type;
+        };
+
+        PullTypeResolutionContext.prototype.getCurrentTypeArgumentInferenceContext = function () {
+            return this.contextStack.length ? this.contextStack[this.contextStack.length - 1].typeArgumentInferenceContext : null;
+        };
+
+        PullTypeResolutionContext.prototype.isInferentiallyTyping = function () {
+            return this.contextStack.length > 0 && this.contextStack[this.contextStack.length - 1].isInferentiallyTyping;
+        };
+
+        PullTypeResolutionContext.prototype.inProvisionalResolution = function () {
+            return (!this.contextStack.length ? false : this.contextStack[this.contextStack.length - 1].provisional);
+        };
+
+        PullTypeResolutionContext.prototype.isInBaseTypeResolution = function () {
+            return this.inBaseTypeResolution;
+        };
+
+        PullTypeResolutionContext.prototype.startBaseTypeResolution = function () {
+            var wasInBaseTypeResoltion = this.inBaseTypeResolution;
+            this.inBaseTypeResolution = true;
+            return wasInBaseTypeResoltion;
+        };
+
+        PullTypeResolutionContext.prototype.doneBaseTypeResolution = function (wasInBaseTypeResolution) {
+            this.inBaseTypeResolution = wasInBaseTypeResolution;
+        };
+
+        PullTypeResolutionContext.prototype.setTypeInContext = function (symbol, type) {
+            if (symbol.type && symbol.type.isError() && !type.isError()) {
+                return;
+            }
+            symbol.type = type;
+
+            if (this.contextStack.length && this.inProvisionalResolution()) {
+                this.contextStack[this.contextStack.length - 1].recordProvisionallyTypedSymbol(symbol);
+            }
+        };
+
+        PullTypeResolutionContext.prototype.postDiagnostic = function (diagnostic) {
+            if (diagnostic) {
+                if (this.inProvisionalResolution()) {
+                    (this.contextStack[this.contextStack.length - 1]).hasProvisionalErrors = true;
+                } else if (this.inTypeCheck && this.resolver) {
+                    this.resolver.semanticInfoChain.addDiagnostic(diagnostic);
+                }
+            }
+        };
+
+        PullTypeResolutionContext.prototype.typeCheck = function () {
+            return this.inTypeCheck && !this.inProvisionalResolution();
+        };
+
+        PullTypeResolutionContext.prototype.setSymbolForAST = function (ast, symbol) {
+            this.contextStack[this.contextStack.length - 1].setSymbolForAST(ast, symbol);
+        };
+
+        PullTypeResolutionContext.prototype.getSymbolForAST = function (ast) {
+            for (var i = this.contextStack.length - 1; i >= 0; i--) {
+                var typeContext = this.contextStack[i];
+                if (!typeContext.provisional) {
+                    break;
+                }
+
+                var symbol = typeContext.getSymbolForAST(ast);
+                if (symbol) {
+                    return symbol;
+                }
+            }
+
+            return null;
+        };
+
+        PullTypeResolutionContext.prototype.startWalkingTypes = function (symbol1, symbol2) {
+            if (!this.enclosingTypeWalker1) {
+                this.enclosingTypeWalker1 = new TypeScript.PullTypeEnclosingTypeWalker();
+            }
+            var symbolsWhenStartedWalkingTypes1 = this.enclosingTypeWalker1.startWalkingType(symbol1);
+            if (!this.enclosingTypeWalker2) {
+                this.enclosingTypeWalker2 = new TypeScript.PullTypeEnclosingTypeWalker();
+            }
+            var symbolsWhenStartedWalkingTypes2 = this.enclosingTypeWalker2.startWalkingType(symbol2);
+            return { symbolsWhenStartedWalkingTypes1: symbolsWhenStartedWalkingTypes1, symbolsWhenStartedWalkingTypes2: symbolsWhenStartedWalkingTypes2 };
+        };
+
+        PullTypeResolutionContext.prototype.endWalkingTypes = function (symbolsWhenStartedWalkingTypes) {
+            this.enclosingTypeWalker1.endWalkingType(symbolsWhenStartedWalkingTypes.symbolsWhenStartedWalkingTypes1);
+            this.enclosingTypeWalker2.endWalkingType(symbolsWhenStartedWalkingTypes.symbolsWhenStartedWalkingTypes2);
+        };
+
+        PullTypeResolutionContext.prototype.setEnclosingTypes = function (symbol1, symbol2) {
+            if (!this.enclosingTypeWalker1) {
+                this.enclosingTypeWalker1 = new TypeScript.PullTypeEnclosingTypeWalker();
+            }
+            this.enclosingTypeWalker1.setEnclosingType(symbol1);
+            if (!this.enclosingTypeWalker2) {
+                this.enclosingTypeWalker2 = new TypeScript.PullTypeEnclosingTypeWalker();
+            }
+            this.enclosingTypeWalker2.setEnclosingType(symbol2);
+        };
+
+        PullTypeResolutionContext.prototype.walkMemberTypes = function (memberName) {
+            this.enclosingTypeWalker1.walkMemberType(memberName, this.resolver);
+            this.enclosingTypeWalker2.walkMemberType(memberName, this.resolver);
+        };
+
+        PullTypeResolutionContext.prototype.postWalkMemberTypes = function () {
+            this.enclosingTypeWalker1.postWalkMemberType();
+            this.enclosingTypeWalker2.postWalkMemberType();
+        };
+
+        PullTypeResolutionContext.prototype.walkSignatures = function (kind, index, index2) {
+            this.enclosingTypeWalker1.walkSignature(kind, index);
+            this.enclosingTypeWalker2.walkSignature(kind, index2 == undefined ? index : index2);
+        };
+
+        PullTypeResolutionContext.prototype.postWalkSignatures = function () {
+            this.enclosingTypeWalker1.postWalkSignature();
+            this.enclosingTypeWalker2.postWalkSignature();
+        };
+
+        PullTypeResolutionContext.prototype.walkTypeParameterConstraints = function (index) {
+            this.enclosingTypeWalker1.walkTypeParameterConstraint(index);
+            this.enclosingTypeWalker2.walkTypeParameterConstraint(index);
+        };
+
+        PullTypeResolutionContext.prototype.postWalkTypeParameterConstraints = function () {
+            this.enclosingTypeWalker1.postWalkTypeParameterConstraint();
+            this.enclosingTypeWalker2.postWalkTypeParameterConstraint();
+        };
+
+        PullTypeResolutionContext.prototype.walkTypeArgument = function (index) {
+            this.enclosingTypeWalker1.walkTypeArgument(index);
+            this.enclosingTypeWalker2.walkTypeArgument(index);
+        };
+
+        PullTypeResolutionContext.prototype.postWalkTypeArgument = function () {
+            this.enclosingTypeWalker1.postWalkTypeArgument();
+            this.enclosingTypeWalker2.postWalkTypeArgument();
+        };
+
+        PullTypeResolutionContext.prototype.walkReturnTypes = function () {
+            this.enclosingTypeWalker1.walkReturnType();
+            this.enclosingTypeWalker2.walkReturnType();
+        };
+
+        PullTypeResolutionContext.prototype.postWalkReturnTypes = function () {
+            this.enclosingTypeWalker1.postWalkReturnType();
+            this.enclosingTypeWalker2.postWalkReturnType();
+        };
+
+        PullTypeResolutionContext.prototype.walkParameterTypes = function (iParam) {
+            this.enclosingTypeWalker1.walkParameterType(iParam);
+            this.enclosingTypeWalker2.walkParameterType(iParam);
+        };
+
+        PullTypeResolutionContext.prototype.postWalkParameterTypes = function () {
+            this.enclosingTypeWalker1.postWalkParameterType();
+            this.enclosingTypeWalker2.postWalkParameterType();
+        };
+
+        PullTypeResolutionContext.prototype.getBothKindOfIndexSignatures = function (includeAugmentedType1, includeAugmentedType2) {
+            var indexSigs1 = this.enclosingTypeWalker1.getBothKindOfIndexSignatures(this.resolver, this, includeAugmentedType1);
+            var indexSigs2 = this.enclosingTypeWalker2.getBothKindOfIndexSignatures(this.resolver, this, includeAugmentedType2);
+            return { indexSigs1: indexSigs1, indexSigs2: indexSigs2 };
+        };
+
+        PullTypeResolutionContext.prototype.walkIndexSignatureReturnTypes = function (indexSigs, useStringIndexSignature1, useStringIndexSignature2, onlySignature) {
+            this.enclosingTypeWalker1.walkIndexSignatureReturnType(indexSigs.indexSigs1, useStringIndexSignature1, onlySignature);
+            this.enclosingTypeWalker2.walkIndexSignatureReturnType(indexSigs.indexSigs2, useStringIndexSignature2, onlySignature);
+        };
+
+        PullTypeResolutionContext.prototype.postWalkIndexSignatureReturnTypes = function (onlySignature) {
+            this.enclosingTypeWalker1.postWalkIndexSignatureReturnType(onlySignature);
+            this.enclosingTypeWalker2.postWalkIndexSignatureReturnType(onlySignature);
+        };
+
+        PullTypeResolutionContext.prototype.swapEnclosingTypeWalkers = function () {
+            var tempEnclosingWalker1 = this.enclosingTypeWalker1;
+            this.enclosingTypeWalker1 = this.enclosingTypeWalker2;
+            this.enclosingTypeWalker2 = tempEnclosingWalker1;
+        };
+
+        PullTypeResolutionContext.prototype.oneOfClassificationsIsInfinitelyExpanding = function () {
+            var generativeClassification1 = this.enclosingTypeWalker1.getGenerativeClassification();
+            if (generativeClassification1 === 3 /* InfinitelyExpanding */) {
+                return true;
+            }
+            var generativeClassification2 = this.enclosingTypeWalker2.getGenerativeClassification();
+            if (generativeClassification2 === 3 /* InfinitelyExpanding */) {
+                return true;
+            }
+
+            return false;
+        };
+
+        PullTypeResolutionContext.prototype.resetEnclosingTypeWalkers = function () {
+            var enclosingTypeWalker1 = this.enclosingTypeWalker1;
+            var enclosingTypeWalker2 = this.enclosingTypeWalker2;
+            this.enclosingTypeWalker1 = null;
+            this.enclosingTypeWalker2 = null;
+            return {
+                enclosingTypeWalker1: enclosingTypeWalker1,
+                enclosingTypeWalker2: enclosingTypeWalker2
+            };
+        };
+
+        PullTypeResolutionContext.prototype.setEnclosingTypeWalkers = function (enclosingTypeWalkers) {
+            this.enclosingTypeWalker1 = enclosingTypeWalkers.enclosingTypeWalker1;
+            this.enclosingTypeWalker2 = enclosingTypeWalkers.enclosingTypeWalker2;
+        };
+        return PullTypeResolutionContext;
+    })();
+    TypeScript.PullTypeResolutionContext = PullTypeResolutionContext;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var OverloadApplicabilityStatus;
+    (function (OverloadApplicabilityStatus) {
+        OverloadApplicabilityStatus[OverloadApplicabilityStatus["NotAssignable"] = 0] = "NotAssignable";
+        OverloadApplicabilityStatus[OverloadApplicabilityStatus["AssignableButWithProvisionalErrors"] = 1] = "AssignableButWithProvisionalErrors";
+        OverloadApplicabilityStatus[OverloadApplicabilityStatus["AssignableWithNoProvisionalErrors"] = 2] = "AssignableWithNoProvisionalErrors";
+        OverloadApplicabilityStatus[OverloadApplicabilityStatus["Subtype"] = 3] = "Subtype";
+    })(OverloadApplicabilityStatus || (OverloadApplicabilityStatus = {}));
+
+    var PullAdditionalCallResolutionData = (function () {
+        function PullAdditionalCallResolutionData() {
+            this.targetSymbol = null;
+            this.resolvedSignatures = null;
+            this.candidateSignature = null;
+            this.actualParametersContextTypeSymbols = null;
+            this.diagnosticsFromOverloadResolution = [];
+        }
+        return PullAdditionalCallResolutionData;
+    })();
+    TypeScript.PullAdditionalCallResolutionData = PullAdditionalCallResolutionData;
+
+    var PullAdditionalObjectLiteralResolutionData = (function () {
+        function PullAdditionalObjectLiteralResolutionData() {
+            this.membersContextTypeSymbols = null;
+        }
+        return PullAdditionalObjectLiteralResolutionData;
+    })();
+    TypeScript.PullAdditionalObjectLiteralResolutionData = PullAdditionalObjectLiteralResolutionData;
+
+    var MemberWithBaseOrigin = (function () {
+        function MemberWithBaseOrigin(memberSymbol, baseOrigin) {
+            this.memberSymbol = memberSymbol;
+            this.baseOrigin = baseOrigin;
+        }
+        return MemberWithBaseOrigin;
+    })();
+
+    var SignatureWithBaseOrigin = (function () {
+        function SignatureWithBaseOrigin(signature, baseOrigin) {
+            this.signature = signature;
+            this.baseOrigin = baseOrigin;
+        }
+        return SignatureWithBaseOrigin;
+    })();
+
+    var InheritedIndexSignatureInfo = (function () {
+        function InheritedIndexSignatureInfo() {
+        }
+        return InheritedIndexSignatureInfo;
+    })();
+
+    var CompilerReservedName;
+    (function (CompilerReservedName) {
+        CompilerReservedName[CompilerReservedName["_this"] = 1] = "_this";
+        CompilerReservedName[CompilerReservedName["_super"] = 2] = "_super";
+        CompilerReservedName[CompilerReservedName["arguments"] = 3] = "arguments";
+        CompilerReservedName[CompilerReservedName["_i"] = 4] = "_i";
+        CompilerReservedName[CompilerReservedName["require"] = 5] = "require";
+        CompilerReservedName[CompilerReservedName["exports"] = 6] = "exports";
+    })(CompilerReservedName || (CompilerReservedName = {}));
+
+    function getCompilerReservedName(name) {
+        var nameText = name.valueText();
+        return CompilerReservedName[nameText];
+    }
+
+    var PullTypeResolver = (function () {
+        function PullTypeResolver(compilationSettings, semanticInfoChain) {
+            this.compilationSettings = compilationSettings;
+            this.semanticInfoChain = semanticInfoChain;
+            this._cachedArrayInterfaceType = null;
+            this._cachedNumberInterfaceType = null;
+            this._cachedStringInterfaceType = null;
+            this._cachedBooleanInterfaceType = null;
+            this._cachedObjectInterfaceType = null;
+            this._cachedFunctionInterfaceType = null;
+            this._cachedIArgumentsInterfaceType = null;
+            this._cachedRegExpInterfaceType = null;
+            this._cachedAnyTypeArgs = null;
+            this.typeCheckCallBacks = [];
+            this.postTypeCheckWorkitems = [];
+            this._cachedFunctionArgumentsSymbol = null;
+            this.assignableCache = TypeScript.BitMatrix.getBitMatrix(true);
+            this.subtypeCache = TypeScript.BitMatrix.getBitMatrix(true);
+            this.identicalCache = TypeScript.BitMatrix.getBitMatrix(true);
+            this.inResolvingOtherDeclsWalker = new TypeScript.PullHelpers.OtherPullDeclsWalker();
+        }
+        PullTypeResolver.prototype.cachedArrayInterfaceType = function () {
+            if (!this._cachedArrayInterfaceType) {
+                this._cachedArrayInterfaceType = this.getSymbolFromDeclPath("Array", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (!this._cachedArrayInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedArrayInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedArrayInterfaceType;
+        };
+
+        PullTypeResolver.prototype.getArrayNamedType = function () {
+            return this.cachedArrayInterfaceType();
+        };
+
+        PullTypeResolver.prototype.cachedNumberInterfaceType = function () {
+            if (!this._cachedNumberInterfaceType) {
+                this._cachedNumberInterfaceType = this.getSymbolFromDeclPath("Number", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (this._cachedNumberInterfaceType && !this._cachedNumberInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedNumberInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedNumberInterfaceType;
+        };
+
+        PullTypeResolver.prototype.cachedStringInterfaceType = function () {
+            if (!this._cachedStringInterfaceType) {
+                this._cachedStringInterfaceType = this.getSymbolFromDeclPath("String", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (this._cachedStringInterfaceType && !this._cachedStringInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedStringInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedStringInterfaceType;
+        };
+
+        PullTypeResolver.prototype.cachedBooleanInterfaceType = function () {
+            if (!this._cachedBooleanInterfaceType) {
+                this._cachedBooleanInterfaceType = this.getSymbolFromDeclPath("Boolean", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (this._cachedBooleanInterfaceType && !this._cachedBooleanInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedBooleanInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedBooleanInterfaceType;
+        };
+
+        PullTypeResolver.prototype.cachedObjectInterfaceType = function () {
+            if (!this._cachedObjectInterfaceType) {
+                this._cachedObjectInterfaceType = this.getSymbolFromDeclPath("Object", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (!this._cachedObjectInterfaceType) {
+                this._cachedObjectInterfaceType = this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            if (!this._cachedObjectInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedObjectInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedObjectInterfaceType;
+        };
+
+        PullTypeResolver.prototype.cachedFunctionInterfaceType = function () {
+            if (!this._cachedFunctionInterfaceType) {
+                this._cachedFunctionInterfaceType = this.getSymbolFromDeclPath("Function", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (this._cachedFunctionInterfaceType && !this._cachedFunctionInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedFunctionInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedFunctionInterfaceType;
+        };
+
+        PullTypeResolver.prototype.cachedIArgumentsInterfaceType = function () {
+            if (!this._cachedIArgumentsInterfaceType) {
+                this._cachedIArgumentsInterfaceType = this.getSymbolFromDeclPath("IArguments", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (this._cachedIArgumentsInterfaceType && !this._cachedIArgumentsInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedIArgumentsInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedIArgumentsInterfaceType;
+        };
+
+        PullTypeResolver.prototype.cachedRegExpInterfaceType = function () {
+            if (!this._cachedRegExpInterfaceType) {
+                this._cachedRegExpInterfaceType = this.getSymbolFromDeclPath("RegExp", [], 16 /* Interface */) || this.semanticInfoChain.emptyTypeSymbol;
+            }
+
+            if (this._cachedRegExpInterfaceType && !this._cachedRegExpInterfaceType.isResolved) {
+                this.resolveDeclaredSymbol(this._cachedRegExpInterfaceType, new TypeScript.PullTypeResolutionContext(this));
+            }
+
+            return this._cachedRegExpInterfaceType;
+        };
+
+        PullTypeResolver.prototype.cachedFunctionArgumentsSymbol = function () {
+            if (!this._cachedFunctionArgumentsSymbol) {
+                this._cachedFunctionArgumentsSymbol = new TypeScript.PullSymbol("arguments", 512 /* Variable */);
+                this._cachedFunctionArgumentsSymbol.type = this.cachedIArgumentsInterfaceType() || this.semanticInfoChain.anyTypeSymbol;
+                this._cachedFunctionArgumentsSymbol.setResolved();
+
+                var functionArgumentsDecl = new TypeScript.PullSynthesizedDecl("arguments", "arguments", 2048 /* Parameter */, 0 /* None */, null, this.semanticInfoChain);
+                functionArgumentsDecl.setSymbol(this._cachedFunctionArgumentsSymbol);
+                this._cachedFunctionArgumentsSymbol.addDeclaration(functionArgumentsDecl);
+            }
+
+            return this._cachedFunctionArgumentsSymbol;
+        };
+
+        PullTypeResolver.prototype.getApparentType = function (type) {
+            if (type.isTypeParameter()) {
+                var baseConstraint = type.getBaseConstraint(this.semanticInfoChain);
+                if (baseConstraint === this.semanticInfoChain.anyTypeSymbol) {
+                    return this.semanticInfoChain.emptyTypeSymbol;
+                } else {
+                    type = baseConstraint;
+                }
+            }
+            if (type.isPrimitive()) {
+                if (type === this.semanticInfoChain.numberTypeSymbol) {
+                    return this.cachedNumberInterfaceType();
+                }
+                if (type === this.semanticInfoChain.booleanTypeSymbol) {
+                    return this.cachedBooleanInterfaceType();
+                }
+                if (type === this.semanticInfoChain.stringTypeSymbol) {
+                    return this.cachedStringInterfaceType();
+                }
+                return type;
+            }
+            if (type.isEnum()) {
+                return this.cachedNumberInterfaceType();
+            }
+            return type;
+        };
+
+        PullTypeResolver.prototype.setTypeChecked = function (ast, context) {
+            context.setTypeChecked(ast);
+        };
+
+        PullTypeResolver.prototype.canTypeCheckAST = function (ast, context) {
+            return context.canTypeCheckAST(ast);
+        };
+
+        PullTypeResolver.prototype.setSymbolForAST = function (ast, symbol, context) {
+            if (context && context.inProvisionalResolution()) {
+                context.setSymbolForAST(ast, symbol);
+            } else {
+                this.semanticInfoChain.setSymbolForAST(ast, symbol);
+            }
+        };
+
+        PullTypeResolver.prototype.getSymbolForAST = function (ast, context) {
+            var symbol = this.semanticInfoChain.getSymbolForAST(ast);
+
+            if (!symbol) {
+                if (context && context.inProvisionalResolution()) {
+                    symbol = context.getSymbolForAST(ast);
+                }
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.getASTForDecl = function (decl) {
+            return this.semanticInfoChain.getASTForDecl(decl);
+        };
+
+        PullTypeResolver.prototype.getNewErrorTypeSymbol = function (name) {
+            if (typeof name === "undefined") { name = null; }
+            return new TypeScript.PullErrorTypeSymbol(this.semanticInfoChain.anyTypeSymbol, name);
+        };
+
+        PullTypeResolver.prototype.getEnclosingDecl = function (decl) {
+            var declPath = decl.getParentPath();
+
+            if (declPath.length > 1 && declPath[declPath.length - 1] === decl) {
+                return declPath[declPath.length - 2];
+            } else {
+                return declPath[declPath.length - 1];
+            }
+        };
+
+        PullTypeResolver.prototype.getExportedMemberSymbol = function (symbol, parent) {
+            if (!(symbol.kind & (65536 /* Method */ | 4096 /* Property */))) {
+                var isContainer = (parent.kind & (4 /* Container */ | 32 /* DynamicModule */)) !== 0;
+                var containerType = !isContainer ? parent.getAssociatedContainerType() : parent;
+
+                if (isContainer && containerType) {
+                    if (symbol.anyDeclHasFlag(1 /* Exported */)) {
+                        return symbol;
+                    }
+
+                    return null;
+                }
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype._getNamedPropertySymbolOfAugmentedType = function (symbolName, parent) {
+            var memberSymbol = this.getNamedPropertySymbol(symbolName, 68147712 /* SomeValue */, parent);
+            if (memberSymbol) {
+                return memberSymbol;
+            }
+
+            if (this.cachedFunctionInterfaceType() && parent.isFunctionType()) {
+                memberSymbol = this.cachedFunctionInterfaceType().findMember(symbolName, true);
+                if (memberSymbol) {
+                    return memberSymbol;
+                }
+            }
+
+            if (this.cachedObjectInterfaceType()) {
+                return this.cachedObjectInterfaceType().findMember(symbolName, true);
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.getNamedPropertySymbol = function (symbolName, declSearchKind, parent) {
+            var member = null;
+
+            if (declSearchKind & 68147712 /* SomeValue */) {
+                member = parent.findMember(symbolName, true);
+            } else if (declSearchKind & 58728795 /* SomeType */) {
+                member = parent.findNestedType(symbolName);
+            } else if (declSearchKind & 164 /* SomeContainer */) {
+                member = parent.findNestedContainer(symbolName);
+            }
+
+            if (member) {
+                return this.getExportedMemberSymbol(member, parent);
+            }
+
+            var containerType = parent.getAssociatedContainerType();
+
+            if (containerType) {
+                if (containerType.isClass()) {
+                    return null;
+                }
+
+                parent = containerType;
+
+                if (declSearchKind & 68147712 /* SomeValue */) {
+                    member = parent.findMember(symbolName, true);
+                } else if (declSearchKind & 58728795 /* SomeType */) {
+                    member = parent.findNestedType(symbolName);
+                } else if (declSearchKind & 164 /* SomeContainer */) {
+                    member = parent.findNestedContainer(symbolName);
+                }
+
+                if (member) {
+                    return this.getExportedMemberSymbol(member, parent);
+                }
+            }
+
+            if (parent.kind & 164 /* SomeContainer */) {
+                var typeDeclarations = parent.getDeclarations();
+                var childDecls = null;
+
+                for (var j = 0; j < typeDeclarations.length; j++) {
+                    childDecls = typeDeclarations[j].searchChildDecls(symbolName, declSearchKind);
+
+                    if (childDecls.length) {
+                        member = childDecls[0].getSymbol();
+
+                        if (!member) {
+                            member = childDecls[0].getSignatureSymbol();
+                        }
+                        return this.getExportedMemberSymbol(member, parent);
+                    }
+
+                    if ((declSearchKind & 58728795 /* SomeType */) !== 0 || (declSearchKind & 68147712 /* SomeValue */) !== 0) {
+                        childDecls = typeDeclarations[j].searchChildDecls(symbolName, 128 /* TypeAlias */);
+                        if (childDecls.length && childDecls[0].kind === 128 /* TypeAlias */) {
+                            var aliasSymbol = this.getExportedMemberSymbol(childDecls[0].getSymbol(), parent);
+                            if (aliasSymbol) {
+                                if ((declSearchKind & 58728795 /* SomeType */) !== 0) {
+                                    var typeSymbol = aliasSymbol.getExportAssignedTypeSymbol();
+                                    if (typeSymbol) {
+                                        return typeSymbol;
+                                    }
+                                } else {
+                                    var valueSymbol = aliasSymbol.getExportAssignedValueSymbol();
+                                    if (valueSymbol) {
+                                        aliasSymbol.setIsUsedAsValue();
+                                        return valueSymbol;
+                                    }
+                                }
+
+                                return aliasSymbol;
+                            }
+                        }
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.getSymbolFromDeclPath = function (symbolName, declPath, declSearchKind) {
+            var _this = this;
+            var symbol = null;
+
+            var decl = null;
+            var childDecls;
+            var declSymbol = null;
+            var declMembers;
+            var pathDeclKind;
+            var valDecl = null;
+            var kind;
+            var instanceSymbol = null;
+            var instanceType = null;
+            var childSymbol = null;
+
+            var allowedContainerDeclKind = 4 /* Container */ | 32 /* DynamicModule */;
+            if (TypeScript.hasFlag(declSearchKind, 67108864 /* EnumMember */)) {
+                allowedContainerDeclKind |= 64 /* Enum */;
+            }
+
+            var isAcceptableAlias = function (symbol) {
+                if (symbol.isAlias()) {
+                    _this.resolveDeclaredSymbol(symbol);
+                    if (TypeScript.hasFlag(declSearchKind, 164 /* SomeContainer */)) {
+                        if (symbol.assignedContainer() || symbol.getExportAssignedContainerSymbol()) {
+                            return true;
+                        }
+                    } else if (TypeScript.hasFlag(declSearchKind, 58728795 /* SomeType */)) {
+                        var type = symbol.getExportAssignedTypeSymbol();
+                        if (type && type.kind !== 32 /* DynamicModule */) {
+                            return true;
+                        }
+
+                        var type = symbol.assignedType();
+                        if (type && type.kind !== 32 /* DynamicModule */) {
+                            return true;
+                        }
+                    } else if (TypeScript.hasFlag(declSearchKind, 68147712 /* SomeValue */ & ~67108864 /* EnumMember */)) {
+                        if (symbol.assignedType() && symbol.assignedType().isError()) {
+                            return true;
+                        } else if (symbol.assignedValue() || symbol.getExportAssignedValueSymbol()) {
+                            return true;
+                        } else {
+                            var assignedType = symbol.assignedType();
+                            if (assignedType && assignedType.isContainer() && assignedType.getInstanceType()) {
+                                return true;
+                            }
+
+                            var decls = symbol.getDeclarations();
+                            var ast = decls[0].ast();
+                            return ast.moduleReference.kind() === 245 /* ExternalModuleReference */;
+                        }
+                    }
+                }
+
+                return false;
+            };
+
+            var tryFindAlias = function (decl) {
+                var childDecls = decl.searchChildDecls(symbolName, 128 /* TypeAlias */);
+
+                if (childDecls.length) {
+                    var sym = childDecls[0].getSymbol();
+                    if (isAcceptableAlias(sym)) {
+                        return sym;
+                    }
+                }
+                return null;
+            };
+
+            for (var i = declPath.length - 1; i >= 0; i--) {
+                decl = declPath[i];
+                pathDeclKind = decl.kind;
+
+                if (decl.flags & 2097152 /* DeclaredInAWithBlock */) {
+                    return this.semanticInfoChain.anyTypeSymbol;
+                }
+
+                if (pathDeclKind & allowedContainerDeclKind) {
+                    childDecls = decl.searchChildDecls(symbolName, declSearchKind);
+
+                    if (childDecls.length) {
+                        return childDecls[0].getSymbol();
+                    }
+
+                    var alias = tryFindAlias(decl);
+                    if (alias) {
+                        return alias;
+                    }
+
+                    if (declSearchKind & 68147712 /* SomeValue */) {
+                        instanceSymbol = decl.getSymbol().getInstanceSymbol();
+
+                        if (instanceSymbol) {
+                            instanceType = instanceSymbol.type;
+
+                            childSymbol = this.getNamedPropertySymbol(symbolName, declSearchKind, instanceType);
+
+                            if (childSymbol && (childSymbol.kind & declSearchKind) && !childSymbol.anyDeclHasFlag(16 /* Static */)) {
+                                return childSymbol;
+                            }
+                        }
+
+                        valDecl = decl.getValueDecl();
+
+                        if (valDecl) {
+                            decl = valDecl;
+                        }
+                    }
+
+                    declSymbol = decl.getSymbol().type;
+
+                    var childSymbol = this.getNamedPropertySymbol(symbolName, declSearchKind, declSymbol);
+
+                    if (childSymbol && (childSymbol.kind & declSearchKind) && !childSymbol.anyDeclHasFlag(16 /* Static */)) {
+                        return childSymbol;
+                    }
+                } else if ((declSearchKind & (58728795 /* SomeType */ | 164 /* SomeContainer */)) || !(pathDeclKind & 8 /* Class */)) {
+                    var candidateSymbol = null;
+
+                    if (pathDeclKind === 131072 /* FunctionExpression */ && symbolName === decl.getFunctionExpressionName()) {
+                        candidateSymbol = decl.getSymbol();
+                    }
+
+                    childDecls = decl.searchChildDecls(symbolName, declSearchKind);
+
+                    if (childDecls.length) {
+                        if (decl.kind & 1032192 /* SomeFunction */) {
+                            decl.ensureSymbolIsBound();
+                        }
+                        return childDecls[0].getSymbol();
+                    }
+
+                    if (candidateSymbol) {
+                        return candidateSymbol;
+                    }
+
+                    var alias = tryFindAlias(decl);
+                    if (alias) {
+                        return alias;
+                    }
+                }
+            }
+
+            symbol = this.semanticInfoChain.findSymbol([symbolName], declSearchKind);
+            if (symbol) {
+                return symbol;
+            }
+
+            if (!TypeScript.hasFlag(declSearchKind, 128 /* TypeAlias */)) {
+                symbol = this.semanticInfoChain.findSymbol([symbolName], 128 /* TypeAlias */);
+                if (symbol && isAcceptableAlias(symbol)) {
+                    return symbol;
+                }
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.getVisibleDeclsFromDeclPath = function (declPath, declSearchKind) {
+            var result = [];
+            var decl = null;
+            var childDecls;
+            var pathDeclKind;
+
+            for (var i = declPath.length - 1; i >= 0; i--) {
+                decl = declPath[i];
+                pathDeclKind = decl.kind;
+
+                var declKind = decl.kind;
+
+                if (declKind !== 8 /* Class */ && declKind !== 16 /* Interface */) {
+                    this.addFilteredDecls(decl.getChildDecls(), declSearchKind, result);
+                }
+
+                switch (declKind) {
+                    case 4 /* Container */:
+                    case 32 /* DynamicModule */:
+                        var otherDecls = this.semanticInfoChain.findDeclsFromPath(declPath.slice(0, i + 1), 164 /* SomeContainer */);
+                        for (var j = 0, m = otherDecls.length; j < m; j++) {
+                            var otherDecl = otherDecls[j];
+                            if (otherDecl === decl) {
+                                continue;
+                            }
+
+                            var otherDeclChildren = otherDecl.getChildDecls();
+                            for (var k = 0, s = otherDeclChildren.length; k < s; k++) {
+                                var otherDeclChild = otherDeclChildren[k];
+                                if ((otherDeclChild.flags & 1 /* Exported */) && (otherDeclChild.kind & declSearchKind)) {
+                                    result.push(otherDeclChild);
+                                }
+                            }
+                        }
+
+                        break;
+
+                    case 8 /* Class */:
+                    case 16 /* Interface */:
+                        var parameters = decl.getTypeParameters();
+                        if (parameters && parameters.length) {
+                            this.addFilteredDecls(parameters, declSearchKind, result);
+                        }
+
+                        break;
+
+                    case 131072 /* FunctionExpression */:
+                        var functionExpressionName = decl.getFunctionExpressionName();
+                        if (functionExpressionName) {
+                            result.push(decl);
+                        }
+
+                    case 16384 /* Function */:
+                    case 32768 /* ConstructorMethod */:
+                    case 65536 /* Method */:
+                        var parameters = decl.getTypeParameters();
+                        if (parameters && parameters.length) {
+                            this.addFilteredDecls(parameters, declSearchKind, result);
+                        }
+
+                        break;
+                }
+            }
+
+            var topLevelDecls = this.semanticInfoChain.topLevelDecls();
+            for (var i = 0, n = topLevelDecls.length; i < n; i++) {
+                var topLevelDecl = topLevelDecls[i];
+                if (declPath.length > 0 && topLevelDecl.fileName() === declPath[0].fileName()) {
+                    continue;
+                }
+
+                if (!topLevelDecl.isExternalModule()) {
+                    this.addFilteredDecls(topLevelDecl.getChildDecls(), declSearchKind, result);
+                }
+            }
+
+            return result;
+        };
+
+        PullTypeResolver.prototype.addFilteredDecls = function (decls, declSearchKind, result) {
+            if (decls.length) {
+                for (var i = 0, n = decls.length; i < n; i++) {
+                    var decl = decls[i];
+                    if (decl.kind & declSearchKind) {
+                        result.push(decl);
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.getVisibleDecls = function (enclosingDecl) {
+            var declPath = enclosingDecl.getParentPath();
+
+            var declSearchKind = 58728795 /* SomeType */ | 164 /* SomeContainer */ | 68147712 /* SomeValue */;
+
+            return this.getVisibleDeclsFromDeclPath(declPath, declSearchKind);
+        };
+
+        PullTypeResolver.prototype.getVisibleContextSymbols = function (enclosingDecl, context) {
+            var contextualTypeSymbol = context.getContextualType();
+            if (!contextualTypeSymbol || this.isAnyOrEquivalent(contextualTypeSymbol)) {
+                return null;
+            }
+
+            var declSearchKind = 58728795 /* SomeType */ | 164 /* SomeContainer */ | 68147712 /* SomeValue */;
+            var members = contextualTypeSymbol.getAllMembers(declSearchKind, 2 /* externallyVisible */);
+
+            for (var i = 0; i < members.length; i++) {
+                members[i].setUnresolved();
+            }
+
+            return members;
+        };
+
+        PullTypeResolver.prototype.getVisibleMembersFromExpression = function (expression, enclosingDecl, context) {
+            var lhs = this.resolveAST(expression, false, context);
+
+            if (isTypesOnlyLocation(expression) && (lhs.kind === 8 /* Class */ || lhs.kind === 16 /* Interface */ || lhs.kind === 64 /* Enum */)) {
+                return null;
+            }
+
+            var lhsType = lhs.type;
+            if (!lhsType) {
+                return null;
+            }
+
+            this.resolveDeclaredSymbol(lhsType, context);
+
+            if (lhsType.isContainer() && lhsType.isAlias()) {
+                lhsType = lhsType.getExportAssignedTypeSymbol();
+            }
+
+            if (this.isAnyOrEquivalent(lhsType)) {
+                return null;
+            }
+
+            var memberVisibilty = 2 /* externallyVisible */;
+            var containerSymbol = lhsType;
+            if (containerSymbol.kind === 33554432 /* ConstructorType */) {
+                containerSymbol = containerSymbol.getConstructSignatures()[0].returnType;
+            }
+
+            if (containerSymbol && containerSymbol.isClass()) {
+                var declPath = enclosingDecl.getParentPath();
+                if (declPath && declPath.length) {
+                    var declarations = containerSymbol.getDeclarations();
+                    for (var i = 0, n = declarations.length; i < n; i++) {
+                        var declaration = declarations[i];
+                        if (TypeScript.ArrayUtilities.contains(declPath, declaration)) {
+                            memberVisibilty = 1 /* internallyVisible */;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            var declSearchKind = 58728795 /* SomeType */ | 164 /* SomeContainer */ | 68147712 /* SomeValue */;
+
+            var members = [];
+
+            if (lhsType.isContainer()) {
+                var exportedAssignedContainerSymbol = lhsType.getExportAssignedContainerSymbol();
+                if (exportedAssignedContainerSymbol) {
+                    lhsType = exportedAssignedContainerSymbol;
+                }
+            }
+
+            lhsType = this.getApparentType(lhsType);
+
+            if (!lhsType.isResolved) {
+                var potentiallySpecializedType = this.resolveDeclaredSymbol(lhsType, context);
+
+                if (potentiallySpecializedType !== lhsType) {
+                    if (!lhs.isType()) {
+                        context.setTypeInContext(lhs, potentiallySpecializedType);
+                    }
+
+                    lhsType = potentiallySpecializedType;
+                }
+            }
+
+            members = lhsType.getAllMembers(declSearchKind, memberVisibilty);
+
+            if (lhsType.isContainer()) {
+                var associatedInstance = lhsType.getInstanceSymbol();
+                if (associatedInstance) {
+                    var instanceType = associatedInstance.type;
+                    this.resolveDeclaredSymbol(instanceType, context);
+                    var instanceMembers = instanceType.getAllMembers(declSearchKind, memberVisibilty);
+                    members = members.concat(instanceMembers);
+                }
+
+                var exportedContainer = lhsType.getExportAssignedContainerSymbol();
+                if (exportedContainer) {
+                    var exportedContainerMembers = exportedContainer.getAllMembers(declSearchKind, memberVisibilty);
+                    members = members.concat(exportedContainerMembers);
+                }
+            } else if (!lhsType.isConstructor() && !lhsType.isEnum()) {
+                var associatedContainerSymbol = lhsType.getAssociatedContainerType();
+                if (associatedContainerSymbol) {
+                    var containerType = associatedContainerSymbol.type;
+                    this.resolveDeclaredSymbol(containerType, context);
+                    var containerMembers = containerType.getAllMembers(declSearchKind, memberVisibilty);
+                    members = members.concat(containerMembers);
+                }
+            }
+
+            if (lhsType.isFunctionType() && this.cachedFunctionInterfaceType()) {
+                members = members.concat(this.cachedFunctionInterfaceType().getAllMembers(declSearchKind, 2 /* externallyVisible */));
+            }
+
+            return members;
+        };
+
+        PullTypeResolver.prototype.isAnyOrEquivalent = function (type) {
+            return (type === this.semanticInfoChain.anyTypeSymbol) || type.isError();
+        };
+
+        PullTypeResolver.prototype.resolveExternalModuleReference = function (idText, currentFileName) {
+            var originalIdText = idText;
+            var symbol = null;
+
+            if (TypeScript.isRelative(originalIdText)) {
+                var path = TypeScript.getRootFilePath(TypeScript.switchToForwardSlashes(currentFileName));
+                symbol = this.semanticInfoChain.findExternalModule(path + idText);
+            } else {
+                idText = originalIdText;
+
+                symbol = this.semanticInfoChain.findAmbientExternalModuleInGlobalContext(TypeScript.quoteStr(originalIdText));
+
+                if (!symbol) {
+                    var path = TypeScript.getRootFilePath(TypeScript.switchToForwardSlashes(currentFileName));
+
+                    while (symbol === null && path != "") {
+                        symbol = this.semanticInfoChain.findExternalModule(path + idText);
+                        if (symbol === null) {
+                            if (path === '/') {
+                                path = '';
+                            } else {
+                                path = TypeScript.normalizePath(path + "..");
+                                path = path && path != '/' ? path + '/' : path;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.resolveDeclaredSymbol = function (symbol, context) {
+            if (!symbol || symbol.isResolved || symbol.isTypeReference()) {
+                return symbol;
+            }
+
+            if (!context) {
+                context = new TypeScript.PullTypeResolutionContext(this);
+            }
+
+            return this.resolveDeclaredSymbolWorker(symbol, context);
+        };
+
+        PullTypeResolver.prototype.resolveDeclaredSymbolWorker = function (symbol, context) {
+            if (!symbol || symbol.isResolved) {
+                return symbol;
+            }
+
+            if (symbol.inResolution) {
+                if (!symbol.type && !symbol.isType()) {
+                    symbol.type = this.semanticInfoChain.anyTypeSymbol;
+                }
+
+                return symbol;
+            }
+
+            var decls = symbol.getDeclarations();
+
+            for (var i = 0; i < decls.length; i++) {
+                var decl = decls[i];
+
+                var ast = this.semanticInfoChain.getASTForDecl(decl);
+
+                if (!ast || (ast.kind() === 139 /* GetAccessor */ && ast.parent.parent.kind() === 215 /* ObjectLiteralExpression */) || (ast.kind() === 140 /* SetAccessor */ && ast.parent.parent.kind() === 215 /* ObjectLiteralExpression */)) {
+                    return symbol;
+                }
+
+                if (ast.parent && ast.parent.kind() === 236 /* CatchClause */ && ast.parent.identifier === ast) {
+                    return symbol;
+                }
+
+                if (ast.parent && ast.parent.kind() === 219 /* SimpleArrowFunctionExpression */ && ast.parent.identifier === ast) {
+                    return symbol;
+                }
+
+                var enclosingModule = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(ast);
+                var resolvedSymbol;
+                if (TypeScript.ASTHelpers.isAnyNameOfModule(enclosingModule, ast)) {
+                    resolvedSymbol = this.resolveSingleModuleDeclaration(enclosingModule, ast, context);
+                } else if (ast.kind() === 120 /* SourceUnit */ && decl.kind === 32 /* DynamicModule */) {
+                    resolvedSymbol = this.resolveModuleSymbol(decl.getSymbol(), context, null, null, ast);
+                } else {
+                    TypeScript.Debug.assert(ast.kind() !== 11 /* IdentifierName */ && ast.kind() !== 212 /* MemberAccessExpression */);
+                    resolvedSymbol = this.resolveAST(ast, false, context);
+                }
+
+                if (decl.kind === 2048 /* Parameter */ && !symbol.isResolved && !symbol.type && resolvedSymbol && symbol.anyDeclHasFlag(8388608 /* PropertyParameter */ | 67108864 /* ConstructorParameter */)) {
+                    symbol.type = resolvedSymbol.type;
+                    symbol.setResolved();
+                }
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.resolveOtherDecl = function (otherDecl, context) {
+            var astForOtherDecl = this.getASTForDecl(otherDecl);
+            var moduleDecl = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(astForOtherDecl);
+            if (TypeScript.ASTHelpers.isAnyNameOfModule(moduleDecl, astForOtherDecl)) {
+                this.resolveSingleModuleDeclaration(moduleDecl, astForOtherDecl, context);
+            } else {
+                this.resolveAST(astForOtherDecl, false, context);
+            }
+        };
+
+        PullTypeResolver.prototype.resolveOtherDeclarations = function (astName, context) {
+            var _this = this;
+            var resolvedDecl = this.semanticInfoChain.getDeclForAST(astName);
+            var symbol = resolvedDecl.getSymbol();
+
+            var allDecls = symbol.getDeclarations();
+            this.inResolvingOtherDeclsWalker.walkOtherPullDecls(resolvedDecl, symbol.getDeclarations(), function (otherDecl) {
+                return _this.resolveOtherDecl(otherDecl, context);
+            });
+        };
+
+        PullTypeResolver.prototype.resolveSourceUnit = function (sourceUnit, context) {
+            var enclosingDecl = this.getEnclosingDeclForAST(sourceUnit);
+            var moduleSymbol = enclosingDecl.getSymbol();
+            this.ensureAllSymbolsAreBound(moduleSymbol);
+
+            this.resolveFirstExportAssignmentStatement(sourceUnit.moduleElements, context);
+            this.resolveAST(sourceUnit.moduleElements, false, context);
+
+            if (this.canTypeCheckAST(sourceUnit, context)) {
+                this.typeCheckSourceUnit(sourceUnit, context);
+            }
+
+            return moduleSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckSourceUnit = function (sourceUnit, context) {
+            var _this = this;
+            this.setTypeChecked(sourceUnit, context);
+
+            this.resolveAST(sourceUnit.moduleElements, false, context);
+
+            this.typeCheckCallBacks.push(function (context) {
+                return _this.verifyUniquenessOfImportNamesInSourceUnit(sourceUnit);
+            });
+        };
+
+        PullTypeResolver.prototype.verifyUniquenessOfImportNamesInSourceUnit = function (sourceUnit) {
+            var _this = this;
+            var enclosingDecl = this.semanticInfoChain.getDeclForAST(sourceUnit);
+
+            var doesImportNameExistInOtherFiles = function (name) {
+                var importSymbol = _this.semanticInfoChain.findTopLevelSymbol(name, 128 /* TypeAlias */, null);
+                return importSymbol && importSymbol.isAlias();
+            };
+
+            this.checkUniquenessOfImportNames([enclosingDecl], doesImportNameExistInOtherFiles);
+        };
+
+        PullTypeResolver.prototype.resolveEnumDeclaration = function (ast, context) {
+            var containerDecl = this.semanticInfoChain.getDeclForAST(ast);
+            var containerSymbol = containerDecl.getSymbol();
+
+            if (containerSymbol.isResolved || containerSymbol.inResolution) {
+                return containerSymbol;
+            }
+
+            containerSymbol.inResolution = true;
+
+            var containerDecls = containerSymbol.getDeclarations();
+
+            for (var i = 0; i < containerDecls.length; i++) {
+                var childDecls = containerDecls[i].getChildDecls();
+
+                for (var j = 0; j < childDecls.length; j++) {
+                    childDecls[j].ensureSymbolIsBound();
+                }
+            }
+
+            containerSymbol.setResolved();
+
+            this.resolveOtherDeclarations(ast, context);
+
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckEnumDeclaration(ast, context);
+            }
+
+            return containerSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckEnumDeclaration = function (ast, context) {
+            var _this = this;
+            this.setTypeChecked(ast, context);
+
+            this.resolveAST(ast.enumElements, false, context);
+            var containerDecl = this.semanticInfoChain.getDeclForAST(ast);
+            this.validateVariableDeclarationGroups(containerDecl, context);
+
+            this.typeCheckCallBacks.push(function (context) {
+                return _this.checkInitializersInEnumDeclarations(containerDecl, context);
+            });
+
+            if (!TypeScript.ASTHelpers.enumIsElided(ast)) {
+                this.checkNameForCompilerGeneratedDeclarationCollision(ast, true, ast.identifier, context);
+            }
+        };
+
+        PullTypeResolver.prototype.postTypeCheckEnumDeclaration = function (ast, context) {
+            this.checkThisCaptureVariableCollides(ast, true, context);
+        };
+
+        PullTypeResolver.prototype.checkInitializersInEnumDeclarations = function (decl, context) {
+            var symbol = decl.getSymbol();
+
+            var declarations = symbol.getDeclarations();
+            if (decl !== declarations[0]) {
+                return;
+            }
+
+            var seenEnumDeclWithNoFirstMember = false;
+            for (var i = 0; i < declarations.length; ++i) {
+                var currentDecl = declarations[i];
+
+                var ast = currentDecl.ast();
+                if (ast.enumElements.nonSeparatorCount() === 0) {
+                    continue;
+                }
+
+                var firstVariable = ast.enumElements.nonSeparatorAt(0);
+                if (!firstVariable.equalsValueClause) {
+                    if (!seenEnumDeclWithNoFirstMember) {
+                        seenEnumDeclWithNoFirstMember = true;
+                    } else {
+                        this.semanticInfoChain.addDiagnosticFromAST(firstVariable, TypeScript.DiagnosticCode.In_enums_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_the_first_enum_element);
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveModuleDeclaration = function (ast, context) {
+            var result;
+
+            if (ast.stringLiteral) {
+                result = this.resolveSingleModuleDeclaration(ast, ast.stringLiteral, context);
+            } else {
+                var moduleNames = TypeScript.ASTHelpers.getModuleNames(ast.name);
+                for (var i = 0, n = moduleNames.length; i < n; i++) {
+                    result = this.resolveSingleModuleDeclaration(ast, moduleNames[i], context);
+                }
+            }
+
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckModuleDeclaration(ast, context);
+            }
+
+            return result;
+        };
+
+        PullTypeResolver.prototype.ensureAllSymbolsAreBound = function (containerSymbol) {
+            if (containerSymbol) {
+                var containerDecls = containerSymbol.getDeclarations();
+
+                for (var i = 0; i < containerDecls.length; i++) {
+                    var childDecls = containerDecls[i].getChildDecls();
+
+                    for (var j = 0; j < childDecls.length; j++) {
+                        childDecls[j].ensureSymbolIsBound();
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveModuleSymbol = function (containerSymbol, context, moduleDeclAST, moduleDeclNameAST, sourceUnitAST) {
+            if (containerSymbol.isResolved || containerSymbol.inResolution) {
+                return containerSymbol;
+            }
+
+            containerSymbol.inResolution = true;
+            this.ensureAllSymbolsAreBound(containerSymbol);
+
+            var instanceSymbol = containerSymbol.getInstanceSymbol();
+
+            if (instanceSymbol) {
+                this.resolveDeclaredSymbol(instanceSymbol, context);
+            }
+
+            var isLastName = TypeScript.ASTHelpers.isLastNameOfModule(moduleDeclAST, moduleDeclNameAST);
+            if (isLastName) {
+                this.resolveFirstExportAssignmentStatement(moduleDeclAST.moduleElements, context);
+            } else if (sourceUnitAST) {
+                this.resolveFirstExportAssignmentStatement(sourceUnitAST.moduleElements, context);
+            }
+
+            containerSymbol.setResolved();
+
+            if (moduleDeclNameAST) {
+                this.resolveOtherDeclarations(moduleDeclNameAST, context);
+            }
+
+            return containerSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveFirstExportAssignmentStatement = function (moduleElements, context) {
+            for (var i = 0, n = moduleElements.childCount(); i < n; i++) {
+                var moduleElement = moduleElements.childAt(i);
+                if (moduleElement.kind() === 134 /* ExportAssignment */) {
+                    this.resolveExportAssignmentStatement(moduleElement, context);
+                    return;
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveSingleModuleDeclaration = function (ast, astName, context) {
+            var containerDecl = this.semanticInfoChain.getDeclForAST(astName);
+            var containerSymbol = containerDecl.getSymbol();
+
+            return this.resolveModuleSymbol(containerSymbol, context, ast, astName, null);
+        };
+
+        PullTypeResolver.prototype.typeCheckModuleDeclaration = function (ast, context) {
+            if (ast.stringLiteral) {
+                this.typeCheckSingleModuleDeclaration(ast, ast.stringLiteral, context);
+            } else {
+                var moduleNames = TypeScript.ASTHelpers.getModuleNames(ast.name);
+                for (var i = 0, n = moduleNames.length; i < n; i++) {
+                    this.typeCheckSingleModuleDeclaration(ast, moduleNames[i], context);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckSingleModuleDeclaration = function (ast, astName, context) {
+            var _this = this;
+            this.setTypeChecked(ast, context);
+
+            if (TypeScript.ASTHelpers.isLastNameOfModule(ast, astName)) {
+                this.resolveAST(ast.moduleElements, false, context);
+            }
+
+            var containerDecl = this.semanticInfoChain.getDeclForAST(astName);
+            this.validateVariableDeclarationGroups(containerDecl, context);
+
+            if (ast.stringLiteral) {
+                if (TypeScript.isRelative(ast.stringLiteral.valueText())) {
+                    this.semanticInfoChain.addDiagnosticFromAST(ast.stringLiteral, TypeScript.DiagnosticCode.Ambient_external_module_declaration_cannot_specify_relative_module_name);
+                }
+            }
+
+            if (!TypeScript.ASTHelpers.moduleIsElided(ast) && !ast.stringLiteral) {
+                this.checkNameForCompilerGeneratedDeclarationCollision(astName, true, astName, context);
+            }
+
+            this.typeCheckCallBacks.push(function (context) {
+                return _this.verifyUniquenessOfImportNamesInModule(containerDecl);
+            });
+        };
+
+        PullTypeResolver.prototype.verifyUniquenessOfImportNamesInModule = function (decl) {
+            var symbol = decl.getSymbol();
+            if (!symbol) {
+                return;
+            }
+
+            var decls = symbol.getDeclarations();
+
+            if (decls[0] !== decl) {
+                return;
+            }
+
+            this.checkUniquenessOfImportNames(decls);
+        };
+
+        PullTypeResolver.prototype.checkUniquenessOfImportNames = function (decls, doesNameExistOutside) {
+            var _this = this;
+            var importDeclarationNames;
+
+            for (var i = 0; i < decls.length; ++i) {
+                var childDecls = decls[i].getChildDecls();
+                for (var j = 0; j < childDecls.length; ++j) {
+                    var childDecl = childDecls[j];
+                    if (childDecl.kind === 128 /* TypeAlias */) {
+                        importDeclarationNames = importDeclarationNames || TypeScript.createIntrinsicsObject();
+                        importDeclarationNames[childDecl.name] = true;
+                    }
+                }
+            }
+
+            if (!importDeclarationNames && !doesNameExistOutside) {
+                return;
+            }
+
+            for (var i = 0; i < decls.length; ++i) {
+                this.scanVariableDeclarationGroups(decls[i], function (firstDeclInGroup) {
+                    var nameConflict = importDeclarationNames && importDeclarationNames[firstDeclInGroup.name];
+                    if (!nameConflict) {
+                        nameConflict = doesNameExistOutside && doesNameExistOutside(firstDeclInGroup.name);
+                        if (nameConflict) {
+                            importDeclarationNames = importDeclarationNames || TypeScript.createIntrinsicsObject();
+                            importDeclarationNames[firstDeclInGroup.name] = true;
+                        }
+                    }
+
+                    if (nameConflict) {
+                        _this.semanticInfoChain.addDiagnosticFromAST(firstDeclInGroup.ast(), TypeScript.DiagnosticCode.Variable_declaration_cannot_have_the_same_name_as_an_import_declaration);
+                    }
+                });
+            }
+        };
+
+        PullTypeResolver.prototype.scanVariableDeclarationGroups = function (enclosingDecl, firstDeclHandler, subsequentDeclHandler) {
+            var declGroups = enclosingDecl.getVariableDeclGroups();
+
+            for (var i = 0; i < declGroups.length; i++) {
+                var firstSymbol = null;
+                var enclosingDeclForFirstSymbol = null;
+
+                if (enclosingDecl.kind === 1 /* Script */ && declGroups[i].length) {
+                    var name = declGroups[i][0].name;
+                    var candidateSymbol = this.semanticInfoChain.findTopLevelSymbol(name, 512 /* Variable */, enclosingDecl);
+                    if (candidateSymbol && candidateSymbol.isResolved) {
+                        if (!candidateSymbol.anyDeclHasFlag(118784 /* ImplicitVariable */)) {
+                            firstSymbol = candidateSymbol;
+                        }
+                    }
+                }
+
+                for (var j = 0; j < declGroups[i].length; j++) {
+                    var decl = declGroups[i][j];
+
+                    var name = decl.name;
+
+                    var symbol = decl.getSymbol();
+
+                    if (j === 0) {
+                        firstDeclHandler(decl);
+                        if (!subsequentDeclHandler) {
+                            break;
+                        }
+
+                        if (!firstSymbol || !firstSymbol.type) {
+                            firstSymbol = symbol;
+                            continue;
+                        }
+                    }
+
+                    subsequentDeclHandler(decl, firstSymbol);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.postTypeCheckModuleDeclaration = function (ast, context) {
+            this.checkThisCaptureVariableCollides(ast, true, context);
+        };
+
+        PullTypeResolver.prototype.isTypeRefWithoutTypeArgs = function (term) {
+            if (term.kind() === 11 /* IdentifierName */) {
+                return true;
+            } else if (term.kind() === 121 /* QualifiedName */) {
+                var binex = term;
+
+                if (binex.right.kind() === 11 /* IdentifierName */) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.createInstantiatedType = function (type, typeArguments) {
+            if (!type.isGeneric()) {
+                return type;
+            }
+
+            var typeParameters = type.getTypeArgumentsOrTypeParameters();
+
+            var typeParameterArgumentMap = [];
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameterArgumentMap[typeParameters[i].pullSymbolID] = typeArguments[i] || new TypeScript.PullErrorTypeSymbol(this.semanticInfoChain.anyTypeSymbol, typeParameters[i].name);
+            }
+
+            return TypeScript.PullInstantiatedTypeReferenceSymbol.create(this, type, typeParameterArgumentMap);
+        };
+
+        PullTypeResolver.prototype.resolveReferenceTypeDeclaration = function (classOrInterface, name, heritageClauses, context) {
+            var _this = this;
+            var typeDecl = this.semanticInfoChain.getDeclForAST(classOrInterface);
+            var enclosingDecl = this.getEnclosingDecl(typeDecl);
+            var typeDeclSymbol = typeDecl.getSymbol();
+            var typeDeclIsClass = classOrInterface.kind() === 131 /* ClassDeclaration */;
+            var hasVisited = this.getSymbolForAST(classOrInterface, context) !== null;
+
+            if ((typeDeclSymbol.isResolved && hasVisited) || (typeDeclSymbol.inResolution && !context.isInBaseTypeResolution())) {
+                return typeDeclSymbol;
+            }
+
+            var wasResolving = typeDeclSymbol.inResolution;
+            typeDeclSymbol.startResolving();
+
+            var typeRefDecls = typeDeclSymbol.getDeclarations();
+
+            for (var i = 0; i < typeRefDecls.length; i++) {
+                var childDecls = typeRefDecls[i].getChildDecls();
+
+                for (var j = 0; j < childDecls.length; j++) {
+                    childDecls[j].ensureSymbolIsBound();
+                }
+            }
+
+            if (!typeDeclSymbol.isResolved) {
+                var typeDeclTypeParameters = typeDeclSymbol.getTypeParameters();
+                for (var i = 0; i < typeDeclTypeParameters.length; i++) {
+                    this.resolveDeclaredSymbol(typeDeclTypeParameters[i], context);
+                }
+            }
+
+            var wasInBaseTypeResolution = context.startBaseTypeResolution();
+
+            if (!typeDeclIsClass && !hasVisited) {
+                typeDeclSymbol.resetKnownBaseTypeCount();
+            }
+
+            var extendsClause = TypeScript.ASTHelpers.getExtendsHeritageClause(heritageClauses);
+            if (extendsClause) {
+                for (var i = typeDeclSymbol.getKnownBaseTypeCount(); i < extendsClause.typeNames.nonSeparatorCount(); i = typeDeclSymbol.getKnownBaseTypeCount()) {
+                    typeDeclSymbol.incrementKnownBaseCount();
+                    var parentType = this.resolveTypeReference(extendsClause.typeNames.nonSeparatorAt(i), context);
+
+                    if (typeDeclSymbol.isValidBaseKind(parentType, true)) {
+                        this.setSymbolForAST(extendsClause.typeNames.nonSeparatorAt(i), parentType, null);
+
+                        if (!typeDeclSymbol.hasBase(parentType) && !parentType.hasBase(typeDeclSymbol)) {
+                            typeDeclSymbol.addExtendedType(parentType);
+
+                            var specializations = typeDeclSymbol.getKnownSpecializations();
+
+                            for (var j = 0; j < specializations.length; j++) {
+                                specializations[j].addExtendedType(parentType);
+                            }
+                        }
+                    } else if (parentType && !this.getSymbolForAST(extendsClause.typeNames.nonSeparatorAt(i), context)) {
+                        this.setSymbolForAST(extendsClause.typeNames.nonSeparatorAt(i), parentType, null);
+                    }
+                }
+            }
+
+            var implementsClause = TypeScript.ASTHelpers.getImplementsHeritageClause(heritageClauses);
+            if (implementsClause && typeDeclIsClass) {
+                var extendsCount = extendsClause ? extendsClause.typeNames.nonSeparatorCount() : 0;
+                for (var i = typeDeclSymbol.getKnownBaseTypeCount(); ((i - extendsCount) >= 0) && ((i - extendsCount) < implementsClause.typeNames.nonSeparatorCount()); i = typeDeclSymbol.getKnownBaseTypeCount()) {
+                    typeDeclSymbol.incrementKnownBaseCount();
+                    var implementedTypeAST = implementsClause.typeNames.nonSeparatorAt(i - extendsCount);
+                    var implementedType = this.resolveTypeReference(implementedTypeAST, context);
+
+                    if (typeDeclSymbol.isValidBaseKind(implementedType, false)) {
+                        this.setSymbolForAST(implementsClause.typeNames.nonSeparatorAt(i - extendsCount), implementedType, null);
+
+                        if (!typeDeclSymbol.hasBase(implementedType) && !implementedType.hasBase(typeDeclSymbol)) {
+                            typeDeclSymbol.addImplementedType(implementedType);
+                        }
+                    } else if (implementedType && !this.getSymbolForAST(implementsClause.typeNames.nonSeparatorAt(i - extendsCount), context)) {
+                        this.setSymbolForAST(implementsClause.typeNames.nonSeparatorAt(i - extendsCount), implementedType, null);
+                    }
+                }
+            }
+
+            context.doneBaseTypeResolution(wasInBaseTypeResolution);
+
+            if (wasInBaseTypeResolution) {
+                typeDeclSymbol.inResolution = false;
+
+                this.typeCheckCallBacks.push(function (context) {
+                    if (classOrInterface.kind() === 131 /* ClassDeclaration */) {
+                        _this.resolveClassDeclaration(classOrInterface, context);
+                    } else {
+                        _this.resolveInterfaceDeclaration(classOrInterface, context);
+                    }
+                });
+
+                return typeDeclSymbol;
+            }
+
+            this.setSymbolForAST(name, typeDeclSymbol, context);
+            this.setSymbolForAST(classOrInterface, typeDeclSymbol, context);
+
+            typeDeclSymbol.setResolved();
+
+            return typeDeclSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveClassDeclaration = function (classDeclAST, context) {
+            var classDecl = this.semanticInfoChain.getDeclForAST(classDeclAST);
+            var classDeclSymbol = classDecl.getSymbol();
+
+            if (!classDeclSymbol.isResolved) {
+                this.resolveReferenceTypeDeclaration(classDeclAST, classDeclAST.identifier, classDeclAST.heritageClauses, context);
+
+                var constructorMethod = classDeclSymbol.getConstructorMethod();
+                var extendedTypes = classDeclSymbol.getExtendedTypes();
+                var parentType = extendedTypes.length ? extendedTypes[0] : null;
+
+                if (constructorMethod) {
+                    if (parentType) {
+                        var parentConstructorSymbol = parentType.getConstructorMethod();
+
+                        if (parentConstructorSymbol) {
+                            var parentConstructorTypeSymbol = parentConstructorSymbol.type;
+                            var constructorTypeSymbol = constructorMethod.type;
+                            if (!constructorTypeSymbol.hasBase(parentConstructorTypeSymbol)) {
+                                constructorTypeSymbol.addExtendedType(parentConstructorTypeSymbol);
+                            }
+                        }
+                    }
+
+                    if (!classDeclSymbol.isResolved) {
+                        return classDeclSymbol;
+                    }
+                }
+
+                this.resolveOtherDeclarations(classDeclAST, context);
+            }
+
+            if (this.canTypeCheckAST(classDeclAST, context)) {
+                this.typeCheckClassDeclaration(classDeclAST, context);
+            }
+
+            return classDeclSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckTypeParametersOfTypeDeclaration = function (classOrInterface, context) {
+            var _this = this;
+            var typeParametersList = classOrInterface.kind() == 131 /* ClassDeclaration */ ? classOrInterface.typeParameterList : classOrInterface.typeParameterList;
+
+            if (typeParametersList) {
+                var typeDecl = this.semanticInfoChain.getDeclForAST(classOrInterface);
+                var typeDeclSymbol = typeDecl.getSymbol();
+
+                for (var i = 0; i < typeParametersList.typeParameters.nonSeparatorCount(); i++) {
+                    var typeParameterAST = typeParametersList.typeParameters.nonSeparatorAt(i);
+                    this.resolveTypeParameterDeclaration(typeParameterAST, context);
+
+                    var typeParameterDecl = this.semanticInfoChain.getDeclForAST(typeParameterAST);
+                    var typeParameterSymbol = typeParameterDecl.getSymbol();
+
+                    this.checkSymbolPrivacy(typeDeclSymbol, typeParameterSymbol, function (symbol) {
+                        return _this.typeParameterOfTypeDeclarationPrivacyErrorReporter(classOrInterface, typeParameterAST, typeParameterSymbol, symbol, context);
+                    });
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckClassDeclaration = function (classDeclAST, context) {
+            this.setTypeChecked(classDeclAST, context);
+
+            var classDecl = this.semanticInfoChain.getDeclForAST(classDeclAST);
+            var classDeclSymbol = classDecl.getSymbol();
+
+            this.checkNameForCompilerGeneratedDeclarationCollision(classDeclAST, true, classDeclAST.identifier, context);
+            this.resolveAST(classDeclAST.classElements, false, context);
+
+            this.typeCheckTypeParametersOfTypeDeclaration(classDeclAST, context);
+            this.typeCheckBases(classDeclAST, classDeclAST.identifier, classDeclAST.heritageClauses, classDeclSymbol, this.getEnclosingDecl(classDecl), context);
+
+            if (!classDeclSymbol.hasBaseTypeConflict()) {
+                this.typeCheckMembersAgainstIndexer(classDeclSymbol, classDecl, context);
+            }
+
+            this.checkTypeForDuplicateIndexSignatures(classDeclSymbol);
+        };
+
+        PullTypeResolver.prototype.postTypeCheckClassDeclaration = function (classDeclAST, context) {
+            this.checkThisCaptureVariableCollides(classDeclAST, true, context);
+        };
+
+        PullTypeResolver.prototype.resolveTypeSymbolSignatures = function (typeSymbol, context) {
+            var callSignatures = typeSymbol.getCallSignatures();
+            for (var i = 0; i < callSignatures.length; i++) {
+                this.resolveDeclaredSymbol(callSignatures[i], context);
+            }
+
+            var constructSignatures = typeSymbol.getConstructSignatures();
+            for (var i = 0; i < constructSignatures.length; i++) {
+                this.resolveDeclaredSymbol(constructSignatures[i], context);
+            }
+
+            var indexSignatures = typeSymbol.getIndexSignatures();
+            for (var i = 0; i < indexSignatures.length; i++) {
+                this.resolveDeclaredSymbol(indexSignatures[i], context);
+            }
+        };
+
+        PullTypeResolver.prototype.resolveInterfaceDeclaration = function (interfaceDeclAST, context) {
+            this.resolveReferenceTypeDeclaration(interfaceDeclAST, interfaceDeclAST.identifier, interfaceDeclAST.heritageClauses, context);
+
+            var interfaceDecl = this.semanticInfoChain.getDeclForAST(interfaceDeclAST);
+            var interfaceDeclSymbol = interfaceDecl.getSymbol();
+
+            this.resolveTypeSymbolSignatures(interfaceDeclSymbol, context);
+
+            if (interfaceDeclSymbol.isResolved) {
+                this.resolveOtherDeclarations(interfaceDeclAST, context);
+
+                if (this.canTypeCheckAST(interfaceDeclAST, context)) {
+                    this.typeCheckInterfaceDeclaration(interfaceDeclAST, context);
+                }
+            }
+
+            return interfaceDeclSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckInterfaceDeclaration = function (interfaceDeclAST, context) {
+            this.setTypeChecked(interfaceDeclAST, context);
+
+            var interfaceDecl = this.semanticInfoChain.getDeclForAST(interfaceDeclAST);
+            var interfaceDeclSymbol = interfaceDecl.getSymbol();
+
+            this.resolveAST(interfaceDeclAST.body.typeMembers, false, context);
+
+            this.typeCheckTypeParametersOfTypeDeclaration(interfaceDeclAST, context);
+            this.typeCheckBases(interfaceDeclAST, interfaceDeclAST.identifier, interfaceDeclAST.heritageClauses, interfaceDeclSymbol, this.getEnclosingDecl(interfaceDecl), context);
+
+            if (!interfaceDeclSymbol.hasBaseTypeConflict()) {
+                this.typeCheckMembersAgainstIndexer(interfaceDeclSymbol, interfaceDecl, context);
+            }
+
+            var allInterfaceDecls = interfaceDeclSymbol.getDeclarations();
+            if (interfaceDecl === allInterfaceDecls[allInterfaceDecls.length - 1]) {
+                this.checkTypeForDuplicateIndexSignatures(interfaceDeclSymbol);
+            }
+
+            if (!this.checkInterfaceDeclForIdenticalTypeParameters(interfaceDeclAST, context)) {
+                this.semanticInfoChain.addDiagnosticFromAST(interfaceDeclAST.identifier, TypeScript.DiagnosticCode.All_declarations_of_an_interface_must_have_identical_type_parameters);
+            }
+        };
+
+        PullTypeResolver.prototype.checkInterfaceDeclForIdenticalTypeParameters = function (interfaceDeclAST, context) {
+            var interfaceDecl = this.semanticInfoChain.getDeclForAST(interfaceDeclAST);
+            var interfaceDeclSymbol = interfaceDecl.getSymbol();
+
+            if (!interfaceDeclSymbol.isGeneric()) {
+                return true;
+            }
+
+            var firstInterfaceDecl = interfaceDeclSymbol.getDeclarations()[0];
+            if (firstInterfaceDecl == interfaceDecl) {
+                return true;
+            }
+
+            var typeParameters = interfaceDecl.getTypeParameters();
+            var firstInterfaceDeclTypeParameters = firstInterfaceDecl.getTypeParameters();
+
+            if (typeParameters.length != firstInterfaceDeclTypeParameters.length) {
+                return false;
+            }
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                var typeParameter = typeParameters[i];
+                var firstInterfaceDeclTypeParameter = firstInterfaceDeclTypeParameters[i];
+
+                if (typeParameter.name != firstInterfaceDeclTypeParameter.name) {
+                    return false;
+                }
+
+                var typeParameterSymbol = typeParameter.getSymbol();
+                var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter);
+                var firstInterfaceDeclTypeParameterAST = this.semanticInfoChain.getASTForDecl(firstInterfaceDeclTypeParameter);
+
+                if (!!typeParameterAST.constraint != !!firstInterfaceDeclTypeParameterAST.constraint) {
+                    return false;
+                }
+
+                if (typeParameterAST.constraint) {
+                    var typeParameterConstraint = this.resolveAST(typeParameterAST.constraint, false, context);
+                    if (!this.typesAreIdenticalWithNewEnclosingTypes(typeParameterConstraint, typeParameterSymbol.getConstraint(), context)) {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.checkTypeForDuplicateIndexSignatures = function (enclosingTypeSymbol) {
+            var indexSignatures = enclosingTypeSymbol.getOwnIndexSignatures();
+            var firstStringIndexer = null;
+            var firstNumberIndexer = null;
+            for (var i = 0; i < indexSignatures.length; i++) {
+                var currentIndexer = indexSignatures[i];
+                var currentParameterType = currentIndexer.parameters[0].type;
+                TypeScript.Debug.assert(currentParameterType);
+                if (currentParameterType === this.semanticInfoChain.stringTypeSymbol) {
+                    if (firstStringIndexer) {
+                        this.semanticInfoChain.addDiagnosticFromAST(currentIndexer.getDeclarations()[0].ast(), TypeScript.DiagnosticCode.Duplicate_string_index_signature, null, [this.semanticInfoChain.locationFromAST(firstStringIndexer.getDeclarations()[0].ast())]);
+                        return;
+                    } else {
+                        firstStringIndexer = currentIndexer;
+                    }
+                } else if (currentParameterType === this.semanticInfoChain.numberTypeSymbol) {
+                    if (firstNumberIndexer) {
+                        this.semanticInfoChain.addDiagnosticFromAST(currentIndexer.getDeclarations()[0].ast(), TypeScript.DiagnosticCode.Duplicate_number_index_signature, null, [this.semanticInfoChain.locationFromAST(firstNumberIndexer.getDeclarations()[0].ast())]);
+                        return;
+                    } else {
+                        firstNumberIndexer = currentIndexer;
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.filterSymbol = function (symbol, kind, enclosingDecl, context) {
+            if (symbol) {
+                if (symbol.kind & kind) {
+                    return symbol;
+                }
+
+                if (symbol.isAlias()) {
+                    this.resolveDeclaredSymbol(symbol, context);
+
+                    var alias = symbol;
+                    if (kind & 164 /* SomeContainer */) {
+                        return alias.getExportAssignedContainerSymbol();
+                    } else if (kind & 58728795 /* SomeType */) {
+                        return alias.getExportAssignedTypeSymbol();
+                    } else if (kind & 68147712 /* SomeValue */) {
+                        return alias.getExportAssignedValueSymbol();
+                    }
+                }
+            }
+            return null;
+        };
+
+        PullTypeResolver.prototype.getMemberSymbolOfKind = function (symbolName, kind, pullTypeSymbol, enclosingDecl, context) {
+            var memberSymbol = this.getNamedPropertySymbol(symbolName, kind, pullTypeSymbol);
+
+            return {
+                symbol: this.filterSymbol(memberSymbol, kind, enclosingDecl, context),
+                aliasSymbol: memberSymbol && memberSymbol.isAlias() ? memberSymbol : null
+            };
+        };
+
+        PullTypeResolver.prototype.resolveIdentifierOfInternalModuleReference = function (importDecl, identifier, moduleSymbol, enclosingDecl, context) {
+            var rhsName = identifier.valueText();
+            if (rhsName.length === 0) {
+                return null;
+            }
+
+            var moduleTypeSymbol = moduleSymbol.type;
+            var memberSymbol = this.getMemberSymbolOfKind(rhsName, 164 /* SomeContainer */, moduleTypeSymbol, enclosingDecl, context);
+            var containerSymbol = memberSymbol.symbol;
+            var valueSymbol = null;
+            var typeSymbol = null;
+            var aliasSymbol = null;
+
+            var acceptableAlias = true;
+
+            if (containerSymbol) {
+                acceptableAlias = (containerSymbol.kind & 59753052 /* AcceptableAlias */) !== 0;
+                aliasSymbol = memberSymbol.aliasSymbol;
+            }
+
+            if (!acceptableAlias && containerSymbol && containerSymbol.kind === 128 /* TypeAlias */) {
+                this.resolveDeclaredSymbol(containerSymbol, context);
+                var aliasedAssignedValue = containerSymbol.getExportAssignedValueSymbol();
+                var aliasedAssignedType = containerSymbol.getExportAssignedTypeSymbol();
+                var aliasedAssignedContainer = containerSymbol.getExportAssignedContainerSymbol();
+
+                if (aliasedAssignedValue || aliasedAssignedType || aliasedAssignedContainer) {
+                    aliasSymbol = containerSymbol;
+                    valueSymbol = aliasedAssignedValue;
+                    typeSymbol = aliasedAssignedType;
+                    containerSymbol = aliasedAssignedContainer;
+                    acceptableAlias = true;
+                }
+            }
+
+            if (!acceptableAlias) {
+                this.semanticInfoChain.addDiagnosticFromAST(identifier, TypeScript.DiagnosticCode.Import_declaration_referencing_identifier_from_internal_module_can_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules);
+                return null;
+            }
+
+            if (!valueSymbol) {
+                if (moduleTypeSymbol.getInstanceSymbol()) {
+                    memberSymbol = this.getMemberSymbolOfKind(rhsName, 68147712 /* SomeValue */, moduleTypeSymbol.getInstanceSymbol().type, enclosingDecl, context);
+                    valueSymbol = memberSymbol.symbol;
+                    if (valueSymbol && memberSymbol.aliasSymbol) {
+                        aliasSymbol = memberSymbol.aliasSymbol;
+                    }
+                }
+            }
+
+            if (!typeSymbol) {
+                memberSymbol = this.getMemberSymbolOfKind(rhsName, 58728795 /* SomeType */, moduleTypeSymbol, enclosingDecl, context);
+                typeSymbol = memberSymbol.symbol;
+                if (typeSymbol && memberSymbol.aliasSymbol) {
+                    aliasSymbol = memberSymbol.aliasSymbol;
+                }
+            }
+
+            if (!valueSymbol && !typeSymbol && !containerSymbol) {
+                this.semanticInfoChain.addDiagnosticFromAST(identifier, TypeScript.DiagnosticCode.Could_not_find_symbol_0_in_module_1, [rhsName, moduleSymbol.toString()]);
+                return null;
+            }
+
+            if (!typeSymbol && containerSymbol) {
+                typeSymbol = containerSymbol;
+            }
+
+            return {
+                valueSymbol: valueSymbol,
+                typeSymbol: typeSymbol,
+                containerSymbol: containerSymbol,
+                aliasSymbol: aliasSymbol
+            };
+        };
+
+        PullTypeResolver.prototype.resolveModuleReference = function (importDecl, moduleNameExpr, enclosingDecl, context, declPath) {
+            TypeScript.Debug.assert(moduleNameExpr.kind() === 121 /* QualifiedName */ || moduleNameExpr.kind() === 11 /* IdentifierName */ || moduleNameExpr.kind() === 14 /* StringLiteral */, "resolving module reference should always be either name or member reference");
+
+            var moduleSymbol = null;
+            var moduleName;
+
+            if (moduleNameExpr.kind() === 121 /* QualifiedName */) {
+                var dottedNameAST = moduleNameExpr;
+                var moduleContainer = this.resolveModuleReference(importDecl, dottedNameAST.left, enclosingDecl, context, declPath);
+                if (moduleContainer) {
+                    moduleName = dottedNameAST.right.valueText();
+
+                    moduleSymbol = this.getMemberSymbolOfKind(moduleName, 4 /* Container */, moduleContainer.type, enclosingDecl, context).symbol;
+                    if (!moduleSymbol) {
+                        this.semanticInfoChain.addDiagnosticFromAST(dottedNameAST.right, TypeScript.DiagnosticCode.Could_not_find_module_0_in_module_1, [moduleName, moduleContainer.toString()]);
+                    }
+                }
+            } else {
+                var valueText = moduleNameExpr.kind() === 11 /* IdentifierName */ ? moduleNameExpr.valueText() : moduleNameExpr.valueText();
+                var text = moduleNameExpr.kind() === 11 /* IdentifierName */ ? moduleNameExpr.text() : moduleNameExpr.text();
+
+                if (text.length > 0) {
+                    var resolvedModuleNameSymbol = this.getSymbolFromDeclPath(valueText, declPath, 4 /* Container */);
+                    moduleSymbol = this.filterSymbol(resolvedModuleNameSymbol, 4 /* Container */, enclosingDecl, context);
+                    if (moduleSymbol) {
+                        this.semanticInfoChain.setSymbolForAST(moduleNameExpr, moduleSymbol);
+                        if (resolvedModuleNameSymbol.isAlias()) {
+                            this.semanticInfoChain.setAliasSymbolForAST(moduleNameExpr, resolvedModuleNameSymbol);
+                            var importDeclSymbol = importDecl.getSymbol();
+                            importDeclSymbol.addLinkedAliasSymbol(resolvedModuleNameSymbol);
+                        }
+                    } else {
+                        this.semanticInfoChain.addDiagnosticFromAST(moduleNameExpr, TypeScript.DiagnosticCode.Unable_to_resolve_module_reference_0, [valueText]);
+                    }
+                }
+            }
+
+            return moduleSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveInternalModuleReference = function (importStatementAST, context) {
+            var importDecl = this.semanticInfoChain.getDeclForAST(importStatementAST);
+            var enclosingDecl = this.getEnclosingDecl(importDecl);
+
+            var moduleReference = importStatementAST.moduleReference;
+
+            var aliasExpr = moduleReference.kind() === 245 /* ExternalModuleReference */ ? moduleReference.stringLiteral : moduleReference.moduleName;
+
+            var declPath = enclosingDecl.getParentPath();
+            var aliasedType = null;
+            var importDeclSymbol = importDecl.getSymbol();
+
+            if (aliasExpr.kind() === 11 /* IdentifierName */ || aliasExpr.kind() === 14 /* StringLiteral */) {
+                var moduleSymbol = this.resolveModuleReference(importDecl, aliasExpr, enclosingDecl, context, declPath);
+                if (moduleSymbol) {
+                    aliasedType = moduleSymbol.type;
+                    this.semanticInfoChain.setAliasSymbolForAST(moduleReference, this.semanticInfoChain.getAliasSymbolForAST(aliasExpr));
+                    if (aliasedType.anyDeclHasFlag(32768 /* InitializedModule */)) {
+                        var moduleName = aliasExpr.kind() === 11 /* IdentifierName */ ? aliasExpr.valueText() : aliasExpr.valueText();
+                        var valueSymbol = this.getSymbolFromDeclPath(moduleName, declPath, 68147712 /* SomeValue */);
+                        var instanceSymbol = aliasedType.getInstanceSymbol();
+
+                        if (valueSymbol && (instanceSymbol != valueSymbol || valueSymbol.type === aliasedType)) {
+                            var text = aliasExpr.kind() === 11 /* IdentifierName */ ? aliasExpr.text() : aliasExpr.text();
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(aliasExpr, TypeScript.DiagnosticCode.Internal_module_reference_0_in_import_declaration_does_not_reference_module_instance_for_1, [text, moduleSymbol.type.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)]));
+                        } else {
+                            importDeclSymbol.setAssignedValueSymbol(valueSymbol);
+                        }
+                    }
+                } else {
+                    aliasedType = this.getNewErrorTypeSymbol();
+                }
+            } else if (aliasExpr.kind() === 121 /* QualifiedName */) {
+                var dottedNameAST = aliasExpr;
+                var moduleSymbol = this.resolveModuleReference(importDecl, dottedNameAST.left, enclosingDecl, context, declPath);
+                if (moduleSymbol) {
+                    var identifierResolution = this.resolveIdentifierOfInternalModuleReference(importDecl, dottedNameAST.right, moduleSymbol, enclosingDecl, context);
+                    if (identifierResolution) {
+                        importDeclSymbol.setAssignedValueSymbol(identifierResolution.valueSymbol);
+                        importDeclSymbol.setAssignedTypeSymbol(identifierResolution.typeSymbol);
+                        importDeclSymbol.setAssignedContainerSymbol(identifierResolution.containerSymbol);
+                        this.semanticInfoChain.setAliasSymbolForAST(moduleReference, identifierResolution.aliasSymbol);
+                        return null;
+                    }
+                }
+            }
+
+            if (!aliasedType) {
+                importDeclSymbol.setAssignedTypeSymbol(this.getNewErrorTypeSymbol());
+            }
+
+            return aliasedType;
+        };
+
+        PullTypeResolver.prototype.resolveImportDeclaration = function (importStatementAST, context) {
+            var importDecl = this.semanticInfoChain.getDeclForAST(importStatementAST);
+            var enclosingDecl = this.getEnclosingDecl(importDecl);
+            var importDeclSymbol = importDecl.getSymbol();
+
+            var aliasedType = null;
+
+            if (importDeclSymbol.isResolved) {
+                return importDeclSymbol;
+            }
+
+            importDeclSymbol.startResolving();
+
+            if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) {
+                var modPath = importStatementAST.moduleReference.stringLiteral.valueText();
+                var declPath = enclosingDecl.getParentPath();
+
+                aliasedType = this.resolveExternalModuleReference(modPath, importDecl.fileName());
+
+                if (!aliasedType) {
+                    var path = importStatementAST.moduleReference.stringLiteral.text();
+                    this.semanticInfoChain.addDiagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Unable_to_resolve_external_module_0, [path]);
+                    aliasedType = this.getNewErrorTypeSymbol();
+                }
+            } else {
+                aliasedType = this.resolveInternalModuleReference(importStatementAST, context);
+            }
+
+            if (aliasedType) {
+                if (!aliasedType.isContainer()) {
+                    this.semanticInfoChain.addDiagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Module_cannot_be_aliased_to_a_non_module_type);
+                    if (!aliasedType.isError()) {
+                        aliasedType = this.getNewErrorTypeSymbol();
+                    }
+                }
+
+                if (aliasedType.isContainer()) {
+                    importDeclSymbol.setAssignedContainerSymbol(aliasedType);
+                }
+                importDeclSymbol.setAssignedTypeSymbol(aliasedType);
+
+                this.setSymbolForAST(importStatementAST.moduleReference, aliasedType, null);
+            }
+
+            importDeclSymbol.setResolved();
+
+            this.resolveDeclaredSymbol(importDeclSymbol.assignedValue(), context);
+            this.resolveDeclaredSymbol(importDeclSymbol.assignedType(), context);
+            this.resolveDeclaredSymbol(importDeclSymbol.assignedContainer(), context);
+
+            if (aliasedType && importDeclSymbol.anyDeclHasFlag(1 /* Exported */)) {
+                importDeclSymbol.setIsUsedInExportedAlias();
+
+                if (aliasedType.isContainer() && aliasedType.getExportAssignedValueSymbol()) {
+                    importDeclSymbol.setIsUsedAsValue();
+                }
+            }
+
+            if (this.canTypeCheckAST(importStatementAST, context)) {
+                this.typeCheckImportDeclaration(importStatementAST, context);
+            }
+
+            return importDeclSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckImportDeclaration = function (importStatementAST, context) {
+            var _this = this;
+            this.setTypeChecked(importStatementAST, context);
+
+            var importDecl = this.semanticInfoChain.getDeclForAST(importStatementAST);
+            var enclosingDecl = this.getEnclosingDecl(importDecl);
+            var importDeclSymbol = importDecl.getSymbol();
+
+            if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) {
+                if (this.compilationSettings.noResolve()) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Import_declaration_cannot_refer_to_external_module_reference_when_noResolve_option_is_set, null));
+                }
+
+                var modPath = importStatementAST.moduleReference.stringLiteral.valueText();
+                if (enclosingDecl.kind === 32 /* DynamicModule */) {
+                    var ast = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(this.getASTForDecl(enclosingDecl));
+                    if (ast && ast.kind() === 130 /* ModuleDeclaration */) {
+                        if (TypeScript.isRelative(modPath)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Import_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name));
+                        }
+                    }
+                }
+            }
+
+            var checkPrivacy;
+            if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) {
+                var containerSymbol = importDeclSymbol.getExportAssignedContainerSymbol();
+                var container = containerSymbol ? containerSymbol.getContainer() : null;
+                if (container && container.kind === 32 /* DynamicModule */) {
+                    checkPrivacy = true;
+                }
+            } else {
+                checkPrivacy = true;
+            }
+
+            if (checkPrivacy) {
+                var typeSymbol = importDeclSymbol.getExportAssignedTypeSymbol();
+                var containerSymbol = importDeclSymbol.getExportAssignedContainerSymbol();
+                var valueSymbol = importDeclSymbol.getExportAssignedValueSymbol();
+
+                this.checkSymbolPrivacy(importDeclSymbol, containerSymbol, function (symbol) {
+                    var messageCode = TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_container_that_is_or_is_using_inaccessible_module_1;
+                    var messageArguments = [importDeclSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null), symbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null, false, false, true)];
+                    context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(importStatementAST, messageCode, messageArguments));
+                });
+
+                if (typeSymbol !== containerSymbol) {
+                    this.checkSymbolPrivacy(importDeclSymbol, typeSymbol, function (symbol) {
+                        var messageCode = symbol.isContainer() && !symbol.isEnum() ? TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_type_that_is_using_inaccessible_module_1 : TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_type_that_has_or_is_using_private_type_1;
+
+                        var messageArguments = [importDeclSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null), symbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null, false, false, true)];
+                        context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(importStatementAST, messageCode, messageArguments));
+                    });
+                }
+
+                if (valueSymbol) {
+                    this.checkSymbolPrivacy(importDeclSymbol, valueSymbol.type, function (symbol) {
+                        var messageCode = symbol.isContainer() && !symbol.isEnum() ? TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_value_with_type_that_is_using_inaccessible_module_1 : TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_value_with_type_that_has_or_is_using_private_type_1;
+                        var messageArguments = [importDeclSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null), symbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null, false, false, true)];
+                        context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(importStatementAST, messageCode, messageArguments));
+                    });
+                }
+            }
+
+            this.checkNameForCompilerGeneratedDeclarationCollision(importStatementAST, true, importStatementAST.identifier, context);
+        };
+
+        PullTypeResolver.prototype.postTypeCheckImportDeclaration = function (importStatementAST, context) {
+            var importDecl = this.semanticInfoChain.getDeclForAST(importStatementAST);
+            var importSymbol = importDecl.getSymbol();
+
+            var isUsedAsValue = importSymbol.isUsedAsValue();
+            var hasAssignedValue = importStatementAST.moduleReference.kind() !== 245 /* ExternalModuleReference */ && importSymbol.getExportAssignedValueSymbol() !== null;
+
+            if (isUsedAsValue || hasAssignedValue) {
+                this.checkThisCaptureVariableCollides(importStatementAST, true, context);
+            }
+        };
+
+        PullTypeResolver.prototype.resolveExportAssignmentStatement = function (exportAssignmentAST, context) {
+            var id = exportAssignmentAST.identifier.valueText();
+            if (id.length === 0) {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var valueSymbol = null;
+            var typeSymbol = null;
+            var containerSymbol = null;
+
+            var enclosingDecl = this.getEnclosingDeclForAST(exportAssignmentAST);
+            var parentSymbol = enclosingDecl.getSymbol();
+
+            if (!parentSymbol.isType() && parentSymbol.isContainer()) {
+                this.semanticInfoChain.addDiagnosticFromAST(exportAssignmentAST, TypeScript.DiagnosticCode.Export_assignments_may_only_be_used_at_the_top_level_of_external_modules);
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var declPath = enclosingDecl !== null ? [enclosingDecl] : [];
+
+            containerSymbol = this.getSymbolFromDeclPath(id, declPath, 164 /* SomeContainer */);
+
+            var acceptableAlias = true;
+
+            if (containerSymbol) {
+                acceptableAlias = (containerSymbol.kind & 59753052 /* AcceptableAlias */) !== 0;
+            }
+
+            if (!acceptableAlias && containerSymbol && containerSymbol.kind === 128 /* TypeAlias */) {
+                this.resolveDeclaredSymbol(containerSymbol, context);
+
+                var aliasSymbol = containerSymbol;
+                var aliasedAssignedValue = aliasSymbol.getExportAssignedValueSymbol();
+                var aliasedAssignedType = aliasSymbol.getExportAssignedTypeSymbol();
+                var aliasedAssignedContainer = aliasSymbol.getExportAssignedContainerSymbol();
+
+                if (aliasedAssignedValue || aliasedAssignedType || aliasedAssignedContainer) {
+                    valueSymbol = aliasedAssignedValue;
+                    typeSymbol = aliasedAssignedType;
+                    containerSymbol = aliasedAssignedContainer;
+                    aliasSymbol.setTypeUsedExternally();
+                    if (valueSymbol) {
+                        aliasSymbol.setIsUsedAsValue();
+                    }
+                    acceptableAlias = true;
+                }
+            }
+
+            if (!acceptableAlias) {
+                this.semanticInfoChain.addDiagnosticFromAST(exportAssignmentAST, TypeScript.DiagnosticCode.Export_assignments_may_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules);
+                return this.semanticInfoChain.voidTypeSymbol;
+            }
+
+            if (!valueSymbol) {
+                valueSymbol = this.getSymbolFromDeclPath(id, declPath, 68147712 /* SomeValue */);
+            }
+            if (!typeSymbol) {
+                typeSymbol = this.getSymbolFromDeclPath(id, declPath, 58728795 /* SomeType */);
+            }
+
+            if (!valueSymbol && !typeSymbol && !containerSymbol) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(exportAssignmentAST, TypeScript.DiagnosticCode.Could_not_find_symbol_0, [id]));
+                return this.semanticInfoChain.voidTypeSymbol;
+            }
+
+            if (valueSymbol) {
+                parentSymbol.setExportAssignedValueSymbol(valueSymbol);
+            }
+            if (typeSymbol) {
+                parentSymbol.setExportAssignedTypeSymbol(typeSymbol);
+            }
+            if (containerSymbol) {
+                parentSymbol.setExportAssignedContainerSymbol(containerSymbol);
+            }
+
+            this.resolveDeclaredSymbol(valueSymbol, context);
+            this.resolveDeclaredSymbol(typeSymbol, context);
+            this.resolveDeclaredSymbol(containerSymbol, context);
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveAnyFunctionTypeSignature = function (funcDeclAST, typeParameters, parameterList, returnTypeAnnotation, context) {
+            var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            TypeScript.Debug.assert(functionDecl);
+
+            var funcDeclSymbol = functionDecl.getSymbol();
+
+            var signature = funcDeclSymbol.kind === 33554432 /* ConstructorType */ ? funcDeclSymbol.getConstructSignatures()[0] : funcDeclSymbol.getCallSignatures()[0];
+
+            if (returnTypeAnnotation) {
+                signature.returnType = this.resolveTypeReference(returnTypeAnnotation, context);
+            }
+
+            if (typeParameters) {
+                for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) {
+                    this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context);
+                }
+            }
+
+            if (parameterList) {
+                for (var i = 0; i < parameterList.parameters.nonSeparatorCount(); i++) {
+                    this.resolveFunctionTypeSignatureParameter(parameterList.parameters.nonSeparatorAt(i), signature, functionDecl, context);
+                }
+            }
+
+            funcDeclSymbol.setResolved();
+
+            if (this.canTypeCheckAST(funcDeclAST, context)) {
+                this.setTypeChecked(funcDeclAST, context);
+                this.typeCheckFunctionOverloads(funcDeclAST, context);
+            }
+
+            return funcDeclSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveFunctionTypeSignatureParameter = function (argDeclAST, signature, enclosingDecl, context) {
+            var paramDecl = this.semanticInfoChain.getDeclForAST(argDeclAST);
+            var paramSymbol = paramDecl.getSymbol();
+
+            if (argDeclAST.typeAnnotation) {
+                var typeRef = this.resolveTypeReference(TypeScript.ASTHelpers.getType(argDeclAST), context);
+
+                if (paramSymbol.isVarArg && !typeRef.isArrayNamedTypeReference()) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Rest_parameters_must_be_array_types));
+                    typeRef = this.getNewErrorTypeSymbol();
+                }
+
+                context.setTypeInContext(paramSymbol, typeRef);
+            } else {
+                if (paramSymbol.isVarArg) {
+                    if (this.cachedArrayInterfaceType()) {
+                        context.setTypeInContext(paramSymbol, this.createInstantiatedType(this.cachedArrayInterfaceType(), [this.semanticInfoChain.anyTypeSymbol]));
+                    } else {
+                        context.setTypeInContext(paramSymbol, this.semanticInfoChain.anyTypeSymbol);
+                    }
+                } else {
+                    context.setTypeInContext(paramSymbol, this.semanticInfoChain.anyTypeSymbol);
+                }
+
+                if (this.compilationSettings.noImplicitAny()) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Parameter_0_of_function_type_implicitly_has_an_any_type, [argDeclAST.identifier.text()]));
+                }
+            }
+
+            if (TypeScript.hasFlag(paramDecl.flags, 128 /* Optional */) && argDeclAST.equalsValueClause && isTypesOnlyLocation(argDeclAST)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Default_arguments_are_only_allowed_in_implementation));
+            }
+
+            paramSymbol.setResolved();
+        };
+
+        PullTypeResolver.prototype.resolveFunctionExpressionParameter = function (argDeclAST, id, typeExpr, equalsValueClause, contextParam, enclosingDecl, context) {
+            var paramDecl = this.semanticInfoChain.getDeclForAST(argDeclAST);
+            var paramSymbol = paramDecl.getSymbol();
+            var contextualType = contextParam && contextParam.type;
+            var isImplicitAny = false;
+
+            if (typeExpr) {
+                var typeRef = this.resolveTypeReference(typeExpr, context);
+
+                if (paramSymbol.isVarArg && !typeRef.isArrayNamedTypeReference()) {
+                    var diagnostic = context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Rest_parameters_must_be_array_types));
+                    typeRef = this.getNewErrorTypeSymbol();
+                }
+
+                contextualType = typeRef || contextualType;
+            }
+            if (contextualType) {
+                if (context.isInferentiallyTyping()) {
+                    contextualType = context.fixAllTypeParametersReferencedByType(contextualType, this);
+                }
+                context.setTypeInContext(paramSymbol, contextualType);
+            } else if (paramSymbol.isVarArg) {
+                if (this.cachedArrayInterfaceType()) {
+                    context.setTypeInContext(paramSymbol, this.createInstantiatedType(this.cachedArrayInterfaceType(), [this.semanticInfoChain.anyTypeSymbol]));
+                } else {
+                    context.setTypeInContext(paramSymbol, this.semanticInfoChain.anyTypeSymbol);
+                }
+                isImplicitAny = true;
+            }
+
+            var canTypeCheckAST = this.canTypeCheckAST(argDeclAST, context);
+            if (equalsValueClause && (canTypeCheckAST || !contextualType)) {
+                if (contextualType) {
+                    context.propagateContextualType(contextualType);
+                }
+
+                var initExprSymbol = this.resolveAST(equalsValueClause, contextualType !== null, context);
+
+                if (contextualType) {
+                    context.popAnyContextualType();
+                }
+
+                if (!initExprSymbol || !initExprSymbol.type) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Unable_to_resolve_type_of_0, [id.text()]));
+
+                    if (!contextualType) {
+                        context.setTypeInContext(paramSymbol, this.getNewErrorTypeSymbol(paramSymbol.name));
+                    }
+                } else {
+                    var initTypeSymbol = this.getInstanceTypeForAssignment(argDeclAST, initExprSymbol.type, context);
+                    if (!contextualType) {
+                        context.setTypeInContext(paramSymbol, initTypeSymbol.widenedType(this, equalsValueClause, context));
+                        isImplicitAny = initTypeSymbol !== paramSymbol.type;
+                    } else {
+                        var comparisonInfo = new TypeComparisonInfo();
+
+                        var isAssignable = this.sourceIsAssignableToTarget(initTypeSymbol, contextualType, argDeclAST, context, comparisonInfo);
+
+                        if (!isAssignable) {
+                            var enclosingSymbol = this.getEnclosingSymbolForAST(argDeclAST);
+                            if (comparisonInfo.message) {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [initTypeSymbol.toString(enclosingSymbol), contextualType.toString(enclosingSymbol), comparisonInfo.message]));
+                            } else {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [initTypeSymbol.toString(enclosingSymbol), contextualType.toString(enclosingSymbol)]));
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (!contextualType && !paramSymbol.isVarArg && !initTypeSymbol) {
+                context.setTypeInContext(paramSymbol, this.semanticInfoChain.anyTypeSymbol);
+                isImplicitAny = true;
+            }
+
+            if (isImplicitAny && this.compilationSettings.noImplicitAny()) {
+                var functionExpressionName = paramDecl.getParentDecl().getFunctionExpressionName();
+                if (functionExpressionName) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Parameter_0_of_1_implicitly_has_an_any_type, [id.text(), functionExpressionName]));
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Parameter_0_of_lambda_function_implicitly_has_an_any_type, [id.text()]));
+                }
+            }
+
+            if (canTypeCheckAST) {
+                this.checkNameForCompilerGeneratedDeclarationCollision(argDeclAST, true, id, context);
+            }
+
+            paramSymbol.setResolved();
+        };
+
+        PullTypeResolver.prototype.checkNameForCompilerGeneratedDeclarationCollision = function (astWithName, isDeclaration, name, context) {
+            var compilerReservedName = getCompilerReservedName(name);
+            switch (compilerReservedName) {
+                case 1 /* _this */:
+                    this.postTypeCheckWorkitems.push(astWithName);
+                    return;
+
+                case 2 /* _super */:
+                    this.checkSuperCaptureVariableCollides(astWithName, isDeclaration, context);
+                    return;
+
+                case 3 /* arguments */:
+                    this.checkArgumentsCollides(astWithName, context);
+                    return;
+
+                case 4 /* _i */:
+                    this.checkIndexOfRestArgumentInitializationCollides(astWithName, isDeclaration, context);
+                    return;
+
+                case 5 /* require */:
+                case 6 /* exports */:
+                    if (isDeclaration) {
+                        this.checkExternalModuleRequireExportsCollides(astWithName, name, context);
+                    }
+                    return;
+            }
+        };
+
+        PullTypeResolver.prototype.hasRestParameterCodeGen = function (someFunctionDecl) {
+            var enclosingAST = this.getASTForDecl(someFunctionDecl);
+            var nodeType = enclosingAST.kind();
+
+            if (nodeType === 129 /* FunctionDeclaration */) {
+                var functionDeclaration = enclosingAST;
+                return !TypeScript.hasFlag(someFunctionDecl.kind === 65536 /* Method */ ? someFunctionDecl.getParentDecl().flags : someFunctionDecl.flags, 8 /* Ambient */) && functionDeclaration.block && TypeScript.lastParameterIsRest(functionDeclaration.callSignature.parameterList);
+            } else if (nodeType === 135 /* MemberFunctionDeclaration */) {
+                var memberFunction = enclosingAST;
+                return !TypeScript.hasFlag(someFunctionDecl.kind === 65536 /* Method */ ? someFunctionDecl.getParentDecl().flags : someFunctionDecl.flags, 8 /* Ambient */) && memberFunction.block && TypeScript.lastParameterIsRest(memberFunction.callSignature.parameterList);
+            } else if (nodeType === 137 /* ConstructorDeclaration */) {
+                var constructorDeclaration = enclosingAST;
+                return !TypeScript.hasFlag(someFunctionDecl.getParentDecl().flags, 8 /* Ambient */) && constructorDeclaration.block && TypeScript.lastParameterIsRest(constructorDeclaration.callSignature.parameterList);
+            } else if (nodeType === 218 /* ParenthesizedArrowFunctionExpression */) {
+                var arrowFunctionExpression = enclosingAST;
+                return TypeScript.lastParameterIsRest(arrowFunctionExpression.callSignature.parameterList);
+            } else if (nodeType === 222 /* FunctionExpression */) {
+                var functionExpression = enclosingAST;
+                return TypeScript.lastParameterIsRest(functionExpression.callSignature.parameterList);
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.checkArgumentsCollides = function (ast, context) {
+            if (ast.kind() === 242 /* Parameter */) {
+                var enclosingDecl = this.getEnclosingDeclForAST(ast);
+                if (TypeScript.hasFlag(enclosingDecl.kind, 1032192 /* SomeFunction */)) {
+                    if (this.hasRestParameterCodeGen(enclosingDecl)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters));
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.checkIndexOfRestArgumentInitializationCollides = function (ast, isDeclaration, context) {
+            if (!isDeclaration || ast.kind() === 242 /* Parameter */) {
+                var enclosingDecl = this.getEnclosingDeclForAST(ast);
+                var declPath = isDeclaration ? [enclosingDecl] : (enclosingDecl ? enclosingDecl.getParentPath() : []);
+                var resolvedSymbol = null;
+                var resolvedSymbolContainer;
+                for (var i = declPath.length - 1; i >= 0; i--) {
+                    var decl = declPath[i];
+                    if (!isDeclaration) {
+                        if (!resolvedSymbol) {
+                            resolvedSymbol = this.resolveNameExpression(ast, context);
+                            if (resolvedSymbol.isError()) {
+                                return;
+                            }
+
+                            resolvedSymbolContainer = resolvedSymbol.getContainer();
+                        }
+
+                        if (resolvedSymbolContainer && TypeScript.ArrayUtilities.contains(resolvedSymbolContainer.getDeclarations(), decl)) {
+                            break;
+                        }
+                    }
+
+                    if (TypeScript.hasFlag(decl.kind, 1032192 /* SomeFunction */)) {
+                        if (this.hasRestParameterCodeGen(decl)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, isDeclaration ? TypeScript.DiagnosticCode.Duplicate_identifier_i_Compiler_uses_i_to_initialize_rest_parameter : TypeScript.DiagnosticCode.Expression_resolves_to_variable_declaration_i_that_compiler_uses_to_initialize_rest_parameter));
+                        }
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.checkExternalModuleRequireExportsCollides = function (ast, name, context) {
+            var enclosingDecl = this.getEnclosingDeclForAST(ast);
+
+            var enclosingModule = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(name);
+            if (TypeScript.ASTHelpers.isAnyNameOfModule(enclosingModule, name)) {
+                enclosingDecl = this.getEnclosingDeclForAST(enclosingModule);
+            }
+
+            if (enclosingDecl && enclosingDecl.kind === 32 /* DynamicModule */) {
+                var decl = this.semanticInfoChain.getDeclForAST(ast);
+
+                if (!TypeScript.hasFlag(decl.flags, 8 /* Ambient */)) {
+                    var nameText = name.valueText();
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module, [nameText, nameText]));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveObjectTypeTypeReference = function (objectType, context) {
+            var interfaceDecl = this.semanticInfoChain.getDeclForAST(objectType);
+            TypeScript.Debug.assert(interfaceDecl);
+
+            var interfaceSymbol = interfaceDecl.getSymbol();
+            TypeScript.Debug.assert(interfaceSymbol);
+
+            if (objectType.typeMembers) {
+                var memberDecl = null;
+                var memberSymbol = null;
+                var memberType = null;
+                var typeMembers = objectType.typeMembers;
+
+                for (var i = 0; i < typeMembers.nonSeparatorCount(); i++) {
+                    memberDecl = this.semanticInfoChain.getDeclForAST(typeMembers.nonSeparatorAt(i));
+                    memberSymbol = (memberDecl.kind & 7340032 /* SomeSignature */) ? memberDecl.getSignatureSymbol() : memberDecl.getSymbol();
+
+                    this.resolveAST(typeMembers.nonSeparatorAt(i), false, context);
+
+                    memberType = memberSymbol.type;
+
+                    if ((memberType && memberType.isGeneric()) || (memberSymbol.isSignature() && memberSymbol.isGeneric())) {
+                        interfaceSymbol.setHasGenericMember();
+                    }
+                }
+            }
+
+            interfaceSymbol.setResolved();
+
+            if (this.canTypeCheckAST(objectType, context)) {
+                this.typeCheckObjectTypeTypeReference(objectType, context);
+            }
+
+            return interfaceSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckObjectTypeTypeReference = function (objectType, context) {
+            this.setTypeChecked(objectType, context);
+            var objectTypeDecl = this.semanticInfoChain.getDeclForAST(objectType);
+            var objectTypeSymbol = objectTypeDecl.getSymbol();
+
+            this.typeCheckMembersAgainstIndexer(objectTypeSymbol, objectTypeDecl, context);
+            this.checkTypeForDuplicateIndexSignatures(objectTypeSymbol);
+        };
+
+        PullTypeResolver.prototype.resolveTypeAnnotation = function (typeAnnotation, context) {
+            return this.resolveTypeReference(typeAnnotation.type, context);
+        };
+
+        PullTypeResolver.prototype.resolveTypeReference = function (typeRef, context) {
+            if (typeRef === null) {
+                return null;
+            }
+
+            TypeScript.Debug.assert(typeRef.kind() !== 244 /* TypeAnnotation */);
+
+            var aliasType = null;
+            var type = this.computeTypeReferenceSymbol(typeRef, context);
+
+            if (type.kind === 4 /* Container */) {
+                var container = type;
+                var instanceSymbol = container.getInstanceSymbol();
+
+                if (instanceSymbol && (instanceSymbol.anyDeclHasFlag(16384 /* ClassConstructorVariable */) || instanceSymbol.kind === 32768 /* ConstructorMethod */)) {
+                    type = instanceSymbol.type.getAssociatedContainerType();
+                }
+            }
+
+            if (type && type.isAlias()) {
+                aliasType = type;
+                type = aliasType.getExportAssignedTypeSymbol();
+            }
+
+            if (type && !type.isGeneric()) {
+                if (aliasType) {
+                    this.semanticInfoChain.setAliasSymbolForAST(typeRef, aliasType);
+                }
+            }
+
+            if (type && !type.isError()) {
+                if ((type.kind & 58728795 /* SomeType */) === 0) {
+                    if (type.kind & 164 /* SomeContainer */) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeRef, TypeScript.DiagnosticCode.Type_reference_cannot_refer_to_container_0, [aliasType ? aliasType.toString() : type.toString()]));
+                    } else {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeRef, TypeScript.DiagnosticCode.Type_reference_must_refer_to_type));
+                    }
+                }
+            }
+
+            if (this.canTypeCheckAST(typeRef, context)) {
+                this.setTypeChecked(typeRef, context);
+            }
+
+            return type;
+        };
+
+        PullTypeResolver.prototype.getArrayType = function (elementType) {
+            var arraySymbol = elementType.getArrayType();
+
+            if (!arraySymbol) {
+                arraySymbol = this.createInstantiatedType(this.cachedArrayInterfaceType(), [elementType]);
+
+                if (!arraySymbol) {
+                    arraySymbol = this.semanticInfoChain.anyTypeSymbol;
+                }
+
+                elementType.setArrayType(arraySymbol);
+            }
+
+            return arraySymbol;
+        };
+
+        PullTypeResolver.prototype.computeTypeReferenceSymbol = function (term, context) {
+            switch (term.kind()) {
+                case 60 /* AnyKeyword */:
+                    return this.semanticInfoChain.anyTypeSymbol;
+                case 61 /* BooleanKeyword */:
+                    return this.semanticInfoChain.booleanTypeSymbol;
+                case 67 /* NumberKeyword */:
+                    return this.semanticInfoChain.numberTypeSymbol;
+                case 69 /* StringKeyword */:
+                    return this.semanticInfoChain.stringTypeSymbol;
+                case 41 /* VoidKeyword */:
+                    return this.semanticInfoChain.voidTypeSymbol;
+            }
+
+            var typeDeclSymbol = null;
+
+            if (term.kind() === 11 /* IdentifierName */) {
+                typeDeclSymbol = this.resolveTypeNameExpression(term, context);
+            } else if (term.kind() === 123 /* FunctionType */) {
+                var functionType = term;
+                typeDeclSymbol = this.resolveAnyFunctionTypeSignature(functionType, functionType.typeParameterList, functionType.parameterList, functionType.type, context);
+            } else if (term.kind() === 125 /* ConstructorType */) {
+                var constructorType = term;
+                typeDeclSymbol = this.resolveAnyFunctionTypeSignature(constructorType, constructorType.typeParameterList, constructorType.parameterList, constructorType.type, context);
+            } else if (term.kind() === 122 /* ObjectType */) {
+                typeDeclSymbol = this.resolveObjectTypeTypeReference(term, context);
+            } else if (term.kind() === 126 /* GenericType */) {
+                typeDeclSymbol = this.resolveGenericTypeReference(term, context);
+            } else if (term.kind() === 121 /* QualifiedName */) {
+                typeDeclSymbol = this.resolveQualifiedName(term, context);
+            } else if (term.kind() === 14 /* StringLiteral */) {
+                var stringConstantAST = term;
+                var enclosingDecl = this.getEnclosingDeclForAST(term);
+                typeDeclSymbol = new TypeScript.PullStringConstantTypeSymbol(stringConstantAST.text());
+                var decl = new TypeScript.PullSynthesizedDecl(stringConstantAST.text(), stringConstantAST.text(), typeDeclSymbol.kind, null, enclosingDecl, enclosingDecl.semanticInfoChain);
+                typeDeclSymbol.addDeclaration(decl);
+            } else if (term.kind() === 127 /* TypeQuery */) {
+                var typeQuery = term;
+
+                var typeQueryTerm = typeQuery.name;
+
+                var valueSymbol = this.resolveAST(typeQueryTerm, false, context);
+
+                if (valueSymbol && valueSymbol.isAlias()) {
+                    if (valueSymbol.assignedValue()) {
+                        valueSymbol = valueSymbol.assignedValue();
+                    } else {
+                        var containerSymbol = valueSymbol.getExportAssignedContainerSymbol();
+                        valueSymbol = (containerSymbol && containerSymbol.isContainer() && !containerSymbol.isEnum()) ? containerSymbol.getInstanceSymbol() : null;
+                    }
+                }
+
+                if (valueSymbol) {
+                    typeDeclSymbol = valueSymbol.type.widenedType(this, typeQueryTerm, context);
+                } else {
+                    typeDeclSymbol = this.getNewErrorTypeSymbol();
+                }
+            } else if (term.kind() === 124 /* ArrayType */) {
+                var arrayType = term;
+                var underlying = this.resolveTypeReference(arrayType.type, context);
+                typeDeclSymbol = this.getArrayType(underlying);
+            } else {
+                throw TypeScript.Errors.invalidOperation("unknown type");
+            }
+
+            if (!typeDeclSymbol) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(term, TypeScript.DiagnosticCode.Unable_to_resolve_type));
+                return this.getNewErrorTypeSymbol();
+            }
+
+            if (typeDeclSymbol.isError()) {
+                return typeDeclSymbol;
+            }
+
+            if (this.genericTypeIsUsedWithoutRequiredTypeArguments(typeDeclSymbol, term, context)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(term, TypeScript.DiagnosticCode.Generic_type_references_must_include_all_type_arguments));
+                typeDeclSymbol = this.instantiateTypeToAny(typeDeclSymbol, context);
+            }
+
+            return typeDeclSymbol;
+        };
+
+        PullTypeResolver.prototype.genericTypeIsUsedWithoutRequiredTypeArguments = function (typeSymbol, term, context) {
+            if (!typeSymbol) {
+                return false;
+            }
+
+            if (typeSymbol.isAlias()) {
+                return this.genericTypeIsUsedWithoutRequiredTypeArguments(typeSymbol.getExportAssignedTypeSymbol(), term, context);
+            }
+
+            return typeSymbol.isNamedTypeSymbol() && typeSymbol.isGeneric() && !typeSymbol.isTypeParameter() && (typeSymbol.isResolved || typeSymbol.inResolution) && !typeSymbol.getIsSpecialized() && typeSymbol.getTypeParameters().length && typeSymbol.getTypeArguments() === null && this.isTypeRefWithoutTypeArgs(term);
+        };
+
+        PullTypeResolver.prototype.resolveMemberVariableDeclaration = function (varDecl, context) {
+            return this.resolveVariableDeclaratorOrParameterOrEnumElement(varDecl, varDecl.modifiers, varDecl.variableDeclarator.propertyName, TypeScript.ASTHelpers.getType(varDecl.variableDeclarator), varDecl.variableDeclarator.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.resolvePropertySignature = function (varDecl, context) {
+            return this.resolveVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.sentinelEmptyArray, varDecl.propertyName, TypeScript.ASTHelpers.getType(varDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.resolveVariableDeclarator = function (varDecl, context) {
+            return this.resolveVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.ASTHelpers.getVariableDeclaratorModifiers(varDecl), varDecl.propertyName, TypeScript.ASTHelpers.getType(varDecl), varDecl.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.resolveParameterList = function (list, context) {
+            return this.resolveSeparatedList(list.parameters, context);
+        };
+
+        PullTypeResolver.prototype.resolveParameter = function (parameter, context) {
+            return this.resolveVariableDeclaratorOrParameterOrEnumElement(parameter, parameter.modifiers, parameter.identifier, TypeScript.ASTHelpers.getType(parameter), parameter.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.getEnumTypeSymbol = function (enumElement, context) {
+            var enumDeclaration = enumElement.parent.parent;
+            var decl = this.semanticInfoChain.getDeclForAST(enumDeclaration);
+            var symbol = decl.getSymbol();
+            this.resolveDeclaredSymbol(symbol, context);
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.resolveEnumElement = function (enumElement, context) {
+            return this.resolveVariableDeclaratorOrParameterOrEnumElement(enumElement, TypeScript.sentinelEmptyArray, enumElement.propertyName, null, enumElement.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckEnumElement = function (enumElement, context) {
+            this.typeCheckVariableDeclaratorOrParameterOrEnumElement(enumElement, TypeScript.sentinelEmptyArray, enumElement.propertyName, null, enumElement.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.resolveEqualsValueClause = function (clause, isContextuallyTyped, context) {
+            if (this.canTypeCheckAST(clause, context)) {
+                this.setTypeChecked(clause, context);
+            }
+
+            return this.resolveAST(clause.value, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.resolveVariableDeclaratorOrParameterOrEnumElement = function (varDeclOrParameter, modifiers, name, typeExpr, init, context) {
+            var hasTypeExpr = typeExpr !== null || varDeclOrParameter.kind() === 243 /* EnumElement */;
+            var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter);
+            var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter);
+
+            if (enclosingDecl && decl.kind === 2048 /* Parameter */) {
+                enclosingDecl.ensureSymbolIsBound();
+            }
+
+            var declSymbol = decl.getSymbol();
+            var declParameterSymbol = decl.getValueDecl() ? decl.getValueDecl().getSymbol() : null;
+
+            if (declSymbol.isResolved) {
+                var declType = declSymbol.type;
+                var valDecl = decl.getValueDecl();
+
+                if (valDecl) {
+                    var valSymbol = valDecl.getSymbol();
+
+                    if (valSymbol && !valSymbol.isResolved) {
+                        valSymbol.type = declType;
+                        valSymbol.setResolved();
+                    }
+                }
+            } else {
+                if (declSymbol.inResolution) {
+                    declSymbol.type = this.semanticInfoChain.anyTypeSymbol;
+                    declSymbol.setResolved();
+                    return declSymbol;
+                }
+
+                if (!declSymbol.type || !declSymbol.type.isError()) {
+                    declSymbol.startResolving();
+
+                    var typeExprSymbol = this.resolveAndTypeCheckVariableDeclarationTypeExpr(varDeclOrParameter, name, typeExpr, context);
+
+                    if (!hasTypeExpr) {
+                        this.resolveAndTypeCheckVariableDeclaratorOrParameterInitExpr(varDeclOrParameter, name, typeExpr, init, context, typeExprSymbol);
+                    }
+
+                    if (!(hasTypeExpr || init)) {
+                        var defaultType = this.semanticInfoChain.anyTypeSymbol;
+
+                        if (declSymbol.isVarArg && this.cachedArrayInterfaceType()) {
+                            defaultType = this.createInstantiatedType(this.cachedArrayInterfaceType(), [defaultType]);
+                        }
+
+                        context.setTypeInContext(declSymbol, defaultType);
+
+                        if (declParameterSymbol) {
+                            declParameterSymbol.type = defaultType;
+                        }
+                    }
+                    declSymbol.setResolved();
+
+                    if (declParameterSymbol) {
+                        declParameterSymbol.setResolved();
+                    }
+                }
+            }
+
+            if (this.canTypeCheckAST(varDeclOrParameter, context)) {
+                this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDeclOrParameter, modifiers, name, typeExpr, init, context);
+            }
+
+            return declSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveAndTypeCheckVariableDeclarationTypeExpr = function (varDeclOrParameter, name, typeExpr, context) {
+            var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter);
+            var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter);
+            var declSymbol = decl.getSymbol();
+            var declParameterSymbol = decl.getValueDecl() ? decl.getValueDecl().getSymbol() : null;
+
+            if (varDeclOrParameter.kind() === 243 /* EnumElement */) {
+                var result = this.getEnumTypeSymbol(varDeclOrParameter, context);
+                declSymbol.type = result;
+                return result;
+            }
+
+            if (!typeExpr) {
+                return null;
+            }
+
+            var wrapperDecl = this.getEnclosingDecl(decl);
+            wrapperDecl = wrapperDecl || enclosingDecl;
+
+            var typeExprSymbol = this.resolveTypeReference(typeExpr, context);
+
+            if (!typeExprSymbol) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Unable_to_resolve_type_of_0, [name.text()]));
+                declSymbol.type = this.getNewErrorTypeSymbol();
+
+                if (declParameterSymbol) {
+                    context.setTypeInContext(declParameterSymbol, this.semanticInfoChain.anyTypeSymbol);
+                }
+            } else if (typeExprSymbol.isError()) {
+                context.setTypeInContext(declSymbol, typeExprSymbol);
+                if (declParameterSymbol) {
+                    context.setTypeInContext(declParameterSymbol, typeExprSymbol);
+                }
+            } else {
+                if (typeExprSymbol === this.semanticInfoChain.anyTypeSymbol) {
+                    decl.setFlag(16777216 /* IsAnnotatedWithAny */);
+                }
+
+                if (typeExprSymbol.isContainer()) {
+                    var exportedTypeSymbol = typeExprSymbol.getExportAssignedTypeSymbol();
+
+                    if (exportedTypeSymbol) {
+                        typeExprSymbol = exportedTypeSymbol;
+                    } else {
+                        typeExprSymbol = typeExprSymbol.type;
+
+                        if (typeExprSymbol.isAlias()) {
+                            typeExprSymbol = typeExprSymbol.getExportAssignedTypeSymbol();
+                        }
+
+                        if (typeExprSymbol && typeExprSymbol.isContainer() && !typeExprSymbol.isEnum()) {
+                            var instanceSymbol = typeExprSymbol.getInstanceSymbol();
+
+                            if (!instanceSymbol || !TypeScript.PullHelpers.symbolIsEnum(instanceSymbol)) {
+                                typeExprSymbol = this.getNewErrorTypeSymbol();
+                            } else {
+                                typeExprSymbol = instanceSymbol.type;
+                            }
+                        }
+                    }
+                } else if (declSymbol.isVarArg && !(typeExprSymbol.isArrayNamedTypeReference() || typeExprSymbol === this.cachedArrayInterfaceType())) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Rest_parameters_must_be_array_types));
+                    typeExprSymbol = this.getNewErrorTypeSymbol();
+                }
+
+                context.setTypeInContext(declSymbol, typeExprSymbol);
+
+                if (declParameterSymbol) {
+                    declParameterSymbol.type = typeExprSymbol;
+                }
+
+                if (typeExprSymbol.kind === 16777216 /* FunctionType */ && !typeExprSymbol.getFunctionSymbol()) {
+                    typeExprSymbol.setFunctionSymbol(declSymbol);
+                }
+            }
+
+            return typeExprSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveAndTypeCheckVariableDeclaratorOrParameterInitExpr = function (varDeclOrParameter, name, typeExpr, init, context, typeExprSymbol) {
+            if (!init) {
+                return null;
+            }
+
+            var hasTypeExpr = typeExpr !== null || varDeclOrParameter.kind() === 243 /* EnumElement */;
+            if (typeExprSymbol) {
+                context.pushNewContextualType(typeExprSymbol);
+            }
+
+            var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter);
+            var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter);
+            var declSymbol = decl.getSymbol();
+            var declParameterSymbol = decl.getValueDecl() ? decl.getValueDecl().getSymbol() : null;
+
+            var wrapperDecl = this.getEnclosingDecl(decl);
+            wrapperDecl = wrapperDecl || enclosingDecl;
+
+            var initExprSymbol = this.resolveAST(init, typeExprSymbol !== null, context);
+
+            if (typeExprSymbol) {
+                context.popAnyContextualType();
+            }
+
+            if (!initExprSymbol) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Unable_to_resolve_type_of_0, [name.text()]));
+
+                if (!hasTypeExpr) {
+                    context.setTypeInContext(declSymbol, this.getNewErrorTypeSymbol());
+
+                    if (declParameterSymbol) {
+                        context.setTypeInContext(declParameterSymbol, this.semanticInfoChain.anyTypeSymbol);
+                    }
+                }
+            } else {
+                var initTypeSymbol = initExprSymbol.type;
+
+                if (!hasTypeExpr) {
+                    var widenedInitTypeSymbol = initTypeSymbol.widenedType(this, init.value, context);
+                    context.setTypeInContext(declSymbol, widenedInitTypeSymbol);
+
+                    if (declParameterSymbol) {
+                        context.setTypeInContext(declParameterSymbol, widenedInitTypeSymbol);
+                    }
+
+                    if (this.compilationSettings.noImplicitAny()) {
+                        if ((widenedInitTypeSymbol !== initTypeSymbol) && (widenedInitTypeSymbol === this.semanticInfoChain.anyTypeSymbol)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Variable_0_implicitly_has_an_any_type, [name.text()]));
+                        }
+                    }
+
+                    return widenedInitTypeSymbol;
+                }
+            }
+
+            return initTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckPropertySignature = function (varDecl, context) {
+            this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.sentinelEmptyArray, varDecl.propertyName, TypeScript.ASTHelpers.getType(varDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckMemberVariableDeclaration = function (varDecl, context) {
+            this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDecl, varDecl.modifiers, varDecl.variableDeclarator.propertyName, TypeScript.ASTHelpers.getType(varDecl), varDecl.variableDeclarator.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckVariableDeclarator = function (varDecl, context) {
+            this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.ASTHelpers.getVariableDeclaratorModifiers(varDecl), varDecl.propertyName, TypeScript.ASTHelpers.getType(varDecl), varDecl.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckParameter = function (parameter, context) {
+            this.typeCheckVariableDeclaratorOrParameterOrEnumElement(parameter, parameter.modifiers, parameter.identifier, TypeScript.ASTHelpers.getType(parameter), parameter.equalsValueClause, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckVariableDeclaratorOrParameterOrEnumElement = function (varDeclOrParameter, modifiers, name, typeExpr, init, context) {
+            var _this = this;
+            this.setTypeChecked(varDeclOrParameter, context);
+
+            var hasTypeExpr = typeExpr !== null || varDeclOrParameter.kind() === 243 /* EnumElement */;
+            var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter);
+            var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter);
+            var declSymbol = decl.getSymbol();
+
+            var typeExprSymbol = this.resolveAndTypeCheckVariableDeclarationTypeExpr(varDeclOrParameter, name, typeExpr, context);
+
+            var initTypeSymbol = this.resolveAndTypeCheckVariableDeclaratorOrParameterInitExpr(varDeclOrParameter, name, typeExpr, init, context, typeExprSymbol);
+
+            if (hasTypeExpr || init) {
+                if (typeExprSymbol && typeExprSymbol.isAlias()) {
+                    typeExprSymbol = typeExprSymbol.getExportAssignedTypeSymbol();
+                }
+
+                if (typeExprSymbol && typeExprSymbol.kind === 32 /* DynamicModule */) {
+                    var exportedTypeSymbol = typeExprSymbol.getExportAssignedTypeSymbol();
+
+                    if (exportedTypeSymbol) {
+                        typeExprSymbol = exportedTypeSymbol;
+                    } else {
+                        var instanceTypeSymbol = typeExprSymbol.getInstanceType();
+
+                        if (!instanceTypeSymbol) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Tried_to_set_variable_type_to_uninitialized_module_type_0, [typeExprSymbol.toString()]));
+                            typeExprSymbol = null;
+                        } else {
+                            typeExprSymbol = instanceTypeSymbol;
+                        }
+                    }
+                }
+
+                initTypeSymbol = this.getInstanceTypeForAssignment(varDeclOrParameter, initTypeSymbol, context);
+
+                if (initTypeSymbol && typeExprSymbol) {
+                    var comparisonInfo = new TypeComparisonInfo();
+
+                    var isAssignable = this.sourceIsAssignableToTarget(initTypeSymbol, typeExprSymbol, varDeclOrParameter, context, comparisonInfo);
+
+                    if (!isAssignable) {
+                        var enclosingSymbol = this.getEnclosingSymbolForAST(varDeclOrParameter);
+                        if (comparisonInfo.message) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [initTypeSymbol.toString(enclosingSymbol), typeExprSymbol.toString(enclosingSymbol), comparisonInfo.message]));
+                        } else {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [initTypeSymbol.toString(enclosingSymbol), typeExprSymbol.toString(enclosingSymbol)]));
+                        }
+                    }
+                }
+            } else if (varDeclOrParameter.kind() !== 243 /* EnumElement */ && this.compilationSettings.noImplicitAny() && !this.isForInVariableDeclarator(varDeclOrParameter)) {
+                var wrapperDecl = this.getEnclosingDecl(decl);
+                wrapperDecl = wrapperDecl || enclosingDecl;
+
+                var needReportError = function (containerDecl, selfDecl) {
+                    if (!TypeScript.hasFlag(containerDecl.flags, 8 /* Ambient */)) {
+                        return true;
+                    }
+
+                    return selfDecl && !TypeScript.hasFlag(selfDecl.flags, 2 /* Private */);
+                };
+
+                if ((wrapperDecl.kind === 16384 /* Function */ || wrapperDecl.kind === 32768 /* ConstructorMethod */ || wrapperDecl.kind === 2097152 /* ConstructSignature */)) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Parameter_0_of_1_implicitly_has_an_any_type, [name.text(), enclosingDecl.name]));
+                } else if (wrapperDecl.kind === 65536 /* Method */) {
+                    var parentDecl = wrapperDecl.getParentDecl();
+
+                    if (needReportError(parentDecl, wrapperDecl)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Parameter_0_of_1_implicitly_has_an_any_type, [name.text(), enclosingDecl.name]));
+                    }
+                } else if (decl.kind === 4096 /* Property */ && !declSymbol.getContainer().isNamedTypeSymbol()) {
+                    if (needReportError(wrapperDecl, decl)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Member_0_of_object_type_implicitly_has_an_any_type, [name.text()]));
+                    }
+                } else if (wrapperDecl.kind !== 268435456 /* CatchBlock */) {
+                    if (needReportError(wrapperDecl) || !TypeScript.hasModifier(modifiers, 2 /* Private */)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Variable_0_implicitly_has_an_any_type, [name.text()]));
+                    }
+                }
+            }
+
+            if (init && varDeclOrParameter.kind() === 242 /* Parameter */) {
+                var containerSignature = enclosingDecl.getSignatureSymbol();
+                if (containerSignature && !containerSignature.isDefinition()) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Default_arguments_are_only_allowed_in_implementation));
+                }
+            }
+            if (declSymbol.kind !== 2048 /* Parameter */ && (declSymbol.kind !== 4096 /* Property */ || declSymbol.getContainer().isNamedTypeSymbol())) {
+                this.checkSymbolPrivacy(declSymbol, declSymbol.type, function (symbol) {
+                    return _this.variablePrivacyErrorReporter(varDeclOrParameter, declSymbol, symbol, context);
+                });
+            }
+
+            if ((declSymbol.kind !== 4096 /* Property */ && declSymbol.kind !== 67108864 /* EnumMember */) || declSymbol.anyDeclHasFlag(8388608 /* PropertyParameter */)) {
+                this.checkNameForCompilerGeneratedDeclarationCollision(varDeclOrParameter, true, name, context);
+            }
+        };
+
+        PullTypeResolver.prototype.isForInVariableDeclarator = function (ast) {
+            return ast.kind() === 225 /* VariableDeclarator */ && ast.parent && ast.parent.parent && ast.parent.parent.parent && ast.parent.kind() === 2 /* SeparatedList */ && ast.parent.parent.kind() === 224 /* VariableDeclaration */ && ast.parent.parent.parent.kind() === 155 /* ForInStatement */ && ast.parent.parent.parent.variableDeclaration === ast.parent.parent;
+        };
+
+        PullTypeResolver.prototype.checkSuperCaptureVariableCollides = function (superAST, isDeclaration, context) {
+            var enclosingDecl = this.getEnclosingDeclForAST(superAST);
+
+            var classSymbol = this.getContextualClassSymbolForEnclosingDecl(superAST, enclosingDecl);
+
+            if (classSymbol && !classSymbol.anyDeclHasFlag(8 /* Ambient */)) {
+                if (superAST.kind() === 242 /* Parameter */) {
+                    var enclosingAST = this.getASTForDecl(enclosingDecl);
+                    if (enclosingAST.kind() !== 218 /* ParenthesizedArrowFunctionExpression */ && enclosingAST.kind() !== 219 /* SimpleArrowFunctionExpression */) {
+                        var block = enclosingDecl.kind === 65536 /* Method */ ? enclosingAST.block : enclosingAST.block;
+                        if (!block) {
+                            return;
+                        }
+                    }
+                }
+
+                this.resolveDeclaredSymbol(classSymbol, context);
+
+                var parents = classSymbol.getExtendedTypes();
+                if (parents.length) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(superAST, isDeclaration ? TypeScript.DiagnosticCode.Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference : TypeScript.DiagnosticCode.Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.checkThisCaptureVariableCollides = function (_thisAST, isDeclaration, context) {
+            if (isDeclaration) {
+                var decl = this.semanticInfoChain.getDeclForAST(_thisAST);
+                if (TypeScript.hasFlag(decl.flags, 8 /* Ambient */)) {
+                    return;
+                }
+            }
+
+            var enclosingDecl = this.getEnclosingDeclForAST(_thisAST);
+
+            var enclosingModule = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(_thisAST);
+            if (TypeScript.ASTHelpers.isAnyNameOfModule(enclosingModule, _thisAST)) {
+                enclosingDecl = this.getEnclosingDeclForAST(enclosingModule);
+            }
+
+            var declPath = enclosingDecl.getParentPath();
+
+            for (var i = declPath.length - 1; i >= 0; i--) {
+                var decl = declPath[i];
+                var declKind = decl.kind;
+                if (declKind === 131072 /* FunctionExpression */ && TypeScript.hasFlag(decl.flags, 8192 /* ArrowFunction */)) {
+                    continue;
+                }
+
+                if (declKind === 16384 /* Function */ || declKind === 65536 /* Method */ || declKind === 32768 /* ConstructorMethod */ || declKind === 262144 /* GetAccessor */ || declKind === 524288 /* SetAccessor */ || declKind === 131072 /* FunctionExpression */ || declKind === 8 /* Class */ || declKind === 4 /* Container */ || declKind === 32 /* DynamicModule */ || declKind === 1 /* Script */) {
+                    if (TypeScript.hasFlag(decl.flags, 262144 /* MustCaptureThis */)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(_thisAST, isDeclaration ? TypeScript.DiagnosticCode.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference : TypeScript.DiagnosticCode.Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference));
+                    }
+                    break;
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.postTypeCheckVariableDeclaratorOrParameter = function (varDeclOrParameter, context) {
+            this.checkThisCaptureVariableCollides(varDeclOrParameter, true, context);
+        };
+
+        PullTypeResolver.prototype.resolveTypeParameterDeclaration = function (typeParameterAST, context) {
+            var typeParameterDecl = this.semanticInfoChain.getDeclForAST(typeParameterAST);
+            var typeParameterSymbol = typeParameterDecl.getSymbol();
+
+            this.resolveFirstTypeParameterDeclaration(typeParameterSymbol, context);
+
+            if (typeParameterSymbol.isResolved && this.canTypeCheckAST(typeParameterAST, context)) {
+                this.typeCheckTypeParameterDeclaration(typeParameterAST, context);
+            }
+
+            return typeParameterSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveFirstTypeParameterDeclaration = function (typeParameterSymbol, context) {
+            var typeParameterDecl = typeParameterSymbol.getDeclarations()[0];
+            var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameterDecl);
+
+            if (typeParameterSymbol.isResolved || typeParameterSymbol.inResolution) {
+                return;
+            }
+
+            typeParameterSymbol.startResolving();
+
+            if (typeParameterAST.constraint) {
+                var constraintTypeSymbol = this.resolveTypeReference(typeParameterAST.constraint.type, context);
+
+                if (constraintTypeSymbol) {
+                    typeParameterSymbol.setConstraint(constraintTypeSymbol);
+                }
+            }
+
+            typeParameterSymbol.setResolved();
+        };
+
+        PullTypeResolver.prototype.typeCheckTypeParameterDeclaration = function (typeParameterAST, context) {
+            this.setTypeChecked(typeParameterAST, context);
+
+            var constraint = this.resolveAST(typeParameterAST.constraint, false, context);
+
+            if (constraint) {
+                var typeParametersAST = typeParameterAST.parent;
+                var typeParameters = [];
+                for (var i = 0; i < typeParametersAST.nonSeparatorCount(); i++) {
+                    var currentTypeParameterAST = typeParametersAST.nonSeparatorAt(i);
+                    var currentTypeParameterDecl = this.semanticInfoChain.getDeclForAST(currentTypeParameterAST);
+                    var currentTypeParameter = this.semanticInfoChain.getSymbolForDecl(currentTypeParameterDecl);
+                    typeParameters[currentTypeParameter.pullSymbolID] = currentTypeParameter;
+                }
+
+                if (constraint.wrapsSomeTypeParameter(typeParameters)) {
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Constraint_of_a_type_parameter_cannot_reference_any_type_parameter_from_the_same_type_parameter_list);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveConstraint = function (constraint, context) {
+            if (this.canTypeCheckAST(constraint, context)) {
+                this.setTypeChecked(constraint, context);
+            }
+
+            return this.resolveTypeReference(constraint.type, context);
+        };
+
+        PullTypeResolver.prototype.resolveFunctionBodyReturnTypes = function (funcDeclAST, block, bodyExpression, signature, useContextualType, enclosingDecl, context) {
+            var _this = this;
+            var returnStatementsExpressions = [];
+
+            var enclosingDeclStack = [enclosingDecl];
+
+            var preFindReturnExpressionTypes = function (ast, walker) {
+                var go = true;
+
+                switch (ast.kind()) {
+                    case 129 /* FunctionDeclaration */:
+                    case 219 /* SimpleArrowFunctionExpression */:
+                    case 218 /* ParenthesizedArrowFunctionExpression */:
+                    case 222 /* FunctionExpression */:
+                    case 215 /* ObjectLiteralExpression */:
+                        go = false;
+                        break;
+
+                    case 150 /* ReturnStatement */:
+                        var returnStatement = ast;
+                        enclosingDecl.setFlag(4194304 /* HasReturnStatement */);
+                        returnStatementsExpressions.push({ expression: returnStatement.expression, enclosingDecl: enclosingDeclStack[enclosingDeclStack.length - 1] });
+                        go = false;
+                        break;
+
+                    case 236 /* CatchClause */:
+                    case 163 /* WithStatement */:
+                        enclosingDeclStack[enclosingDeclStack.length] = _this.semanticInfoChain.getDeclForAST(ast);
+                        break;
+
+                    default:
+                        break;
+                }
+
+                walker.options.goChildren = go;
+
+                return ast;
+            };
+
+            var postFindReturnExpressionEnclosingDecls = function (ast, walker) {
+                switch (ast.kind()) {
+                    case 236 /* CatchClause */:
+                    case 163 /* WithStatement */:
+                        enclosingDeclStack.length--;
+                        break;
+                    default:
+                        break;
+                }
+
+                walker.options.goChildren = true;
+
+                return ast;
+            };
+
+            if (block) {
+                TypeScript.getAstWalkerFactory().walk(block, preFindReturnExpressionTypes, postFindReturnExpressionEnclosingDecls);
+            } else {
+                returnStatementsExpressions.push({ expression: bodyExpression, enclosingDecl: enclosingDecl });
+                enclosingDecl.setFlag(4194304 /* HasReturnStatement */);
+            }
+
+            if (!returnStatementsExpressions.length) {
+                signature.returnType = this.semanticInfoChain.voidTypeSymbol;
+            } else {
+                var returnExpressionSymbols = [];
+                var returnExpressions = [];
+
+                for (var i = 0; i < returnStatementsExpressions.length; i++) {
+                    var returnExpression = returnStatementsExpressions[i].expression;
+                    if (returnExpression) {
+                        var returnType = this.resolveAST(returnExpression, useContextualType, context).type;
+
+                        if (returnType.isError()) {
+                            signature.returnType = returnType;
+                            return;
+                        } else {
+                            if (returnExpression.parent.kind() === 150 /* ReturnStatement */) {
+                                this.setSymbolForAST(returnExpression.parent, returnType, context);
+                            }
+                        }
+
+                        returnExpressionSymbols.push(returnType);
+                        returnExpressions.push(returnExpression);
+                    }
+                }
+
+                if (!returnExpressionSymbols.length) {
+                    signature.returnType = this.semanticInfoChain.voidTypeSymbol;
+                } else {
+                    var collection = {
+                        getLength: function () {
+                            return returnExpressionSymbols.length;
+                        },
+                        getTypeAtIndex: function (index) {
+                            return returnExpressionSymbols[index].type;
+                        }
+                    };
+
+                    var bestCommonReturnType = this.findBestCommonType(collection, context, new TypeComparisonInfo());
+                    var returnType = bestCommonReturnType;
+                    var returnExpression = returnExpressions[returnExpressionSymbols.indexOf(returnType)];
+
+                    var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+                    var functionSymbol = functionDecl.getSymbol();
+
+                    if (returnType) {
+                        var previousReturnType = returnType;
+                        var newReturnType = returnType.widenedType(this, returnExpression, context);
+                        signature.returnType = newReturnType;
+
+                        if (!TypeScript.ArrayUtilities.contains(returnExpressionSymbols, bestCommonReturnType)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Could_not_find_the_best_common_type_of_types_of_all_return_statement_expressions));
+                        }
+
+                        if (this.compilationSettings.noImplicitAny()) {
+                            if (previousReturnType !== newReturnType && newReturnType === this.semanticInfoChain.anyTypeSymbol) {
+                                var functionName = enclosingDecl.name;
+                                if (functionName === "") {
+                                    functionName = enclosingDecl.getFunctionExpressionName();
+                                }
+
+                                if (functionName != "") {
+                                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type, [functionName]));
+                                } else {
+                                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_any_return_type));
+                                }
+                            }
+                        }
+                    }
+
+                    if (!functionSymbol.type && functionSymbol.isAccessor()) {
+                        functionSymbol.type = signature.returnType;
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckConstructorDeclaration = function (funcDeclAST, context) {
+            var _this = this;
+            this.setTypeChecked(funcDeclAST, context);
+
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            for (var i = 0; i < funcDeclAST.callSignature.parameterList.parameters.nonSeparatorCount(); i++) {
+                this.resolveAST(funcDeclAST.callSignature.parameterList.parameters.nonSeparatorAt(i), false, context);
+            }
+
+            this.resolveAST(funcDeclAST.block, false, context);
+
+            if (funcDecl.getSignatureSymbol() && funcDecl.getSignatureSymbol().isDefinition() && this.enclosingClassIsDerived(funcDecl.getParentDecl())) {
+                if (!this.constructorHasSuperCall(funcDeclAST)) {
+                    context.postDiagnostic(new TypeScript.Diagnostic(funcDeclAST.fileName(), this.semanticInfoChain.lineMap(funcDeclAST.fileName()), funcDeclAST.start(), "constructor".length, TypeScript.DiagnosticCode.Constructors_for_derived_classes_must_contain_a_super_call));
+                } else if (this.superCallMustBeFirstStatementInConstructor(funcDecl)) {
+                    var firstStatement = this.getFirstStatementOfBlockOrNull(funcDeclAST.block);
+                    if (!firstStatement || !this.isSuperInvocationExpressionStatement(firstStatement)) {
+                        context.postDiagnostic(new TypeScript.Diagnostic(funcDeclAST.fileName(), this.semanticInfoChain.lineMap(funcDeclAST.fileName()), funcDeclAST.start(), "constructor".length, TypeScript.DiagnosticCode.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties));
+                    }
+                }
+            }
+
+            this.validateVariableDeclarationGroups(funcDecl, context);
+
+            this.checkFunctionTypePrivacy(funcDeclAST, false, null, TypeScript.ASTHelpers.parametersFromParameterList(funcDeclAST.callSignature.parameterList), null, funcDeclAST.block, context);
+
+            this.typeCheckCallBacks.push(function (context) {
+                _this.typeCheckFunctionOverloads(funcDeclAST, context);
+            });
+        };
+
+        PullTypeResolver.prototype.constructorHasSuperCall = function (constructorDecl) {
+            var _this = this;
+            if (constructorDecl.block) {
+                var foundSuperCall = false;
+                var pre = function (ast, walker) {
+                    switch (ast.kind()) {
+                        case 129 /* FunctionDeclaration */:
+                        case 219 /* SimpleArrowFunctionExpression */:
+                        case 218 /* ParenthesizedArrowFunctionExpression */:
+                        case 222 /* FunctionExpression */:
+                        case 215 /* ObjectLiteralExpression */:
+                            walker.options.goChildren = false;
+                        default:
+                            if (_this.isSuperInvocationExpression(ast)) {
+                                foundSuperCall = true;
+                                walker.options.stopWalking = true;
+                            }
+                    }
+                };
+
+                TypeScript.getAstWalkerFactory().walk(constructorDecl.block, pre);
+                return foundSuperCall;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.typeCheckFunctionExpression = function (funcDecl, isContextuallyTyped, context) {
+            this.typeCheckAnyFunctionExpression(funcDecl, funcDecl.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList), funcDecl.callSignature.typeAnnotation, funcDecl.block, null, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckCallSignature = function (funcDecl, context) {
+            this.typeCheckAnyFunctionDeclaration(funcDecl, false, null, funcDecl.typeParameterList, funcDecl.parameterList, TypeScript.ASTHelpers.getType(funcDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckConstructSignature = function (funcDecl, context) {
+            this.typeCheckAnyFunctionDeclaration(funcDecl, false, null, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckMethodSignature = function (funcDecl, context) {
+            this.typeCheckAnyFunctionDeclaration(funcDecl, false, funcDecl.propertyName, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckMemberFunctionDeclaration = function (funcDecl, context) {
+            this.typeCheckAnyFunctionDeclaration(funcDecl, TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */), funcDecl.propertyName, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), funcDecl.block, context);
+        };
+
+        PullTypeResolver.prototype.containsSingleThrowStatement = function (block) {
+            return block !== null && block.statements.childCount() === 1 && block.statements.childAt(0).kind() === 157 /* ThrowStatement */;
+        };
+
+        PullTypeResolver.prototype.typeCheckAnyFunctionDeclaration = function (funcDeclAST, isStatic, name, typeParameters, parameters, returnTypeAnnotation, block, context) {
+            var _this = this;
+            this.setTypeChecked(funcDeclAST, context);
+
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            if (typeParameters) {
+                for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) {
+                    this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context);
+                }
+            }
+
+            this.resolveAST(parameters, false, context);
+
+            this.resolveAST(block, false, context);
+            var enclosingDecl = this.getEnclosingDecl(funcDecl);
+
+            this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, returnTypeAnnotation, context);
+            this.validateVariableDeclarationGroups(funcDecl, context);
+
+            this.checkFunctionTypePrivacy(funcDeclAST, isStatic, typeParameters, TypeScript.ASTHelpers.parametersFromParameterList(parameters), returnTypeAnnotation, block, context);
+
+            this.checkThatNonVoidFunctionHasReturnExpressionOrThrowStatement(funcDecl, returnTypeAnnotation, funcDecl.getSignatureSymbol().returnType, block, context);
+
+            if (funcDecl.kind === 16384 /* Function */) {
+                this.checkNameForCompilerGeneratedDeclarationCollision(funcDeclAST, true, name, context);
+            }
+
+            this.typeCheckCallBacks.push(function (context) {
+                _this.typeCheckFunctionOverloads(funcDeclAST, context);
+            });
+        };
+
+        PullTypeResolver.prototype.checkThatNonVoidFunctionHasReturnExpressionOrThrowStatement = function (functionDecl, returnTypeAnnotation, returnTypeSymbol, block, context) {
+            var hasReturn = TypeScript.hasFlag(functionDecl.flags, 4194304 /* HasReturnStatement */);
+
+            if (block !== null && returnTypeAnnotation !== null && !hasReturn) {
+                var isVoidOrAny = this.isAnyOrEquivalent(returnTypeSymbol) || returnTypeSymbol === this.semanticInfoChain.voidTypeSymbol;
+
+                if (!isVoidOrAny && !this.containsSingleThrowStatement(block)) {
+                    var funcName = functionDecl.getDisplayName() || TypeScript.getLocalizedText(TypeScript.DiagnosticCode.expression, null);
+
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, TypeScript.DiagnosticCode.Function_declared_a_non_void_return_type_but_has_no_return_expression));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckIndexSignature = function (funcDeclAST, context) {
+            var _this = this;
+            this.setTypeChecked(funcDeclAST, context);
+
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            this.resolveAST(funcDeclAST.parameter, false, context);
+
+            var enclosingDecl = this.getEnclosingDecl(funcDecl);
+
+            this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, TypeScript.ASTHelpers.getType(funcDeclAST), context);
+            this.validateVariableDeclarationGroups(funcDecl, context);
+
+            this.checkFunctionTypePrivacy(funcDeclAST, false, null, TypeScript.ASTHelpers.parametersFromParameter(funcDeclAST.parameter), TypeScript.ASTHelpers.getType(funcDeclAST), null, context);
+
+            var signature = funcDecl.getSignatureSymbol();
+
+            this.typeCheckCallBacks.push(function (context) {
+                var parentSymbol = funcDecl.getSignatureSymbol().getContainer();
+                var allIndexSignatures = _this.getBothKindsOfIndexSignaturesExcludingAugmentedType(parentSymbol, context);
+                var stringIndexSignature = allIndexSignatures.stringSignature;
+                var numberIndexSignature = allIndexSignatures.numericSignature;
+                var isNumericIndexer = numberIndexSignature === signature;
+
+                if (numberIndexSignature && stringIndexSignature && (isNumericIndexer || stringIndexSignature.getDeclarations()[0].getParentDecl() !== numberIndexSignature.getDeclarations()[0].getParentDecl())) {
+                    var comparisonInfo = new TypeComparisonInfo();
+
+                    if (!_this.sourceIsAssignableToTarget(numberIndexSignature.returnType, stringIndexSignature.returnType, funcDeclAST, context, comparisonInfo)) {
+                        var enclosingSymbol = _this.getEnclosingSymbolForAST(funcDeclAST);
+                        if (comparisonInfo.message) {
+                            context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Numeric_indexer_type_0_must_be_assignable_to_string_indexer_type_1_NL_2, [numberIndexSignature.returnType.toString(enclosingSymbol), stringIndexSignature.returnType.toString(enclosingSymbol), comparisonInfo.message]));
+                        } else {
+                            context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Numeric_indexer_type_0_must_be_assignable_to_string_indexer_type_1, [numberIndexSignature.returnType.toString(enclosingSymbol), stringIndexSignature.returnType.toString(enclosingSymbol)]));
+                        }
+                    }
+                }
+
+                var allMembers = parentSymbol.type.getAllMembers(536869887 /* All */, 0 /* all */);
+                for (var i = 0; i < allMembers.length; i++) {
+                    var member = allMembers[i];
+                    var name = member.name;
+                    if (name || (member.kind === 4096 /* Property */ && name === "")) {
+                        if (!allMembers[i].isResolved) {
+                            _this.resolveDeclaredSymbol(allMembers[i], context);
+                        }
+
+                        if (parentSymbol !== allMembers[i].getContainer()) {
+                            var isMemberNumeric = TypeScript.PullHelpers.isNameNumeric(name);
+                            var indexerKindMatchesMemberNameKind = isNumericIndexer === isMemberNumeric;
+                            var onlyStringIndexerIsPresent = !numberIndexSignature;
+
+                            if (indexerKindMatchesMemberNameKind || onlyStringIndexerIsPresent) {
+                                var comparisonInfo = new TypeComparisonInfo();
+                                if (!_this.sourceIsAssignableToTarget(allMembers[i].type, signature.returnType, funcDeclAST, context, comparisonInfo, false)) {
+                                    _this.reportErrorThatMemberIsNotSubtypeOfIndexer(allMembers[i], signature, funcDeclAST, context, comparisonInfo);
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+        };
+
+        PullTypeResolver.prototype.postTypeCheckFunctionDeclaration = function (funcDeclAST, context) {
+            this.checkThisCaptureVariableCollides(funcDeclAST, true, context);
+        };
+
+        PullTypeResolver.prototype.resolveReturnTypeAnnotationOfFunctionDeclaration = function (funcDeclAST, returnTypeAnnotation, context) {
+            var returnTypeSymbol = null;
+
+            if (returnTypeAnnotation) {
+                var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+                returnTypeSymbol = this.resolveTypeReference(returnTypeAnnotation, context);
+
+                if (!returnTypeSymbol) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, TypeScript.DiagnosticCode.Cannot_resolve_return_type_reference));
+                } else {
+                    var isConstructor = funcDeclAST.kind() === 137 /* ConstructorDeclaration */ || funcDeclAST.kind() === 143 /* ConstructSignature */;
+                    if (isConstructor && returnTypeSymbol === this.semanticInfoChain.voidTypeSymbol) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Constructors_cannot_have_a_return_type_of_void));
+                    }
+                }
+            }
+
+            return returnTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveMemberFunctionDeclaration = function (funcDecl, context) {
+            return this.resolveFunctionDeclaration(funcDecl, TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */), funcDecl.propertyName, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), funcDecl.block, context);
+        };
+
+        PullTypeResolver.prototype.resolveCallSignature = function (funcDecl, context) {
+            return this.resolveFunctionDeclaration(funcDecl, false, null, funcDecl.typeParameterList, funcDecl.parameterList, TypeScript.ASTHelpers.getType(funcDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.resolveConstructSignature = function (funcDecl, context) {
+            return this.resolveFunctionDeclaration(funcDecl, false, null, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.resolveMethodSignature = function (funcDecl, context) {
+            return this.resolveFunctionDeclaration(funcDecl, false, funcDecl.propertyName, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), null, context);
+        };
+
+        PullTypeResolver.prototype.resolveAnyFunctionDeclaration = function (funcDecl, context) {
+            return this.resolveFunctionDeclaration(funcDecl, TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */), funcDecl.identifier, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), funcDecl.block, context);
+        };
+
+        PullTypeResolver.prototype.resolveFunctionExpression = function (funcDecl, isContextuallyTyped, context) {
+            return this.resolveAnyFunctionExpression(funcDecl, funcDecl.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList), TypeScript.ASTHelpers.getType(funcDecl), funcDecl.block, null, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.resolveSimpleArrowFunctionExpression = function (funcDecl, isContextuallyTyped, context) {
+            return this.resolveAnyFunctionExpression(funcDecl, null, TypeScript.ASTHelpers.parametersFromIdentifier(funcDecl.identifier), null, funcDecl.block, funcDecl.expression, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.resolveParenthesizedArrowFunctionExpression = function (funcDecl, isContextuallyTyped, context) {
+            return this.resolveAnyFunctionExpression(funcDecl, funcDecl.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList), TypeScript.ASTHelpers.getType(funcDecl), funcDecl.block, funcDecl.expression, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.getEnclosingClassDeclaration = function (ast) {
+            while (ast) {
+                if (ast.kind() === 131 /* ClassDeclaration */) {
+                    return ast;
+                }
+
+                ast = ast.parent;
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.resolveConstructorDeclaration = function (funcDeclAST, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            var funcSymbol = funcDecl.getSymbol();
+
+            var signature = funcDecl.getSignatureSymbol();
+
+            var hadError = false;
+
+            if (signature) {
+                if (signature.isResolved) {
+                    if (this.canTypeCheckAST(funcDeclAST, context)) {
+                        this.typeCheckConstructorDeclaration(funcDeclAST, context);
+                    }
+                    return funcSymbol;
+                }
+
+                if (!signature.inResolution) {
+                    var classAST = this.getEnclosingClassDeclaration(funcDeclAST);
+
+                    if (classAST) {
+                        var classDecl = this.semanticInfoChain.getDeclForAST(classAST);
+                        var classSymbol = classDecl.getSymbol();
+
+                        if (!classSymbol.isResolved && !classSymbol.inResolution) {
+                            this.resolveDeclaredSymbol(classSymbol, context);
+                        }
+                    }
+                }
+
+                var functionTypeSymbol = funcSymbol && funcSymbol.type;
+
+                if (signature.inResolution) {
+                    signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+
+                    if (funcSymbol) {
+                        funcSymbol.setUnresolved();
+                        if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) {
+                            funcSymbol.type = functionTypeSymbol;
+                        }
+                    }
+                    signature.setResolved();
+                    return funcSymbol;
+                }
+
+                if (funcSymbol) {
+                    funcSymbol.startResolving();
+                }
+                signature.startResolving();
+
+                var prevInTypeCheck = context.inTypeCheck;
+
+                context.inTypeCheck = false;
+
+                for (var i = 0; i < funcDeclAST.callSignature.parameterList.parameters.nonSeparatorCount(); i++) {
+                    this.resolveParameter(funcDeclAST.callSignature.parameterList.parameters.nonSeparatorAt(i), context);
+                }
+
+                context.inTypeCheck = prevInTypeCheck;
+
+                if (signature.isGeneric()) {
+                    if (funcSymbol) {
+                        funcSymbol.type.setHasGenericSignature();
+                    }
+                }
+
+                if (!hadError) {
+                    if (funcSymbol) {
+                        funcSymbol.setUnresolved();
+                        if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) {
+                            funcSymbol.type = functionTypeSymbol;
+                        }
+                    }
+                    signature.setResolved();
+                }
+            }
+
+            if (funcSymbol) {
+                this.resolveOtherDeclarations(funcDeclAST, context);
+            }
+
+            if (this.canTypeCheckAST(funcDeclAST, context)) {
+                this.typeCheckConstructorDeclaration(funcDeclAST, context);
+            }
+
+            return funcSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveIndexMemberDeclaration = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+            }
+
+            return this.resolveIndexSignature(ast.indexSignature, context);
+        };
+
+        PullTypeResolver.prototype.resolveIndexSignature = function (funcDeclAST, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            var funcSymbol = funcDecl.getSymbol();
+
+            var signature = funcDecl.getSignatureSymbol();
+
+            var hadError = false;
+
+            if (signature) {
+                if (signature.isResolved) {
+                    if (this.canTypeCheckAST(funcDeclAST, context)) {
+                        this.typeCheckIndexSignature(funcDeclAST, context);
+                    }
+                    return funcSymbol;
+                }
+
+                var functionTypeSymbol = funcSymbol && funcSymbol.type;
+
+                if (signature.inResolution) {
+                    if (funcDeclAST.typeAnnotation) {
+                        var returnTypeSymbol = this.resolveTypeReference(TypeScript.ASTHelpers.getType(funcDeclAST), context);
+                        if (!returnTypeSymbol) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(TypeScript.ASTHelpers.getType(funcDeclAST), TypeScript.DiagnosticCode.Cannot_resolve_return_type_reference));
+                            signature.returnType = this.getNewErrorTypeSymbol();
+                            hadError = true;
+                        } else {
+                            signature.returnType = returnTypeSymbol;
+                        }
+                    } else {
+                        signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+                    }
+
+                    if (funcSymbol) {
+                        funcSymbol.setUnresolved();
+                        if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) {
+                            funcSymbol.type = functionTypeSymbol;
+                        }
+                    }
+                    signature.setResolved();
+                    return funcSymbol;
+                }
+
+                if (funcSymbol) {
+                    funcSymbol.startResolving();
+                }
+                signature.startResolving();
+
+                if (funcDeclAST.parameter) {
+                    var prevInTypeCheck = context.inTypeCheck;
+
+                    context.inTypeCheck = false;
+                    this.resolveParameter(funcDeclAST.parameter, context);
+                    context.inTypeCheck = prevInTypeCheck;
+                }
+
+                if (funcDeclAST.typeAnnotation) {
+                    returnTypeSymbol = this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, TypeScript.ASTHelpers.getType(funcDeclAST), context);
+
+                    if (!returnTypeSymbol) {
+                        signature.returnType = this.getNewErrorTypeSymbol();
+                        hadError = true;
+                    } else {
+                        signature.returnType = returnTypeSymbol;
+                    }
+                } else {
+                    signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+                }
+
+                if (!hadError) {
+                    if (funcSymbol) {
+                        funcSymbol.setUnresolved();
+                        if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) {
+                            funcSymbol.type = functionTypeSymbol;
+                        }
+                    }
+                    signature.setResolved();
+                }
+            }
+
+            if (funcSymbol) {
+                this.resolveOtherDeclarations(funcDeclAST, context);
+            }
+
+            if (this.canTypeCheckAST(funcDeclAST, context)) {
+                this.typeCheckIndexSignature(funcDeclAST, context);
+            }
+
+            return funcSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveFunctionDeclaration = function (funcDeclAST, isStatic, name, typeParameters, parameterList, returnTypeAnnotation, block, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            var funcSymbol = funcDecl.getSymbol();
+
+            var signature = funcDecl.getSignatureSymbol();
+
+            var hadError = false;
+
+            var isConstructor = funcDeclAST.kind() === 143 /* ConstructSignature */;
+
+            if (signature) {
+                if (signature.isResolved) {
+                    if (this.canTypeCheckAST(funcDeclAST, context)) {
+                        this.typeCheckAnyFunctionDeclaration(funcDeclAST, isStatic, name, typeParameters, parameterList, returnTypeAnnotation, block, context);
+                    }
+                    return funcSymbol;
+                }
+
+                if (isConstructor && !signature.inResolution) {
+                    var classAST = this.getEnclosingClassDeclaration(funcDeclAST);
+
+                    if (classAST) {
+                        var classDecl = this.semanticInfoChain.getDeclForAST(classAST);
+                        var classSymbol = classDecl.getSymbol();
+
+                        if (!classSymbol.isResolved && !classSymbol.inResolution) {
+                            this.resolveDeclaredSymbol(classSymbol, context);
+                        }
+                    }
+                }
+
+                var functionTypeSymbol = funcSymbol && funcSymbol.type;
+
+                if (signature.inResolution) {
+                    if (returnTypeAnnotation) {
+                        var returnTypeSymbol = this.resolveTypeReference(returnTypeAnnotation, context);
+                        if (!returnTypeSymbol) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, TypeScript.DiagnosticCode.Cannot_resolve_return_type_reference));
+                            signature.returnType = this.getNewErrorTypeSymbol();
+                            hadError = true;
+                        } else {
+                            signature.returnType = returnTypeSymbol;
+
+                            if (isConstructor && returnTypeSymbol === this.semanticInfoChain.voidTypeSymbol) {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Constructors_cannot_have_a_return_type_of_void));
+                            }
+                        }
+                    } else {
+                        signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+                    }
+
+                    if (funcSymbol) {
+                        funcSymbol.setUnresolved();
+                        if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) {
+                            funcSymbol.type = functionTypeSymbol;
+                        }
+                    }
+                    signature.setResolved();
+                    return funcSymbol;
+                }
+
+                if (funcSymbol) {
+                    funcSymbol.startResolving();
+                }
+                signature.startResolving();
+
+                if (typeParameters) {
+                    for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) {
+                        this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context);
+                    }
+                }
+
+                if (parameterList) {
+                    var prevInTypeCheck = context.inTypeCheck;
+
+                    context.inTypeCheck = false;
+
+                    for (var i = 0; i < parameterList.parameters.nonSeparatorCount(); i++) {
+                        this.resolveParameter(parameterList.parameters.nonSeparatorAt(i), context);
+                    }
+
+                    context.inTypeCheck = prevInTypeCheck;
+                }
+
+                if (returnTypeAnnotation) {
+                    returnTypeSymbol = this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, returnTypeAnnotation, context);
+
+                    if (!returnTypeSymbol) {
+                        signature.returnType = this.getNewErrorTypeSymbol();
+                        hadError = true;
+                    } else {
+                        signature.returnType = returnTypeSymbol;
+                    }
+                } else if (funcDecl.kind !== 2097152 /* ConstructSignature */) {
+                    if (TypeScript.hasFlag(funcDecl.flags, 2048 /* Signature */)) {
+                        signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+                        var parentDeclFlags = 0 /* None */;
+                        if (TypeScript.hasFlag(funcDecl.kind, 65536 /* Method */) || TypeScript.hasFlag(funcDecl.kind, 32768 /* ConstructorMethod */)) {
+                            var parentDecl = funcDecl.getParentDecl();
+                            parentDeclFlags = parentDecl.flags;
+                        }
+
+                        if (this.compilationSettings.noImplicitAny() && (!TypeScript.hasFlag(parentDeclFlags, 8 /* Ambient */) || (TypeScript.hasFlag(parentDeclFlags, 8 /* Ambient */) && !TypeScript.hasFlag(funcDecl.flags, 2 /* Private */)))) {
+                            var funcDeclASTName = name;
+                            if (funcDeclASTName) {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type, [funcDeclASTName.text()]));
+                            } else {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Lambda_Function_which_lacks_return_type_annotation_implicitly_has_an_any_return_type));
+                            }
+                        }
+                    } else {
+                        this.resolveFunctionBodyReturnTypes(funcDeclAST, block, null, signature, false, funcDecl, context);
+                    }
+                } else if (funcDecl.kind === 2097152 /* ConstructSignature */) {
+                    signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+
+                    if (this.compilationSettings.noImplicitAny()) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Constructor_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type));
+                    }
+                }
+
+                if (!hadError) {
+                    if (funcSymbol) {
+                        funcSymbol.setUnresolved();
+                        if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) {
+                            funcSymbol.type = functionTypeSymbol;
+                        }
+                    }
+                    signature.setResolved();
+                }
+            }
+
+            if (funcSymbol) {
+                this.resolveOtherDeclarations(funcDeclAST, context);
+            }
+
+            if (this.canTypeCheckAST(funcDeclAST, context)) {
+                this.typeCheckAnyFunctionDeclaration(funcDeclAST, isStatic, name, typeParameters, parameterList, returnTypeAnnotation, block, context);
+            }
+
+            return funcSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveGetterReturnTypeAnnotation = function (getterFunctionDeclarationAst, enclosingDecl, context) {
+            if (getterFunctionDeclarationAst && getterFunctionDeclarationAst.typeAnnotation) {
+                return this.resolveTypeReference(TypeScript.ASTHelpers.getType(getterFunctionDeclarationAst), context);
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.resolveSetterArgumentTypeAnnotation = function (setterFunctionDeclarationAst, enclosingDecl, context) {
+            if (setterFunctionDeclarationAst && setterFunctionDeclarationAst.parameterList && setterFunctionDeclarationAst.parameterList.parameters.nonSeparatorCount() > 0) {
+                var parameter = setterFunctionDeclarationAst.parameterList.parameters.nonSeparatorAt(0);
+                return this.resolveTypeReference(TypeScript.ASTHelpers.getType(parameter), context);
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.resolveAccessorDeclaration = function (funcDeclAst, context) {
+            var functionDeclaration = this.semanticInfoChain.getDeclForAST(funcDeclAst);
+            var accessorSymbol = functionDeclaration.getSymbol();
+
+            if (accessorSymbol.inResolution) {
+                accessorSymbol.type = this.semanticInfoChain.anyTypeSymbol;
+                accessorSymbol.setResolved();
+
+                return accessorSymbol;
+            }
+
+            if (accessorSymbol.isResolved) {
+                if (!accessorSymbol.type) {
+                    accessorSymbol.type = this.semanticInfoChain.anyTypeSymbol;
+                }
+            } else {
+                var getterSymbol = accessorSymbol.getGetter();
+                var getterFunctionDeclarationAst = getterSymbol ? getterSymbol.getDeclarations()[0].ast() : null;
+                var hasGetter = getterSymbol !== null;
+
+                var setterSymbol = accessorSymbol.getSetter();
+                var setterFunctionDeclarationAst = setterSymbol ? setterSymbol.getDeclarations()[0].ast() : null;
+                var hasSetter = setterSymbol !== null;
+
+                var getterAnnotatedType = this.resolveGetterReturnTypeAnnotation(getterFunctionDeclarationAst, functionDeclaration, context);
+                var getterHasTypeAnnotation = getterAnnotatedType !== null;
+
+                var setterAnnotatedType = this.resolveSetterArgumentTypeAnnotation(setterFunctionDeclarationAst, functionDeclaration, context);
+                var setterHasTypeAnnotation = setterAnnotatedType !== null;
+
+                accessorSymbol.startResolving();
+
+                if (hasGetter) {
+                    getterSymbol = this.resolveGetAccessorDeclaration(getterFunctionDeclarationAst, getterFunctionDeclarationAst.parameterList, TypeScript.ASTHelpers.getType(getterFunctionDeclarationAst), getterFunctionDeclarationAst.block, setterAnnotatedType, context);
+                }
+
+                if (hasSetter) {
+                    setterSymbol = this.resolveSetAccessorDeclaration(setterFunctionDeclarationAst, setterFunctionDeclarationAst.parameterList, context);
+                }
+
+                if (hasGetter && hasSetter) {
+                    var setterSig = setterSymbol.type.getCallSignatures()[0];
+                    var setterParameters = setterSig.parameters;
+                    var setterHasParameters = setterParameters.length > 0;
+                    var getterSig = getterSymbol.type.getCallSignatures()[0];
+
+                    var setterSuppliedTypeSymbol = setterHasParameters ? setterParameters[0].type : null;
+                    var getterSuppliedTypeSymbol = getterSig.returnType;
+
+                    if (setterHasTypeAnnotation && !getterHasTypeAnnotation) {
+                        getterSuppliedTypeSymbol = setterSuppliedTypeSymbol;
+                        getterSig.returnType = setterSuppliedTypeSymbol;
+                    } else if ((getterHasTypeAnnotation && !setterHasTypeAnnotation) || (!getterHasTypeAnnotation && !setterHasTypeAnnotation)) {
+                        setterSuppliedTypeSymbol = getterSuppliedTypeSymbol;
+
+                        if (setterHasParameters) {
+                            setterParameters[0].type = getterSuppliedTypeSymbol;
+                        }
+                    }
+
+                    if (!this.typesAreIdentical(setterSuppliedTypeSymbol, getterSuppliedTypeSymbol, context)) {
+                        accessorSymbol.type = this.getNewErrorTypeSymbol();
+                    } else {
+                        accessorSymbol.type = getterSuppliedTypeSymbol;
+                    }
+                } else if (hasSetter) {
+                    var setterSig = setterSymbol.type.getCallSignatures()[0];
+                    var setterParameters = setterSig.parameters;
+                    var setterHasParameters = setterParameters.length > 0;
+
+                    accessorSymbol.type = setterHasParameters ? setterParameters[0].type : this.semanticInfoChain.anyTypeSymbol;
+                } else {
+                    var getterSig = getterSymbol.type.getCallSignatures()[0];
+                    accessorSymbol.type = getterSig.returnType;
+                }
+
+                accessorSymbol.setResolved();
+            }
+
+            if (this.canTypeCheckAST(funcDeclAst, context)) {
+                this.typeCheckAccessorDeclaration(funcDeclAst, context);
+            }
+
+            return accessorSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckAccessorDeclaration = function (funcDeclAst, context) {
+            this.setTypeChecked(funcDeclAst, context);
+            var functionDeclaration = this.semanticInfoChain.getDeclForAST(funcDeclAst);
+            var accessorSymbol = functionDeclaration.getSymbol();
+            var getterSymbol = accessorSymbol.getGetter();
+            var setterSymbol = accessorSymbol.getSetter();
+
+            var isGetter = funcDeclAst.kind() === 139 /* GetAccessor */;
+            if (isGetter) {
+                var getterFunctionDeclarationAst = funcDeclAst;
+                context.pushNewContextualType(getterSymbol.type);
+                this.typeCheckGetAccessorDeclaration(getterFunctionDeclarationAst, context);
+                context.popAnyContextualType();
+            } else {
+                var setterFunctionDeclarationAst = funcDeclAst;
+                this.typeCheckSetAccessorDeclaration(setterFunctionDeclarationAst, context);
+            }
+        };
+
+        PullTypeResolver.prototype.resolveGetAccessorDeclaration = function (funcDeclAST, parameters, returnTypeAnnotation, block, setterAnnotatedType, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            var accessorSymbol = funcDecl.getSymbol();
+
+            var getterSymbol = accessorSymbol.getGetter();
+            var getterTypeSymbol = getterSymbol.type;
+
+            var signature = getterTypeSymbol.getCallSignatures()[0];
+
+            var hadError = false;
+
+            if (signature) {
+                if (signature.isResolved) {
+                    return getterSymbol;
+                }
+
+                if (signature.inResolution) {
+                    signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+                    signature.setResolved();
+
+                    return getterSymbol;
+                }
+
+                signature.startResolving();
+
+                if (returnTypeAnnotation) {
+                    var returnTypeSymbol = this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, returnTypeAnnotation, context);
+
+                    if (!returnTypeSymbol) {
+                        signature.returnType = this.getNewErrorTypeSymbol();
+
+                        hadError = true;
+                    } else {
+                        signature.returnType = returnTypeSymbol;
+                    }
+                } else {
+                    if (!setterAnnotatedType) {
+                        this.resolveFunctionBodyReturnTypes(funcDeclAST, block, null, signature, false, funcDecl, context);
+                    } else {
+                        signature.returnType = setterAnnotatedType;
+                    }
+                }
+
+                if (!hadError) {
+                    signature.setResolved();
+                }
+            }
+
+            return getterSymbol;
+        };
+
+        PullTypeResolver.prototype.checkIfGetterAndSetterTypeMatch = function (funcDeclAST, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            var accessorSymbol = funcDecl.getSymbol();
+            var getter = accessorSymbol.getGetter();
+            var setter = accessorSymbol.getSetter();
+
+            if (getter && setter) {
+                var getterAST = getter.getDeclarations()[0].ast();
+                var setterAST = setter.getDeclarations()[0].ast();
+
+                if (getterAST.typeAnnotation && PullTypeResolver.hasSetAccessorParameterTypeAnnotation(setterAST)) {
+                    var setterSig = setter.type.getCallSignatures()[0];
+                    var setterParameters = setterSig.parameters;
+
+                    var getter = accessorSymbol.getGetter();
+                    var getterSig = getter.type.getCallSignatures()[0];
+
+                    var setterSuppliedTypeSymbol = setterParameters[0].type;
+                    var getterSuppliedTypeSymbol = getterSig.returnType;
+
+                    if (!this.typesAreIdentical(setterSuppliedTypeSymbol, getterSuppliedTypeSymbol, context)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.get_and_set_accessor_must_have_the_same_type));
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckGetAccessorDeclaration = function (funcDeclAST, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            var accessorSymbol = funcDecl.getSymbol();
+
+            this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, TypeScript.ASTHelpers.getType(funcDeclAST), context);
+
+            this.resolveAST(funcDeclAST.block, false, context);
+
+            this.validateVariableDeclarationGroups(funcDecl, context);
+
+            var enclosingDecl = this.getEnclosingDecl(funcDecl);
+
+            var hasReturn = (funcDecl.flags & (2048 /* Signature */ | 4194304 /* HasReturnStatement */)) !== 0;
+            var funcNameAST = funcDeclAST.propertyName;
+
+            if (!hasReturn && !this.containsSingleThrowStatement(funcDeclAST.block)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcNameAST, TypeScript.DiagnosticCode.Getters_must_return_a_value));
+            }
+
+            var setter = accessorSymbol.getSetter();
+            if (setter) {
+                var setterDecl = setter.getDeclarations()[0];
+                var setterIsPrivate = TypeScript.hasFlag(setterDecl.flags, 2 /* Private */);
+                var getterIsPrivate = TypeScript.hasModifier(funcDeclAST.modifiers, 2 /* Private */);
+
+                if (getterIsPrivate !== setterIsPrivate) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcNameAST, TypeScript.DiagnosticCode.Getter_and_setter_accessors_do_not_agree_in_visibility));
+                }
+
+                this.checkIfGetterAndSetterTypeMatch(funcDeclAST, context);
+            }
+
+            this.checkFunctionTypePrivacy(funcDeclAST, TypeScript.hasModifier(funcDeclAST.modifiers, 16 /* Static */), null, TypeScript.ASTHelpers.parametersFromParameterList(funcDeclAST.parameterList), TypeScript.ASTHelpers.getType(funcDeclAST), funcDeclAST.block, context);
+        };
+
+        PullTypeResolver.hasSetAccessorParameterTypeAnnotation = function (setAccessor) {
+            return setAccessor.parameterList && setAccessor.parameterList.parameters.nonSeparatorCount() > 0 && setAccessor.parameterList.parameters.nonSeparatorAt(0).typeAnnotation !== null;
+        };
+
+        PullTypeResolver.prototype.resolveSetAccessorDeclaration = function (funcDeclAST, parameterList, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            var accessorSymbol = funcDecl.getSymbol();
+
+            var setterSymbol = accessorSymbol.getSetter();
+            var setterTypeSymbol = setterSymbol.type;
+
+            var signature = funcDecl.getSignatureSymbol();
+
+            var hadError = false;
+
+            if (signature) {
+                if (signature.isResolved) {
+                    return setterSymbol;
+                }
+
+                if (signature.inResolution) {
+                    signature.returnType = this.semanticInfoChain.voidTypeSymbol;
+                    signature.setResolved();
+                    return setterSymbol;
+                }
+
+                signature.startResolving();
+
+                if (parameterList) {
+                    for (var i = 0; i < parameterList.parameters.nonSeparatorCount(); i++) {
+                        this.resolveParameter(parameterList.parameters.nonSeparatorAt(i), context);
+                    }
+                }
+
+                signature.returnType = this.semanticInfoChain.voidTypeSymbol;
+
+                if (!hadError) {
+                    signature.setResolved();
+                }
+            }
+
+            return setterSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckSetAccessorDeclaration = function (funcDeclAST, context) {
+            var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            var accessorSymbol = funcDecl.getSymbol();
+
+            if (funcDeclAST.parameterList) {
+                for (var i = 0; i < funcDeclAST.parameterList.parameters.nonSeparatorCount(); i++) {
+                    this.resolveParameter(funcDeclAST.parameterList.parameters.nonSeparatorAt(i), context);
+                }
+            }
+
+            this.resolveAST(funcDeclAST.block, false, context);
+
+            this.validateVariableDeclarationGroups(funcDecl, context);
+
+            var hasReturn = (funcDecl.flags & (2048 /* Signature */ | 4194304 /* HasReturnStatement */)) !== 0;
+
+            var getter = accessorSymbol.getGetter();
+
+            var funcNameAST = funcDeclAST.propertyName;
+
+            if (getter) {
+                var getterDecl = getter.getDeclarations()[0];
+                var getterIsPrivate = TypeScript.hasFlag(getterDecl.flags, 2 /* Private */);
+                var setterIsPrivate = TypeScript.hasModifier(funcDeclAST.modifiers, 2 /* Private */);
+
+                if (getterIsPrivate !== setterIsPrivate) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcNameAST, TypeScript.DiagnosticCode.Getter_and_setter_accessors_do_not_agree_in_visibility));
+                }
+
+                this.checkIfGetterAndSetterTypeMatch(funcDeclAST, context);
+            } else {
+                if (this.compilationSettings.noImplicitAny()) {
+                    var setterFunctionDeclarationAst = funcDeclAST;
+                    if (!PullTypeResolver.hasSetAccessorParameterTypeAnnotation(setterFunctionDeclarationAst) && accessorSymbol.type === this.semanticInfoChain.anyTypeSymbol) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_get_accessor_and_parameter_type_annotation_on_set_accessor_implicitly_has_an_any_type, [setterFunctionDeclarationAst.propertyName.text()]));
+                    }
+                }
+            }
+
+            this.checkFunctionTypePrivacy(funcDeclAST, TypeScript.hasModifier(funcDeclAST.modifiers, 16 /* Static */), null, TypeScript.ASTHelpers.parametersFromParameterList(funcDeclAST.parameterList), null, funcDeclAST.block, context);
+        };
+
+        PullTypeResolver.prototype.resolveList = function (list, context) {
+            if (this.canTypeCheckAST(list, context)) {
+                this.setTypeChecked(list, context);
+
+                for (var i = 0, n = list.childCount(); i < n; i++) {
+                    this.resolveAST(list.childAt(i), false, context);
+                }
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveSeparatedList = function (list, context) {
+            if (this.canTypeCheckAST(list, context)) {
+                this.setTypeChecked(list, context);
+
+                for (var i = 0, n = list.nonSeparatorCount(); i < n; i++) {
+                    this.resolveAST(list.nonSeparatorAt(i), false, context);
+                }
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveVoidExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+
+                this.resolveAST(ast.expression, false, context);
+            }
+
+            return this.semanticInfoChain.undefinedTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveLogicalOperation = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckLogicalOperation(ast, context);
+            }
+
+            return this.semanticInfoChain.booleanTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckLogicalOperation = function (binex, context) {
+            this.setTypeChecked(binex, context);
+
+            var leftType = this.resolveAST(binex.left, false, context).type;
+            var rightType = this.resolveAST(binex.right, false, context).type;
+
+            var comparisonInfo = new TypeComparisonInfo();
+            if (!this.sourceIsAssignableToTarget(leftType, rightType, binex, context, comparisonInfo) && !this.sourceIsAssignableToTarget(rightType, leftType, binex, context, comparisonInfo)) {
+                var enclosingSymbol = this.getEnclosingSymbolForAST(binex);
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binex, TypeScript.DiagnosticCode.Operator_0_cannot_be_applied_to_types_1_and_2, [
+                    TypeScript.SyntaxFacts.getText(TypeScript.SyntaxFacts.getOperatorTokenFromBinaryExpression(binex.kind())),
+                    leftType.toString(enclosingSymbol), rightType.toString(enclosingSymbol)]));
+            }
+        };
+
+        PullTypeResolver.prototype.resolveLogicalNotExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+
+                this.resolveAST(ast.operand, false, context);
+            }
+
+            return this.semanticInfoChain.booleanTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveUnaryArithmeticOperation = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckUnaryArithmeticOperation(ast, context);
+            }
+
+            return this.semanticInfoChain.numberTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolvePostfixUnaryExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckPostfixUnaryExpression(ast, context);
+            }
+
+            return this.semanticInfoChain.numberTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.isAnyOrNumberOrEnum = function (type) {
+            return this.isAnyOrEquivalent(type) || type === this.semanticInfoChain.numberTypeSymbol || TypeScript.PullHelpers.symbolIsEnum(type);
+        };
+
+        PullTypeResolver.prototype.typeCheckUnaryArithmeticOperation = function (unaryExpression, context) {
+            this.setTypeChecked(unaryExpression, context);
+
+            var nodeType = unaryExpression.kind();
+            var expression = this.resolveAST(unaryExpression.operand, false, context);
+
+            if (nodeType === 164 /* PlusExpression */ || nodeType == 165 /* NegateExpression */ || nodeType == 166 /* BitwiseNotExpression */) {
+                return;
+            }
+
+            TypeScript.Debug.assert(nodeType === 168 /* PreIncrementExpression */ || nodeType === 169 /* PreDecrementExpression */);
+
+            var operandType = expression.type;
+            if (!this.isAnyOrNumberOrEnum(operandType)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_type_of_a_unary_arithmetic_operation_operand_must_be_of_type_any_number_or_an_enum_type));
+            }
+
+            if (!this.isReference(unaryExpression.operand, expression)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer));
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckPostfixUnaryExpression = function (unaryExpression, context) {
+            this.setTypeChecked(unaryExpression, context);
+
+            var nodeType = unaryExpression.kind();
+            var expression = this.resolveAST(unaryExpression.operand, false, context);
+
+            TypeScript.Debug.assert(nodeType === 210 /* PostIncrementExpression */ || nodeType === 211 /* PostDecrementExpression */);
+
+            var operandType = expression.type;
+            if (!this.isAnyOrNumberOrEnum(operandType)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_type_of_a_unary_arithmetic_operation_operand_must_be_of_type_any_number_or_an_enum_type));
+            }
+
+            if (!this.isReference(unaryExpression.operand, expression)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer));
+            }
+        };
+
+        PullTypeResolver.prototype.resolveBinaryArithmeticExpression = function (binaryExpression, context) {
+            if (this.canTypeCheckAST(binaryExpression, context)) {
+                this.typeCheckBinaryArithmeticExpression(binaryExpression, context);
+            }
+
+            return this.semanticInfoChain.numberTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckBinaryArithmeticExpression = function (binaryExpression, context) {
+            this.setTypeChecked(binaryExpression, context);
+
+            var lhsSymbol = this.resolveAST(binaryExpression.left, false, context);
+
+            var lhsType = lhsSymbol.type;
+            var rhsType = this.resolveAST(binaryExpression.right, false, context).type;
+
+            if (lhsType === this.semanticInfoChain.nullTypeSymbol || lhsType === this.semanticInfoChain.undefinedTypeSymbol) {
+                lhsType = rhsType;
+            }
+
+            if (rhsType === this.semanticInfoChain.nullTypeSymbol || rhsType === this.semanticInfoChain.undefinedTypeSymbol) {
+                rhsType = lhsType;
+            }
+
+            var lhsIsFit = this.isAnyOrNumberOrEnum(lhsType);
+            var rhsIsFit = this.isAnyOrNumberOrEnum(rhsType);
+
+            if (!rhsIsFit) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.right, TypeScript.DiagnosticCode.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type));
+            }
+
+            if (!lhsIsFit) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type));
+            }
+
+            if (lhsIsFit && rhsIsFit) {
+                switch (binaryExpression.kind()) {
+                    case 183 /* LeftShiftAssignmentExpression */:
+                    case 184 /* SignedRightShiftAssignmentExpression */:
+                    case 185 /* UnsignedRightShiftAssignmentExpression */:
+                    case 176 /* SubtractAssignmentExpression */:
+                    case 177 /* MultiplyAssignmentExpression */:
+                    case 178 /* DivideAssignmentExpression */:
+                    case 179 /* ModuloAssignmentExpression */:
+                    case 182 /* OrAssignmentExpression */:
+                    case 180 /* AndAssignmentExpression */:
+                    case 181 /* ExclusiveOrAssignmentExpression */:
+                        if (!this.isReference(binaryExpression.left, lhsSymbol)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_left_hand_side_of_assignment_expression));
+                        }
+
+                        this.checkAssignability(binaryExpression.left, rhsType, lhsType, context);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveTypeOfExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+
+                this.resolveAST(ast.expression, false, context);
+            }
+
+            return this.semanticInfoChain.stringTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveThrowStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+
+                this.resolveAST(ast.expression, false, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveDeleteExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+                this.resolveAST(ast.expression, false, context);
+            }
+
+            return this.semanticInfoChain.booleanTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveInstanceOfExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckInstanceOfExpression(ast, context);
+            }
+
+            return this.semanticInfoChain.booleanTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckInstanceOfExpression = function (binaryExpression, context) {
+            this.setTypeChecked(binaryExpression, context);
+
+            var lhsType = this.resolveAST(binaryExpression.left, false, context).type;
+            var rhsType = this.resolveAST(binaryExpression.right, false, context).type;
+
+            var enclosingSymbol = this.getEnclosingSymbolForAST(binaryExpression);
+            var isValidLHS = this.isAnyOrEquivalent(lhsType) || lhsType.isObject() || lhsType.isTypeParameter();
+            var isValidRHS = this.isAnyOrEquivalent(rhsType) || this.typeIsAssignableToFunction(rhsType, binaryExpression, context);
+
+            if (!isValidLHS) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter));
+            }
+
+            if (!isValidRHS) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.right, TypeScript.DiagnosticCode.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type));
+            }
+        };
+
+        PullTypeResolver.prototype.resolveCommaExpression = function (commaExpression, context) {
+            if (this.canTypeCheckAST(commaExpression, context)) {
+                this.setTypeChecked(commaExpression, context);
+
+                this.resolveAST(commaExpression.left, false, context);
+            }
+
+            return this.resolveAST(commaExpression.right, false, context).type;
+        };
+
+        PullTypeResolver.prototype.resolveInExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckInExpression(ast, context);
+            }
+
+            return this.semanticInfoChain.booleanTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckInExpression = function (binaryExpression, context) {
+            this.setTypeChecked(binaryExpression, context);
+
+            var lhsType = this.resolveAST(binaryExpression.left, false, context).type;
+            var rhsType = this.resolveAST(binaryExpression.right, false, context).type;
+
+            var isValidLHS = this.isAnyOrEquivalent(lhsType.type) || lhsType.type === this.semanticInfoChain.stringTypeSymbol || lhsType.type === this.semanticInfoChain.numberTypeSymbol;
+
+            var isValidRHS = this.isAnyOrEquivalent(rhsType) || rhsType.isObject() || rhsType.isTypeParameter();
+
+            if (!isValidLHS) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.The_left_hand_side_of_an_in_expression_must_be_of_types_any_string_or_number));
+            }
+
+            if (!isValidRHS) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.right, TypeScript.DiagnosticCode.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter));
+            }
+        };
+
+        PullTypeResolver.prototype.resolveForStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+
+                this.resolveAST(ast.variableDeclaration, false, context);
+                this.resolveAST(ast.initializer, false, context);
+                this.resolveAST(ast.condition, false, context);
+                this.resolveAST(ast.incrementor, false, context);
+                this.resolveAST(ast.statement, false, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveForInStatement = function (forInStatement, context) {
+            if (this.canTypeCheckAST(forInStatement, context)) {
+                this.typeCheckForInStatement(forInStatement, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckForInStatement = function (forInStatement, context) {
+            this.setTypeChecked(forInStatement, context);
+
+            if (forInStatement.variableDeclaration) {
+                var declaration = forInStatement.variableDeclaration;
+
+                if (declaration.declarators.nonSeparatorCount() === 1) {
+                    var varDecl = declaration.declarators.nonSeparatorAt(0);
+
+                    if (varDecl.typeAnnotation) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(declaration, TypeScript.DiagnosticCode.Variable_declarations_of_a_for_statement_cannot_use_a_type_annotation));
+                    }
+                }
+            } else {
+                var varSym = this.resolveAST(forInStatement.left, false, context);
+                var isStringOrNumber = varSym.type === this.semanticInfoChain.stringTypeSymbol || this.isAnyOrEquivalent(varSym.type);
+
+                if (!isStringOrNumber) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(forInStatement.left, TypeScript.DiagnosticCode.Variable_declarations_of_a_for_statement_must_be_of_types_string_or_any));
+                }
+            }
+
+            var rhsType = this.resolveAST(forInStatement.expression, false, context).type;
+            var isValidRHS = rhsType && (this.isAnyOrEquivalent(rhsType) || rhsType.isObject() || rhsType.isTypeParameter());
+
+            if (!isValidRHS) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(forInStatement.expression, TypeScript.DiagnosticCode.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter));
+            }
+
+            this.resolveAST(forInStatement.statement, false, context);
+        };
+
+        PullTypeResolver.prototype.resolveWhileStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckWhileStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckWhileStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            this.resolveAST(ast.condition, false, context);
+            this.resolveAST(ast.statement, false, context);
+        };
+
+        PullTypeResolver.prototype.resolveDoStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckDoStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckDoStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            this.resolveAST(ast.condition, false, context);
+            this.resolveAST(ast.statement, false, context);
+        };
+
+        PullTypeResolver.prototype.resolveIfStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckIfStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckIfStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            this.resolveAST(ast.condition, false, context);
+            this.resolveAST(ast.statement, false, context);
+            this.resolveAST(ast.elseClause, false, context);
+        };
+
+        PullTypeResolver.prototype.resolveElseClause = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckElseClause(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckElseClause = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            this.resolveAST(ast.statement, false, context);
+        };
+
+        PullTypeResolver.prototype.resolveBlock = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+                this.resolveAST(ast.statements, false, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveVariableStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+                this.resolveAST(ast.declaration, false, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveVariableDeclarationList = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+                this.resolveAST(ast.declarators, false, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveWithStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckWithStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckWithStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+            var withStatement = ast;
+            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(withStatement.condition, TypeScript.DiagnosticCode.All_symbols_within_a_with_block_will_be_resolved_to_any));
+        };
+
+        PullTypeResolver.prototype.resolveTryStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckTryStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckTryStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+            var tryStatement = ast;
+
+            this.resolveAST(tryStatement.block, false, context);
+            this.resolveAST(tryStatement.catchClause, false, context);
+            this.resolveAST(tryStatement.finallyClause, false, context);
+        };
+
+        PullTypeResolver.prototype.resolveCatchClause = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckCatchClause(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckCatchClause = function (ast, context) {
+            this.setTypeChecked(ast, context);
+            this.resolveAST(ast.block, false, context);
+
+            var catchDecl = this.semanticInfoChain.getDeclForAST(ast);
+            this.validateVariableDeclarationGroups(catchDecl, context);
+        };
+
+        PullTypeResolver.prototype.resolveFinallyClause = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckFinallyClause(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckFinallyClause = function (ast, context) {
+            this.setTypeChecked(ast, context);
+            this.resolveAST(ast.block, false, context);
+        };
+
+        PullTypeResolver.prototype.getEnclosingFunctionDeclaration = function (ast) {
+            var enclosingDecl = this.getEnclosingDeclForAST(ast);
+
+            while (enclosingDecl) {
+                if (enclosingDecl.kind & 1032192 /* SomeFunction */) {
+                    return enclosingDecl;
+                }
+
+                enclosingDecl = enclosingDecl.getParentDecl();
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.resolveReturnExpression = function (expression, enclosingFunction, context) {
+            if (enclosingFunction) {
+                enclosingFunction.setFlag(4194304 /* HasReturnStatement */);
+            }
+
+            var isContextuallyTyped = false;
+
+            if (enclosingFunction) {
+                var enclosingDeclAST = this.getASTForDecl(enclosingFunction);
+                var typeAnnotation = TypeScript.ASTHelpers.getType(enclosingDeclAST);
+                if (typeAnnotation) {
+                    var returnTypeAnnotationSymbol = this.resolveTypeReference(typeAnnotation, context);
+                    if (returnTypeAnnotationSymbol) {
+                        isContextuallyTyped = true;
+                        context.pushNewContextualType(returnTypeAnnotationSymbol);
+                    }
+                } else {
+                    var currentContextualType = context.getContextualType();
+                    if (currentContextualType && currentContextualType.isFunction()) {
+                        var contextualSignatures = currentContextualType.kind == 33554432 /* ConstructorType */ ? currentContextualType.getConstructSignatures() : currentContextualType.getCallSignatures();
+                        var currentContextualTypeSignatureSymbol = contextualSignatures[0];
+
+                        var currentContextualTypeReturnTypeSymbol = currentContextualTypeSignatureSymbol.returnType;
+                        if (currentContextualTypeReturnTypeSymbol) {
+                            isContextuallyTyped = true;
+                            context.propagateContextualType(currentContextualTypeReturnTypeSymbol);
+                        }
+                    }
+                }
+            }
+
+            var result = this.resolveAST(expression, isContextuallyTyped, context).type;
+            if (isContextuallyTyped) {
+                context.popAnyContextualType();
+            }
+
+            return result;
+        };
+
+        PullTypeResolver.prototype.typeCheckReturnExpression = function (expression, expressionType, enclosingFunction, context) {
+            if (enclosingFunction && enclosingFunction.kind === 32768 /* ConstructorMethod */) {
+                var classDecl = enclosingFunction.getParentDecl();
+                if (classDecl) {
+                    var classSymbol = classDecl.getSymbol();
+                    this.resolveDeclaredSymbol(classSymbol, context);
+
+                    var comparisonInfo = new TypeComparisonInfo();
+                    var isAssignable = this.sourceIsAssignableToTarget(expressionType, classSymbol.type, expression, context, comparisonInfo);
+                    if (!isAssignable) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class));
+                    }
+                }
+            }
+
+            if (enclosingFunction && enclosingFunction.kind === 524288 /* SetAccessor */) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Setters_cannot_return_a_value));
+            }
+
+            if (enclosingFunction) {
+                var enclosingDeclAST = this.getASTForDecl(enclosingFunction);
+                var typeAnnotation = TypeScript.ASTHelpers.getType(enclosingDeclAST);
+                if (typeAnnotation || enclosingFunction.kind === 262144 /* GetAccessor */) {
+                    var signatureSymbol = enclosingFunction.getSignatureSymbol();
+                    var sigReturnType = signatureSymbol.returnType;
+
+                    if (expressionType && sigReturnType) {
+                        var comparisonInfo = new TypeComparisonInfo();
+                        var upperBound = null;
+
+                        this.resolveDeclaredSymbol(expressionType, context);
+                        this.resolveDeclaredSymbol(sigReturnType, context);
+
+                        var isAssignable = this.sourceIsAssignableToTarget(expressionType, sigReturnType, expression, context, comparisonInfo);
+
+                        if (!isAssignable) {
+                            var enclosingSymbol = this.getEnclosingSymbolForAST(expression);
+                            if (comparisonInfo.message) {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [expressionType.toString(enclosingSymbol), sigReturnType.toString(enclosingSymbol), comparisonInfo.message]));
+                            } else {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [expressionType.toString(enclosingSymbol), sigReturnType.toString(enclosingSymbol)]));
+                            }
+                        }
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveReturnStatement = function (returnAST, context) {
+            var enclosingFunction = this.getEnclosingFunctionDeclaration(returnAST);
+            if (enclosingFunction) {
+                enclosingFunction.setFlag(4194304 /* HasReturnStatement */);
+            }
+
+            var returnType = this.getSymbolForAST(returnAST, context);
+            var canTypeCheckAST = this.canTypeCheckAST(returnAST, context);
+            if (!returnType || canTypeCheckAST) {
+                var returnExpr = returnAST.expression;
+
+                var resolvedReturnType = returnExpr === null ? this.semanticInfoChain.voidTypeSymbol : this.resolveReturnExpression(returnExpr, enclosingFunction, context);
+
+                if (!returnType) {
+                    returnType = resolvedReturnType;
+                    this.setSymbolForAST(returnAST, resolvedReturnType, context);
+                }
+
+                if (returnExpr && canTypeCheckAST) {
+                    this.setTypeChecked(returnExpr, context);
+                    this.typeCheckReturnExpression(returnExpr, resolvedReturnType, enclosingFunction, context);
+                }
+            }
+
+            return returnType;
+        };
+
+        PullTypeResolver.prototype.resolveSwitchStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckSwitchStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckSwitchStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            var expressionType = this.resolveAST(ast.expression, false, context).type;
+
+            for (var i = 0, n = ast.switchClauses.childCount(); i < n; i++) {
+                var switchClause = ast.switchClauses.childAt(i);
+                if (switchClause.kind() === 233 /* CaseSwitchClause */) {
+                    var caseSwitchClause = switchClause;
+
+                    var caseClauseExpressionType = this.resolveAST(caseSwitchClause.expression, false, context).type;
+                    this.resolveAST(caseSwitchClause.statements, false, context);
+
+                    var comparisonInfo = new TypeComparisonInfo();
+                    if (!this.sourceIsAssignableToTarget(expressionType, caseClauseExpressionType, caseSwitchClause.expression, context, comparisonInfo) && !this.sourceIsAssignableToTarget(caseClauseExpressionType, expressionType, caseSwitchClause.expression, context, comparisonInfo)) {
+                        var enclosingSymbol = this.getEnclosingSymbolForAST(caseSwitchClause.expression);
+                        if (comparisonInfo.message) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(caseSwitchClause.expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [caseClauseExpressionType.toString(enclosingSymbol), expressionType.toString(enclosingSymbol), comparisonInfo.message]));
+                        } else {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(caseSwitchClause.expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [caseClauseExpressionType.toString(enclosingSymbol), expressionType.toString(enclosingSymbol)]));
+                        }
+                    }
+                } else {
+                    var defaultSwitchClause = switchClause;
+                    this.resolveAST(defaultSwitchClause.statements, false, context);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveLabeledStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckLabeledStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckLabeledStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            var labelIdentifier = ast.identifier.valueText();
+
+            var breakableLabels = this.getEnclosingLabels(ast, true, false);
+
+            var matchingLabel = TypeScript.ArrayUtilities.firstOrDefault(breakableLabels, function (s) {
+                return s.identifier.valueText() === labelIdentifier;
+            });
+            if (matchingLabel) {
+                context.postDiagnostic(this.semanticInfoChain.duplicateIdentifierDiagnosticFromAST(ast.identifier, labelIdentifier, matchingLabel));
+            }
+
+            this.resolveAST(ast.statement, false, context);
+        };
+
+        PullTypeResolver.prototype.labelIsOnContinuableConstruct = function (statement) {
+            switch (statement.kind()) {
+                case 160 /* LabeledStatement */:
+                    return this.labelIsOnContinuableConstruct(statement.statement);
+
+                case 158 /* WhileStatement */:
+                case 154 /* ForStatement */:
+                case 155 /* ForInStatement */:
+                case 161 /* DoStatement */:
+                    return true;
+
+                default:
+                    return false;
+            }
+        };
+
+        PullTypeResolver.prototype.resolveContinueStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckContinueStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.isIterationStatement = function (ast) {
+            switch (ast.kind()) {
+                case 154 /* ForStatement */:
+                case 155 /* ForInStatement */:
+                case 158 /* WhileStatement */:
+                case 161 /* DoStatement */:
+                    return true;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.isAnyFunctionExpressionOrDeclaration = function (ast) {
+            switch (ast.kind()) {
+                case 219 /* SimpleArrowFunctionExpression */:
+                case 218 /* ParenthesizedArrowFunctionExpression */:
+                case 222 /* FunctionExpression */:
+                case 129 /* FunctionDeclaration */:
+                case 135 /* MemberFunctionDeclaration */:
+                case 241 /* FunctionPropertyAssignment */:
+                case 137 /* ConstructorDeclaration */:
+                case 139 /* GetAccessor */:
+                case 140 /* SetAccessor */:
+                    return true;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.inSwitchStatement = function (ast) {
+            while (ast) {
+                if (ast.kind() === 151 /* SwitchStatement */) {
+                    return true;
+                }
+
+                if (this.isAnyFunctionExpressionOrDeclaration(ast)) {
+                    return false;
+                }
+
+                ast = ast.parent;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.inIterationStatement = function (ast, crossFunctions) {
+            while (ast) {
+                if (this.isIterationStatement(ast)) {
+                    return true;
+                }
+
+                if (!crossFunctions && this.isAnyFunctionExpressionOrDeclaration(ast)) {
+                    return false;
+                }
+
+                ast = ast.parent;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.getEnclosingLabels = function (ast, breakable, crossFunctions) {
+            var result = [];
+
+            ast = ast.parent;
+            while (ast) {
+                if (ast.kind() === 160 /* LabeledStatement */) {
+                    var labeledStatement = ast;
+                    if (breakable) {
+                        result.push(labeledStatement);
+                    } else {
+                        if (this.labelIsOnContinuableConstruct(labeledStatement.statement)) {
+                            result.push(labeledStatement);
+                        }
+                    }
+                }
+
+                if (!crossFunctions && this.isAnyFunctionExpressionOrDeclaration(ast)) {
+                    break;
+                }
+
+                ast = ast.parent;
+            }
+
+            return result;
+        };
+
+        PullTypeResolver.prototype.typeCheckContinueStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            if (!this.inIterationStatement(ast, false)) {
+                if (this.inIterationStatement(ast, true)) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_cannot_cross_function_boundary));
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.continue_statement_can_only_be_used_within_an_enclosing_iteration_statement));
+                }
+            } else if (ast.identifier) {
+                var continuableLabels = this.getEnclosingLabels(ast, false, false);
+
+                if (!TypeScript.ArrayUtilities.any(continuableLabels, function (s) {
+                    return s.identifier.valueText() === ast.identifier.valueText();
+                })) {
+                    var continuableLabels = this.getEnclosingLabels(ast, false, true);
+
+                    if (TypeScript.ArrayUtilities.any(continuableLabels, function (s) {
+                        return s.identifier.valueText() === ast.identifier.valueText();
+                    })) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_cannot_cross_function_boundary));
+                    } else {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_not_found));
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveBreakStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckBreakStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckBreakStatement = function (ast, context) {
+            this.setTypeChecked(ast, context);
+
+            if (ast.identifier) {
+                var breakableLabels = this.getEnclosingLabels(ast, true, false);
+
+                if (!TypeScript.ArrayUtilities.any(breakableLabels, function (s) {
+                    return s.identifier.valueText() === ast.identifier.valueText();
+                })) {
+                    var breakableLabels = this.getEnclosingLabels(ast, true, true);
+                    if (TypeScript.ArrayUtilities.any(breakableLabels, function (s) {
+                        return s.identifier.valueText() === ast.identifier.valueText();
+                    })) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_cannot_cross_function_boundary));
+                    } else {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_not_found));
+                    }
+                }
+            } else if (!this.inIterationStatement(ast, false) && !this.inSwitchStatement(ast)) {
+                if (this.inIterationStatement(ast, true)) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_cannot_cross_function_boundary));
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveAST = function (ast, isContextuallyTyped, context) {
+            if (!ast) {
+                return;
+            }
+
+            var symbol = this.getSymbolForAST(ast, context);
+            if (symbol && symbol.isResolved) {
+                this.typeCheckAST(ast, isContextuallyTyped, context);
+                return symbol;
+            }
+
+            if (ast.isExpression() && !isTypesOnlyLocation(ast)) {
+                return this.resolveExpressionAST(ast, isContextuallyTyped, context);
+            }
+
+            var nodeType = ast.kind();
+
+            switch (nodeType) {
+                case 124 /* ArrayType */:
+                case 126 /* GenericType */:
+                case 122 /* ObjectType */:
+                case 127 /* TypeQuery */:
+                case 125 /* ConstructorType */:
+                case 123 /* FunctionType */:
+                    return this.resolveTypeReference(ast, context);
+
+                case 1 /* List */:
+                    return this.resolveList(ast, context);
+
+                case 2 /* SeparatedList */:
+                    return this.resolveSeparatedList(ast, context);
+
+                case 120 /* SourceUnit */:
+                    return this.resolveSourceUnit(ast, context);
+
+                case 132 /* EnumDeclaration */:
+                    return this.resolveEnumDeclaration(ast, context);
+
+                case 130 /* ModuleDeclaration */:
+                    return this.resolveModuleDeclaration(ast, context);
+
+                case 128 /* InterfaceDeclaration */:
+                    return this.resolveInterfaceDeclaration(ast, context);
+
+                case 131 /* ClassDeclaration */:
+                    return this.resolveClassDeclaration(ast, context);
+
+                case 224 /* VariableDeclaration */:
+                    return this.resolveVariableDeclarationList(ast, context);
+
+                case 136 /* MemberVariableDeclaration */:
+                    return this.resolveMemberVariableDeclaration(ast, context);
+
+                case 225 /* VariableDeclarator */:
+                    return this.resolveVariableDeclarator(ast, context);
+
+                case 141 /* PropertySignature */:
+                    return this.resolvePropertySignature(ast, context);
+
+                case 227 /* ParameterList */:
+                    return this.resolveParameterList(ast, context);
+
+                case 242 /* Parameter */:
+                    return this.resolveParameter(ast, context);
+
+                case 243 /* EnumElement */:
+                    return this.resolveEnumElement(ast, context);
+
+                case 232 /* EqualsValueClause */:
+                    return this.resolveEqualsValueClause(ast, isContextuallyTyped, context);
+
+                case 238 /* TypeParameter */:
+                    return this.resolveTypeParameterDeclaration(ast, context);
+
+                case 239 /* Constraint */:
+                    return this.resolveConstraint(ast, context);
+
+                case 133 /* ImportDeclaration */:
+                    return this.resolveImportDeclaration(ast, context);
+
+                case 240 /* SimplePropertyAssignment */:
+                    return this.resolveSimplePropertyAssignment(ast, isContextuallyTyped, context);
+
+                case 241 /* FunctionPropertyAssignment */:
+                    return this.resolveFunctionPropertyAssignment(ast, isContextuallyTyped, context);
+
+                case 11 /* IdentifierName */:
+                    TypeScript.Debug.assert(isTypesOnlyLocation(ast));
+                    return this.resolveTypeNameExpression(ast, context);
+
+                case 121 /* QualifiedName */:
+                    return this.resolveQualifiedName(ast, context);
+
+                case 137 /* ConstructorDeclaration */:
+                    return this.resolveConstructorDeclaration(ast, context);
+
+                case 139 /* GetAccessor */:
+                case 140 /* SetAccessor */:
+                    return this.resolveAccessorDeclaration(ast, context);
+
+                case 138 /* IndexMemberDeclaration */:
+                    return this.resolveIndexMemberDeclaration(ast, context);
+
+                case 144 /* IndexSignature */:
+                    return this.resolveIndexSignature(ast, context);
+
+                case 135 /* MemberFunctionDeclaration */:
+                    return this.resolveMemberFunctionDeclaration(ast, context);
+
+                case 142 /* CallSignature */:
+                    return this.resolveCallSignature(ast, context);
+
+                case 143 /* ConstructSignature */:
+                    return this.resolveConstructSignature(ast, context);
+
+                case 145 /* MethodSignature */:
+                    return this.resolveMethodSignature(ast, context);
+
+                case 129 /* FunctionDeclaration */:
+                    return this.resolveAnyFunctionDeclaration(ast, context);
+
+                case 244 /* TypeAnnotation */:
+                    return this.resolveTypeAnnotation(ast, context);
+
+                case 134 /* ExportAssignment */:
+                    return this.resolveExportAssignmentStatement(ast, context);
+
+                case 157 /* ThrowStatement */:
+                    return this.resolveThrowStatement(ast, context);
+
+                case 149 /* ExpressionStatement */:
+                    return this.resolveExpressionStatement(ast, context);
+
+                case 154 /* ForStatement */:
+                    return this.resolveForStatement(ast, context);
+
+                case 155 /* ForInStatement */:
+                    return this.resolveForInStatement(ast, context);
+
+                case 158 /* WhileStatement */:
+                    return this.resolveWhileStatement(ast, context);
+
+                case 161 /* DoStatement */:
+                    return this.resolveDoStatement(ast, context);
+
+                case 147 /* IfStatement */:
+                    return this.resolveIfStatement(ast, context);
+
+                case 235 /* ElseClause */:
+                    return this.resolveElseClause(ast, context);
+
+                case 146 /* Block */:
+                    return this.resolveBlock(ast, context);
+
+                case 148 /* VariableStatement */:
+                    return this.resolveVariableStatement(ast, context);
+
+                case 163 /* WithStatement */:
+                    return this.resolveWithStatement(ast, context);
+
+                case 159 /* TryStatement */:
+                    return this.resolveTryStatement(ast, context);
+
+                case 236 /* CatchClause */:
+                    return this.resolveCatchClause(ast, context);
+
+                case 237 /* FinallyClause */:
+                    return this.resolveFinallyClause(ast, context);
+
+                case 150 /* ReturnStatement */:
+                    return this.resolveReturnStatement(ast, context);
+
+                case 151 /* SwitchStatement */:
+                    return this.resolveSwitchStatement(ast, context);
+
+                case 153 /* ContinueStatement */:
+                    return this.resolveContinueStatement(ast, context);
+
+                case 152 /* BreakStatement */:
+                    return this.resolveBreakStatement(ast, context);
+
+                case 160 /* LabeledStatement */:
+                    return this.resolveLabeledStatement(ast, context);
+            }
+
+            return this.semanticInfoChain.anyTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveExpressionAST = function (ast, isContextuallyOrInferentiallyTyped, context) {
+            var expressionSymbol = this.resolveExpressionWorker(ast, isContextuallyOrInferentiallyTyped, context);
+
+            if (isContextuallyOrInferentiallyTyped && context.isInferentiallyTyping()) {
+                return this.alterPotentialGenericFunctionTypeToInstantiatedFunctionTypeForTypeArgumentInference(expressionSymbol, context);
+            } else {
+                return expressionSymbol;
+            }
+        };
+
+        PullTypeResolver.prototype.resolveExpressionWorker = function (ast, isContextuallyTyped, context) {
+            switch (ast.kind()) {
+                case 215 /* ObjectLiteralExpression */:
+                    return this.resolveObjectLiteralExpression(ast, isContextuallyTyped, context);
+
+                case 11 /* IdentifierName */:
+                    return this.resolveNameExpression(ast, context);
+
+                case 212 /* MemberAccessExpression */:
+                    return this.resolveMemberAccessExpression(ast, context);
+
+                case 222 /* FunctionExpression */:
+                    return this.resolveFunctionExpression(ast, isContextuallyTyped, context);
+
+                case 219 /* SimpleArrowFunctionExpression */:
+                    return this.resolveSimpleArrowFunctionExpression(ast, isContextuallyTyped, context);
+
+                case 218 /* ParenthesizedArrowFunctionExpression */:
+                    return this.resolveParenthesizedArrowFunctionExpression(ast, isContextuallyTyped, context);
+
+                case 214 /* ArrayLiteralExpression */:
+                    return this.resolveArrayLiteralExpression(ast, isContextuallyTyped, context);
+
+                case 35 /* ThisKeyword */:
+                    return this.resolveThisExpression(ast, context);
+
+                case 50 /* SuperKeyword */:
+                    return this.resolveSuperExpression(ast, context);
+
+                case 213 /* InvocationExpression */:
+                    return this.resolveInvocationExpression(ast, context);
+
+                case 216 /* ObjectCreationExpression */:
+                    return this.resolveObjectCreationExpression(ast, context);
+
+                case 220 /* CastExpression */:
+                    return this.resolveCastExpression(ast, context);
+
+                case 13 /* NumericLiteral */:
+                    return this.semanticInfoChain.numberTypeSymbol;
+
+                case 14 /* StringLiteral */:
+                    return this.semanticInfoChain.stringTypeSymbol;
+
+                case 32 /* NullKeyword */:
+                    return this.semanticInfoChain.nullTypeSymbol;
+
+                case 37 /* TrueKeyword */:
+                case 24 /* FalseKeyword */:
+                    return this.semanticInfoChain.booleanTypeSymbol;
+
+                case 172 /* VoidExpression */:
+                    return this.resolveVoidExpression(ast, context);
+
+                case 174 /* AssignmentExpression */:
+                    return this.resolveAssignmentExpression(ast, context);
+
+                case 167 /* LogicalNotExpression */:
+                    return this.resolveLogicalNotExpression(ast, context);
+
+                case 193 /* NotEqualsWithTypeConversionExpression */:
+                case 192 /* EqualsWithTypeConversionExpression */:
+                case 194 /* EqualsExpression */:
+                case 195 /* NotEqualsExpression */:
+                case 196 /* LessThanExpression */:
+                case 198 /* LessThanOrEqualExpression */:
+                case 199 /* GreaterThanOrEqualExpression */:
+                case 197 /* GreaterThanExpression */:
+                    return this.resolveLogicalOperation(ast, context);
+
+                case 208 /* AddExpression */:
+                case 175 /* AddAssignmentExpression */:
+                    return this.resolveBinaryAdditionOperation(ast, context);
+
+                case 164 /* PlusExpression */:
+                case 165 /* NegateExpression */:
+                case 166 /* BitwiseNotExpression */:
+                case 168 /* PreIncrementExpression */:
+                case 169 /* PreDecrementExpression */:
+                    return this.resolveUnaryArithmeticOperation(ast, context);
+
+                case 210 /* PostIncrementExpression */:
+                case 211 /* PostDecrementExpression */:
+                    return this.resolvePostfixUnaryExpression(ast, context);
+
+                case 209 /* SubtractExpression */:
+                case 205 /* MultiplyExpression */:
+                case 206 /* DivideExpression */:
+                case 207 /* ModuloExpression */:
+                case 189 /* BitwiseOrExpression */:
+                case 191 /* BitwiseAndExpression */:
+                case 202 /* LeftShiftExpression */:
+                case 203 /* SignedRightShiftExpression */:
+                case 204 /* UnsignedRightShiftExpression */:
+                case 190 /* BitwiseExclusiveOrExpression */:
+                case 181 /* ExclusiveOrAssignmentExpression */:
+                case 183 /* LeftShiftAssignmentExpression */:
+                case 184 /* SignedRightShiftAssignmentExpression */:
+                case 185 /* UnsignedRightShiftAssignmentExpression */:
+                case 176 /* SubtractAssignmentExpression */:
+                case 177 /* MultiplyAssignmentExpression */:
+                case 178 /* DivideAssignmentExpression */:
+                case 179 /* ModuloAssignmentExpression */:
+                case 182 /* OrAssignmentExpression */:
+                case 180 /* AndAssignmentExpression */:
+                    return this.resolveBinaryArithmeticExpression(ast, context);
+
+                case 221 /* ElementAccessExpression */:
+                    return this.resolveElementAccessExpression(ast, context);
+
+                case 187 /* LogicalOrExpression */:
+                    return this.resolveLogicalOrExpression(ast, isContextuallyTyped, context);
+
+                case 188 /* LogicalAndExpression */:
+                    return this.resolveLogicalAndExpression(ast, context);
+
+                case 171 /* TypeOfExpression */:
+                    return this.resolveTypeOfExpression(ast, context);
+
+                case 170 /* DeleteExpression */:
+                    return this.resolveDeleteExpression(ast, context);
+
+                case 186 /* ConditionalExpression */:
+                    return this.resolveConditionalExpression(ast, isContextuallyTyped, context);
+
+                case 12 /* RegularExpressionLiteral */:
+                    return this.resolveRegularExpressionLiteral();
+
+                case 217 /* ParenthesizedExpression */:
+                    return this.resolveParenthesizedExpression(ast, context);
+
+                case 200 /* InstanceOfExpression */:
+                    return this.resolveInstanceOfExpression(ast, context);
+
+                case 173 /* CommaExpression */:
+                    return this.resolveCommaExpression(ast, context);
+
+                case 201 /* InExpression */:
+                    return this.resolveInExpression(ast, context);
+
+                case 223 /* OmittedExpression */:
+                    return this.semanticInfoChain.undefinedTypeSymbol;
+            }
+
+            TypeScript.Debug.fail("resolveExpressionASTWorker: Missing expression kind: " + TypeScript.SyntaxKind[ast.kind()]);
+        };
+
+        PullTypeResolver.prototype.typeCheckAST = function (ast, isContextuallyTyped, context) {
+            if (!this.canTypeCheckAST(ast, context)) {
+                return;
+            }
+
+            var nodeType = ast.kind();
+            switch (nodeType) {
+                case 120 /* SourceUnit */:
+                    this.typeCheckSourceUnit(ast, context);
+                    return;
+
+                case 132 /* EnumDeclaration */:
+                    this.typeCheckEnumDeclaration(ast, context);
+                    return;
+
+                case 130 /* ModuleDeclaration */:
+                    this.typeCheckModuleDeclaration(ast, context);
+                    return;
+
+                case 128 /* InterfaceDeclaration */:
+                    this.typeCheckInterfaceDeclaration(ast, context);
+                    return;
+
+                case 131 /* ClassDeclaration */:
+                    this.typeCheckClassDeclaration(ast, context);
+                    return;
+
+                case 243 /* EnumElement */:
+                    this.typeCheckEnumElement(ast, context);
+                    return;
+
+                case 136 /* MemberVariableDeclaration */:
+                    this.typeCheckMemberVariableDeclaration(ast, context);
+                    return;
+
+                case 225 /* VariableDeclarator */:
+                    this.typeCheckVariableDeclarator(ast, context);
+                    return;
+
+                case 141 /* PropertySignature */:
+                    this.typeCheckPropertySignature(ast, context);
+                    return;
+
+                case 242 /* Parameter */:
+                    this.typeCheckParameter(ast, context);
+                    return;
+
+                case 133 /* ImportDeclaration */:
+                    this.typeCheckImportDeclaration(ast, context);
+                    return;
+
+                case 215 /* ObjectLiteralExpression */:
+                    this.resolveObjectLiteralExpression(ast, isContextuallyTyped, context);
+                    return;
+
+                case 241 /* FunctionPropertyAssignment */:
+                    this.typeCheckFunctionPropertyAssignment(ast, isContextuallyTyped, context);
+                    return;
+
+                case 11 /* IdentifierName */:
+                    if (isTypesOnlyLocation(ast)) {
+                        this.resolveTypeNameExpression(ast, context);
+                    } else {
+                        this.resolveNameExpression(ast, context);
+                    }
+                    return;
+
+                case 212 /* MemberAccessExpression */:
+                    this.resolveMemberAccessExpression(ast, context);
+                    return;
+
+                case 121 /* QualifiedName */:
+                    this.resolveQualifiedName(ast, context);
+                    return;
+
+                case 222 /* FunctionExpression */:
+                    this.typeCheckFunctionExpression(ast, isContextuallyTyped, context);
+                    return;
+
+                case 137 /* ConstructorDeclaration */:
+                    this.typeCheckConstructorDeclaration(ast, context);
+                    return;
+
+                case 139 /* GetAccessor */:
+                case 140 /* SetAccessor */:
+                    this.typeCheckAccessorDeclaration(ast, context);
+                    return;
+
+                case 135 /* MemberFunctionDeclaration */:
+                    this.typeCheckMemberFunctionDeclaration(ast, context);
+                    return;
+
+                case 145 /* MethodSignature */:
+                    this.typeCheckMethodSignature(ast, context);
+                    return;
+
+                case 144 /* IndexSignature */:
+                    this.typeCheckIndexSignature(ast, context);
+                    break;
+
+                case 142 /* CallSignature */:
+                    this.typeCheckCallSignature(ast, context);
+                    return;
+
+                case 143 /* ConstructSignature */:
+                    this.typeCheckConstructSignature(ast, context);
+                    return;
+
+                case 129 /* FunctionDeclaration */: {
+                    var funcDecl = ast;
+                    this.typeCheckAnyFunctionDeclaration(funcDecl, TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */), funcDecl.identifier, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.ASTHelpers.getType(funcDecl), funcDecl.block, context);
+                    return;
+                }
+
+                case 219 /* SimpleArrowFunctionExpression */:
+                    this.typeCheckSimpleArrowFunctionExpression(ast, isContextuallyTyped, context);
+                    return;
+
+                case 218 /* ParenthesizedArrowFunctionExpression */:
+                    this.typeCheckParenthesizedArrowFunctionExpression(ast, isContextuallyTyped, context);
+                    return;
+
+                case 214 /* ArrayLiteralExpression */:
+                    this.resolveArrayLiteralExpression(ast, isContextuallyTyped, context);
+                    return;
+
+                case 213 /* InvocationExpression */:
+                    this.typeCheckInvocationExpression(ast, context);
+                    return;
+
+                case 216 /* ObjectCreationExpression */:
+                    this.typeCheckObjectCreationExpression(ast, context);
+                    return;
+
+                case 150 /* ReturnStatement */:
+                    this.resolveReturnStatement(ast, context);
+                    return;
+
+                default:
+                    TypeScript.Debug.assert(false, "Failure nodeType: " + TypeScript.SyntaxKind[ast.kind()] + ". Implement typeCheck when symbol is set for the ast as part of resolution.");
+            }
+        };
+
+        PullTypeResolver.prototype.processPostTypeCheckWorkItems = function (context) {
+            while (this.postTypeCheckWorkitems.length) {
+                var ast = this.postTypeCheckWorkitems.pop();
+                this.postTypeCheck(ast, context);
+            }
+        };
+
+        PullTypeResolver.prototype.postTypeCheck = function (ast, context) {
+            var nodeType = ast.kind();
+
+            switch (nodeType) {
+                case 242 /* Parameter */:
+                case 225 /* VariableDeclarator */:
+                    this.postTypeCheckVariableDeclaratorOrParameter(ast, context);
+                    return;
+
+                case 131 /* ClassDeclaration */:
+                    this.postTypeCheckClassDeclaration(ast, context);
+                    return;
+
+                case 129 /* FunctionDeclaration */:
+                    this.postTypeCheckFunctionDeclaration(ast, context);
+                    return;
+
+                case 130 /* ModuleDeclaration */:
+                    this.postTypeCheckModuleDeclaration(ast, context);
+                    return;
+
+                case 132 /* EnumDeclaration */:
+                    this.postTypeCheckEnumDeclaration(ast, context);
+                    return;
+
+                case 133 /* ImportDeclaration */:
+                    this.postTypeCheckImportDeclaration(ast, context);
+                    return;
+
+                case 11 /* IdentifierName */:
+                    this.postTypeCheckNameExpression(ast, context);
+                    return;
+
+                default:
+                    TypeScript.Debug.assert(false, "Implement postTypeCheck clause to handle the postTypeCheck work, nodeType: " + TypeScript.SyntaxKind[ast.kind()]);
+            }
+        };
+
+        PullTypeResolver.prototype.resolveRegularExpressionLiteral = function () {
+            if (this.cachedRegExpInterfaceType()) {
+                return this.cachedRegExpInterfaceType();
+            } else {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+        };
+
+        PullTypeResolver.prototype.postTypeCheckNameExpression = function (nameAST, context) {
+            this.checkThisCaptureVariableCollides(nameAST, false, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckNameExpression = function (nameAST, context) {
+            this.setTypeChecked(nameAST, context);
+            this.checkNameForCompilerGeneratedDeclarationCollision(nameAST, false, nameAST, context);
+        };
+
+        PullTypeResolver.prototype.resolveNameExpression = function (nameAST, context) {
+            var nameSymbol = this.getSymbolForAST(nameAST, context);
+            var foundCached = nameSymbol !== null;
+
+            if (!foundCached || this.canTypeCheckAST(nameAST, context)) {
+                if (this.canTypeCheckAST(nameAST, context)) {
+                    this.typeCheckNameExpression(nameAST, context);
+                }
+                nameSymbol = this.computeNameExpression(nameAST, context);
+            }
+
+            this.resolveDeclaredSymbol(nameSymbol, context);
+
+            if (nameSymbol && (nameSymbol.type !== this.semanticInfoChain.anyTypeSymbol || nameSymbol.anyDeclHasFlag(16777216 /* IsAnnotatedWithAny */ | 1 /* Exported */))) {
+                this.setSymbolForAST(nameAST, nameSymbol, context);
+            }
+
+            return nameSymbol;
+        };
+
+        PullTypeResolver.prototype.isInEnumDecl = function (decl) {
+            if (decl.kind & 64 /* Enum */) {
+                return true;
+            }
+
+            var declPath = decl.getParentPath();
+
+            var disallowedKinds = 164 /* SomeContainer */ | 58728795 /* SomeType */;
+            for (var i = declPath.length - 1; i >= 0; i--) {
+                var decl = declPath[i];
+
+                if (decl.kind & 64 /* Enum */) {
+                    return true;
+                }
+
+                if (decl.kind & disallowedKinds) {
+                    return false;
+                }
+            }
+            return false;
+        };
+
+        PullTypeResolver.prototype.getSomeInnermostFunctionScopeDecl = function (declPath) {
+            for (var i = declPath.length - 1; i >= 0; i--) {
+                var decl = declPath[i];
+                if (decl.kind & 1032192 /* SomeFunction */) {
+                    return decl;
+                }
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.isFromFunctionScope = function (nameSymbol, functionScopeDecl) {
+            var _this = this;
+            return TypeScript.ArrayUtilities.any(nameSymbol.getDeclarations(), function (nameSymbolDecl) {
+                return _this.getSomeInnermostFunctionScopeDecl(nameSymbolDecl.getParentPath()) === functionScopeDecl;
+            });
+        };
+
+        PullTypeResolver.prototype.findConstructorDeclOfEnclosingType = function (decl) {
+            var current = decl;
+            while (current) {
+                if (TypeScript.hasFlag(current.kind, 4096 /* Property */)) {
+                    var parentDecl = current.getParentDecl();
+                    if (TypeScript.hasFlag(parentDecl.kind, 8 /* Class */)) {
+                        return TypeScript.ArrayUtilities.lastOrDefault(parentDecl.getChildDecls(), function (decl) {
+                            return TypeScript.hasFlag(decl.kind, 32768 /* ConstructorMethod */);
+                        });
+                    }
+                }
+
+                if (TypeScript.hasFlag(current.kind, 164 /* SomeContainer */)) {
+                    return null;
+                }
+
+                current = current.getParentDecl();
+            }
+            return null;
+        };
+
+        PullTypeResolver.prototype.checkNameAsPartOfInitializerExpressionForInstanceMemberVariable = function (nameAST, nameSymbol, context) {
+            var id = nameAST.valueText();
+            if (id.length === 0) {
+                return false;
+            }
+
+            var memberVariableDeclarationAST = TypeScript.ASTHelpers.getEnclosingMemberVariableDeclaration(nameAST);
+            if (memberVariableDeclarationAST) {
+                var memberVariableDecl = this.semanticInfoChain.getDeclForAST(memberVariableDeclarationAST);
+                if (!TypeScript.hasFlag(memberVariableDecl.flags, 16 /* Static */)) {
+                    var constructorDecl = this.findConstructorDeclOfEnclosingType(memberVariableDecl);
+
+                    if (constructorDecl) {
+                        var childDecls = constructorDecl.searchChildDecls(id, 68147712 /* SomeValue */);
+                        if (childDecls.length) {
+                            if (TypeScript.PullHelpers.isSymbolDeclaredInScopeChain(nameSymbol, constructorDecl.getSymbol().getContainer())) {
+                                var memberVariableSymbol = memberVariableDecl.getSymbol();
+
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, [memberVariableSymbol.getScopedName(constructorDecl.getSymbol()), nameAST.text()]));
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+            return false;
+        };
+
+        PullTypeResolver.prototype.computeNameExpression = function (nameAST, context) {
+            var id = nameAST.valueText();
+            if (id.length === 0) {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var nameSymbol = null;
+            var enclosingDecl = this.getEnclosingDeclForAST(nameAST);
+
+            if (TypeScript.hasFlag(enclosingDecl.flags, 8388608 /* PropertyParameter */)) {
+                var valueDecl = enclosingDecl.getValueDecl();
+                if (valueDecl && TypeScript.hasFlag(valueDecl.kind, 2048 /* Parameter */)) {
+                    enclosingDecl = valueDecl;
+                }
+            }
+
+            var isDeclarationASTOrDeclarationNameAST = TypeScript.ASTHelpers.isDeclarationASTOrDeclarationNameAST(nameAST);
+            if (isDeclarationASTOrDeclarationNameAST) {
+                nameSymbol = this.semanticInfoChain.getDeclForAST(nameAST.parent).getSymbol();
+            }
+
+            var declPath = enclosingDecl.getParentPath();
+
+            if (!nameSymbol) {
+                var searchKind = 68147712 /* SomeValue */;
+
+                if (!this.isInEnumDecl(enclosingDecl)) {
+                    searchKind = searchKind & ~(67108864 /* EnumMember */);
+                }
+
+                var nameSymbol = this.getSymbolFromDeclPath(id, declPath, searchKind);
+            }
+
+            if (id === "arguments") {
+                var functionScopeDecl = this.getSomeInnermostFunctionScopeDecl(declPath);
+                if (functionScopeDecl) {
+                    if (!nameSymbol || !this.isFromFunctionScope(nameSymbol, functionScopeDecl)) {
+                        nameSymbol = this.cachedFunctionArgumentsSymbol();
+                        this.resolveDeclaredSymbol(this.cachedIArgumentsInterfaceType(), context);
+                    }
+                }
+            }
+
+            var aliasSymbol = null;
+            if (nameSymbol && nameSymbol.isAlias() && !isDeclarationASTOrDeclarationNameAST) {
+                aliasSymbol = nameSymbol;
+                if (!this.inTypeQuery(nameAST)) {
+                    aliasSymbol.setIsUsedAsValue();
+                }
+
+                this.resolveDeclaredSymbol(nameSymbol, context);
+
+                this.resolveDeclaredSymbol(aliasSymbol.assignedValue(), context);
+                this.resolveDeclaredSymbol(aliasSymbol.assignedContainer(), context);
+
+                nameSymbol = aliasSymbol.getExportAssignedValueSymbol();
+                if (!nameSymbol) {
+                    aliasSymbol = null;
+                }
+            }
+
+            if (!nameSymbol) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Could_not_find_symbol_0, [nameAST.text()]));
+                return this.getNewErrorTypeSymbol(id);
+            } else if (this.checkNameAsPartOfInitializerExpressionForInstanceMemberVariable(nameAST, nameSymbol, context)) {
+                return this.getNewErrorTypeSymbol(id);
+            }
+
+            var nameDeclaration = nameSymbol.getDeclarations()[0];
+            var nameParentDecl = nameDeclaration.getParentDecl();
+            if (nameParentDecl && (nameParentDecl.kind & 1032192 /* SomeFunction */) && (nameParentDecl.flags & 33554432 /* HasDefaultArgs */)) {
+                var enclosingFunctionAST = this.semanticInfoChain.getASTForDecl(nameParentDecl);
+                var currentParameterIndex = this.getCurrentParameterIndexForFunction(nameAST, enclosingFunctionAST);
+
+                var parameterList = TypeScript.ASTHelpers.getParameterList(enclosingFunctionAST);
+
+                if (currentParameterIndex >= 0) {
+                    var matchingParameter;
+                    if (parameterList) {
+                        for (var i = 0; i <= currentParameterIndex; i++) {
+                            var candidateParameter = parameterList.parameters.nonSeparatorAt(i);
+                            if (candidateParameter && candidateParameter.identifier.valueText() === id) {
+                                matchingParameter = candidateParameter;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (!matchingParameter) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it, [parameterList.parameters.nonSeparatorAt(currentParameterIndex).identifier.text(), nameAST.text()]));
+                        return this.getNewErrorTypeSymbol(id);
+                    } else if (matchingParameter === TypeScript.ASTHelpers.getEnclosingParameterForInitializer(nameAST)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Parameter_0_cannot_be_referenced_in_its_initializer, [parameterList.parameters.nonSeparatorAt(currentParameterIndex).identifier.text()]));
+                        return this.getNewErrorTypeSymbol(id);
+                    }
+                }
+            }
+
+            if (aliasSymbol) {
+                this.semanticInfoChain.setAliasSymbolForAST(nameAST, aliasSymbol);
+            }
+
+            return nameSymbol;
+        };
+
+        PullTypeResolver.prototype.getCurrentParameterIndexForFunction = function (parameter, funcDecl) {
+            var parameterList = TypeScript.ASTHelpers.getParameterList(funcDecl);
+            if (parameterList) {
+                while (parameter && parameter.parent) {
+                    if (parameter.parent.parent === parameterList) {
+                        return parameterList.parameters.nonSeparatorIndexOf(parameter);
+                    }
+
+                    parameter = parameter.parent;
+                }
+            }
+
+            return -1;
+        };
+
+        PullTypeResolver.prototype.resolveMemberAccessExpression = function (dottedNameAST, context) {
+            return this.resolveDottedNameExpression(dottedNameAST, dottedNameAST.expression, dottedNameAST.name, context);
+        };
+
+        PullTypeResolver.prototype.resolveDottedNameExpression = function (dottedNameAST, expression, name, context) {
+            var symbol = this.getSymbolForAST(dottedNameAST, context);
+            var foundCached = symbol !== null;
+
+            if (!foundCached || this.canTypeCheckAST(dottedNameAST, context)) {
+                var canTypeCheckDottedNameAST = this.canTypeCheckAST(dottedNameAST, context);
+                if (canTypeCheckDottedNameAST) {
+                    this.setTypeChecked(dottedNameAST, context);
+                }
+
+                symbol = this.computeDottedNameExpression(expression, name, context, canTypeCheckDottedNameAST);
+            }
+
+            this.resolveDeclaredSymbol(symbol, context);
+
+            if (symbol && (symbol.type !== this.semanticInfoChain.anyTypeSymbol || symbol.anyDeclHasFlag(16777216 /* IsAnnotatedWithAny */ | 1 /* Exported */))) {
+                this.setSymbolForAST(dottedNameAST, symbol, context);
+                this.setSymbolForAST(name, symbol, context);
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.computeDottedNameExpression = function (expression, name, context, checkSuperPrivateAndStaticAccess) {
+            var rhsName = name.valueText();
+            if (rhsName.length === 0) {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var lhs = this.resolveAST(expression, false, context);
+            return this.computeDottedNameExpressionFromLHS(lhs, expression, name, context, checkSuperPrivateAndStaticAccess);
+        };
+
+        PullTypeResolver.prototype.computeDottedNameExpressionFromLHS = function (lhs, expression, name, context, checkSuperPrivateAndStaticAccess) {
+            var rhsName = name.valueText();
+            if (rhsName.length === 0) {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var lhsType = lhs.type;
+
+            if (lhs.isAlias()) {
+                var lhsAlias = lhs;
+                if (!this.inTypeQuery(expression)) {
+                    lhsAlias.setIsUsedAsValue();
+                }
+                lhsType = lhsAlias.getExportAssignedTypeSymbol();
+            }
+
+            if (lhsType.isAlias()) {
+                lhsType = lhsType.getExportAssignedTypeSymbol();
+            }
+
+            if (!lhsType) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode.Could_not_find_enclosing_symbol_for_dotted_name_0, [name.text()]));
+                return this.getNewErrorTypeSymbol();
+            }
+
+            if (!lhsType.isResolved) {
+                var potentiallySpecializedType = this.resolveDeclaredSymbol(lhsType, context);
+
+                if (potentiallySpecializedType !== lhsType) {
+                    if (!lhs.isType()) {
+                        context.setTypeInContext(lhs, potentiallySpecializedType);
+                    }
+
+                    lhsType = potentiallySpecializedType;
+                }
+            }
+
+            if (lhsType.isContainer() && !lhsType.isAlias() && !lhsType.isEnum()) {
+                var instanceSymbol = lhsType.getInstanceSymbol();
+
+                if (instanceSymbol) {
+                    lhsType = instanceSymbol.type;
+                }
+            }
+
+            var originalLhsTypeForErrorReporting = lhsType;
+
+            lhsType = this.getApparentType(lhsType).widenedType(this, expression, context);
+
+            if (this.isAnyOrEquivalent(lhsType)) {
+                return lhsType;
+            }
+
+            var nameSymbol = this._getNamedPropertySymbolOfAugmentedType(rhsName, lhsType);
+
+            if (!nameSymbol) {
+                if (lhsType.kind === 32 /* DynamicModule */) {
+                    var container = lhsType;
+                    var associatedInstance = container.getInstanceSymbol();
+
+                    if (associatedInstance) {
+                        var instanceType = associatedInstance.type;
+
+                        nameSymbol = this.getNamedPropertySymbol(rhsName, 68147712 /* SomeValue */, instanceType);
+                    }
+                } else {
+                    var associatedType = lhsType.getAssociatedContainerType();
+
+                    if (associatedType && !associatedType.isClass()) {
+                        nameSymbol = this.getNamedPropertySymbol(rhsName, 68147712 /* SomeValue */, associatedType);
+                    }
+                }
+
+                if (!nameSymbol) {
+                    var enclosingDecl = this.getEnclosingDeclForAST(expression);
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode.The_property_0_does_not_exist_on_value_of_type_1, [name.text(), originalLhsTypeForErrorReporting.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)]));
+                    return this.getNewErrorTypeSymbol(rhsName);
+                }
+            }
+
+            if (checkSuperPrivateAndStaticAccess) {
+                this.checkForSuperMemberAccess(expression, name, nameSymbol, context) || this.checkForPrivateMemberAccess(name, lhsType, nameSymbol, context);
+            }
+
+            return nameSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveTypeNameExpression = function (nameAST, context) {
+            var typeNameSymbol = this.getSymbolForAST(nameAST, context);
+
+            if (!typeNameSymbol || !typeNameSymbol.isType() || this.canTypeCheckAST(nameAST, context)) {
+                if (this.canTypeCheckAST(nameAST, context)) {
+                    this.setTypeChecked(nameAST, context);
+                }
+                typeNameSymbol = this.computeTypeNameExpression(nameAST, context);
+                this.setSymbolForAST(nameAST, typeNameSymbol, context);
+            }
+
+            this.resolveDeclaredSymbol(typeNameSymbol, context);
+
+            return typeNameSymbol;
+        };
+
+        PullTypeResolver.prototype.computeTypeNameExpression = function (nameAST, context) {
+            var id = nameAST.valueText();
+            if (id.length === 0) {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var enclosingDecl = this.getEnclosingDeclForAST(nameAST);
+
+            var declPath = enclosingDecl.getParentPath();
+
+            var onLeftOfDot = this.isLeftSideOfQualifiedName(nameAST);
+
+            var kindToCheckFirst = onLeftOfDot ? 164 /* SomeContainer */ : 58728795 /* SomeType */;
+            var kindToCheckSecond = onLeftOfDot ? 58728795 /* SomeType */ : 164 /* SomeContainer */;
+
+            var typeNameSymbol = this.getSymbolFromDeclPath(id, declPath, kindToCheckFirst);
+
+            if (!typeNameSymbol) {
+                typeNameSymbol = this.getSymbolFromDeclPath(id, declPath, kindToCheckSecond);
+            }
+
+            if (!typeNameSymbol) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Could_not_find_symbol_0, [nameAST.text()]));
+                return this.getNewErrorTypeSymbol(id);
+            }
+
+            var typeNameSymbolAlias = null;
+            if (typeNameSymbol.isAlias()) {
+                typeNameSymbolAlias = typeNameSymbol;
+                this.resolveDeclaredSymbol(typeNameSymbol, context);
+
+                var aliasedType = typeNameSymbolAlias.getExportAssignedTypeSymbol();
+
+                this.resolveDeclaredSymbol(aliasedType, context);
+            }
+
+            if (typeNameSymbol.isTypeParameter()) {
+                if (this.isInStaticMemberContext(enclosingDecl)) {
+                    var parentDecl = typeNameSymbol.getDeclarations()[0].getParentDecl();
+
+                    if (parentDecl.kind === 8 /* Class */) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Static_members_cannot_reference_class_type_parameters));
+                        return this.getNewErrorTypeSymbol();
+                    }
+                }
+            }
+
+            if (!typeNameSymbol.isGeneric() && (typeNameSymbol.isClass() || typeNameSymbol.isInterface())) {
+                typeNameSymbol = TypeScript.PullTypeReferenceSymbol.createTypeReference(typeNameSymbol);
+            }
+
+            return typeNameSymbol;
+        };
+
+        PullTypeResolver.prototype.isInStaticMemberContext = function (decl) {
+            while (decl) {
+                if (TypeScript.hasFlag(decl.kind, 1032192 /* SomeFunction */ | 4096 /* Property */) && TypeScript.hasFlag(decl.flags, 16 /* Static */)) {
+                    return true;
+                }
+
+                if (TypeScript.hasFlag(decl.kind, 164 /* SomeContainer */)) {
+                    return false;
+                }
+
+                decl = decl.getParentDecl();
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.isLeftSideOfQualifiedName = function (ast) {
+            return ast && ast.parent && ast.parent.kind() === 121 /* QualifiedName */ && ast.parent.left === ast;
+        };
+
+        PullTypeResolver.prototype.resolveGenericTypeReference = function (genericTypeAST, context) {
+            var _this = this;
+            var genericTypeSymbol = this.resolveAST(genericTypeAST.name, false, context).type;
+
+            if (genericTypeSymbol.isError()) {
+                return genericTypeSymbol;
+            }
+
+            if (!genericTypeSymbol.inResolution && !genericTypeSymbol.isResolved) {
+                this.resolveDeclaredSymbol(genericTypeSymbol, context);
+            }
+
+            if (genericTypeSymbol.isAlias()) {
+                if (this.inClassExtendsHeritageClause(genericTypeAST) && !this.inTypeArgumentList(genericTypeAST)) {
+                    genericTypeSymbol.setIsUsedAsValue();
+                }
+                genericTypeSymbol = genericTypeSymbol.getExportAssignedTypeSymbol();
+            }
+
+            var typeParameters = genericTypeSymbol.getTypeParameters();
+            if (typeParameters.length === 0) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(genericTypeAST, TypeScript.DiagnosticCode.Type_0_does_not_have_type_parameters, [genericTypeSymbol.toString()]));
+                return this.getNewErrorTypeSymbol();
+            }
+
+            var typeArgs = [];
+
+            if (genericTypeAST.typeArgumentList && genericTypeAST.typeArgumentList.typeArguments.nonSeparatorCount()) {
+                for (var i = 0; i < genericTypeAST.typeArgumentList.typeArguments.nonSeparatorCount(); i++) {
+                    typeArgs[i] = this.resolveTypeReference(genericTypeAST.typeArgumentList.typeArguments.nonSeparatorAt(i), context);
+
+                    if (typeArgs[i].isError()) {
+                        typeArgs[i] = this.semanticInfoChain.anyTypeSymbol;
+                    }
+                }
+            }
+
+            if (typeArgs.length && typeArgs.length !== typeParameters.length) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(genericTypeAST, TypeScript.DiagnosticCode.Generic_type_0_requires_1_type_argument_s, [genericTypeSymbol.toString(), genericTypeSymbol.getTypeParameters().length]));
+                return this.getNewErrorTypeSymbol();
+            }
+
+            if (!genericTypeSymbol.isResolved) {
+                var typeDecls = genericTypeSymbol.getDeclarations();
+                var childDecls = null;
+
+                for (var i = 0; i < typeDecls.length; i++) {
+                    childDecls = typeDecls[i].getChildDecls();
+
+                    for (var j = 0; j < childDecls.length; j++) {
+                        childDecls[j].ensureSymbolIsBound();
+                    }
+                }
+            }
+
+            var specializedSymbol = this.createInstantiatedType(genericTypeSymbol, typeArgs);
+
+            var upperBound = null;
+
+            typeParameters = specializedSymbol.getTypeParameters();
+
+            var typeConstraintSubstitutionMap = [];
+
+            var instantiatedSubstitutionMap = specializedSymbol.getTypeParameterArgumentMap();
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeConstraintSubstitutionMap[typeParameters[i].pullSymbolID] = typeParameters[i];
+            }
+
+            for (var id in instantiatedSubstitutionMap) {
+                typeConstraintSubstitutionMap[id] = instantiatedSubstitutionMap[id];
+            }
+
+            for (var iArg = 0; (iArg < typeArgs.length) && (iArg < typeParameters.length); iArg++) {
+                var typeArg = typeArgs[iArg];
+                var typeParameter = typeParameters[iArg];
+                var typeConstraint = typeParameter.getConstraint();
+
+                typeConstraintSubstitutionMap[typeParameter.pullSymbolID] = typeArg;
+
+                if (typeConstraint) {
+                    if (typeConstraint.isTypeParameter()) {
+                        for (var j = 0; j < typeParameters.length && j < typeArgs.length; j++) {
+                            if (typeParameters[j] === typeConstraint) {
+                                typeConstraint = typeArgs[j];
+                            }
+                        }
+                    } else if (typeConstraint.isGeneric()) {
+                        typeConstraint = this.instantiateType(typeConstraint, typeConstraintSubstitutionMap);
+                    }
+
+                    if (typeArg.isTypeParameter()) {
+                        upperBound = typeArg.getConstraint();
+
+                        if (upperBound) {
+                            typeArg = upperBound;
+                        }
+                    }
+
+                    if (typeArg.inResolution || (typeArg.isTypeReference() && typeArg.referencedTypeSymbol.inResolution)) {
+                        return specializedSymbol;
+                    }
+
+                    if (context.canTypeCheckAST(genericTypeAST)) {
+                        this.typeCheckCallBacks.push(function (context) {
+                            if (!_this.sourceIsAssignableToTarget(typeArg, typeConstraint, genericTypeAST, context)) {
+                                var enclosingSymbol = _this.getEnclosingSymbolForAST(genericTypeAST);
+                                context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(genericTypeAST, TypeScript.DiagnosticCode.Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2, [typeArg.toString(enclosingSymbol, true), typeConstraint.toString(enclosingSymbol, true), typeParameter.toString(enclosingSymbol, true)]));
+                            }
+                        });
+                    }
+                }
+            }
+
+            return specializedSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveQualifiedName = function (dottedNameAST, context) {
+            if (this.inTypeQuery(dottedNameAST)) {
+                return this.resolveDottedNameExpression(dottedNameAST, dottedNameAST.left, dottedNameAST.right, context).type;
+            }
+
+            var symbol = this.getSymbolForAST(dottedNameAST, context);
+            if (!symbol || this.canTypeCheckAST(dottedNameAST, context)) {
+                var canTypeCheck = this.canTypeCheckAST(dottedNameAST, context);
+                if (canTypeCheck) {
+                    this.setTypeChecked(dottedNameAST, context);
+                }
+
+                symbol = this.computeQualifiedName(dottedNameAST, context);
+                this.setSymbolForAST(dottedNameAST, symbol, context);
+            }
+
+            this.resolveDeclaredSymbol(symbol, context);
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.isLastNameOfModuleNameModuleReference = function (ast) {
+            return ast.kind() === 11 /* IdentifierName */ && ast.parent && ast.parent.kind() === 121 /* QualifiedName */ && ast.parent.right === ast && ast.parent.parent && ast.parent.parent.kind() === 246 /* ModuleNameModuleReference */;
+        };
+
+        PullTypeResolver.prototype.computeQualifiedName = function (dottedNameAST, context) {
+            var rhsName = dottedNameAST.right.valueText();
+            if (rhsName.length === 0) {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var enclosingDecl = this.getEnclosingDeclForAST(dottedNameAST);
+            var lhs = this.resolveAST(dottedNameAST.left, false, context);
+
+            var lhsType = lhs.isAlias() ? lhs.getExportAssignedContainerSymbol() : lhs.type;
+
+            if (this.inClassExtendsHeritageClause(dottedNameAST) && !this.inTypeArgumentList(dottedNameAST)) {
+                if (lhs.isAlias()) {
+                    lhs.setIsUsedAsValue();
+                }
+            }
+
+            if (!lhsType) {
+                return this.getNewErrorTypeSymbol();
+            }
+
+            if (this.isAnyOrEquivalent(lhsType)) {
+                return lhsType;
+            }
+
+            var onLeftOfDot = this.isLeftSideOfQualifiedName(dottedNameAST);
+            var isNameOfModule = dottedNameAST.parent.kind() === 130 /* ModuleDeclaration */ && dottedNameAST.parent.name === dottedNameAST;
+
+            var memberKind = (onLeftOfDot || isNameOfModule) ? 164 /* SomeContainer */ : 58728795 /* SomeType */;
+
+            var childTypeSymbol = this.getNamedPropertySymbol(rhsName, memberKind, lhsType);
+
+            if (!childTypeSymbol && !isNameOfModule && this.isLastNameOfModuleNameModuleReference(dottedNameAST.right)) {
+                childTypeSymbol = this.getNamedPropertySymbol(rhsName, 68147712 /* SomeValue */, lhsType);
+            }
+
+            if (!childTypeSymbol && lhsType.isContainer()) {
+                var exportedContainer = lhsType.getExportAssignedContainerSymbol();
+
+                if (exportedContainer) {
+                    childTypeSymbol = this.getNamedPropertySymbol(rhsName, memberKind, exportedContainer);
+                }
+            }
+
+            if (!childTypeSymbol && enclosingDecl) {
+                var parentDecl = enclosingDecl;
+
+                while (parentDecl) {
+                    if (parentDecl.kind & 164 /* SomeContainer */) {
+                        break;
+                    }
+
+                    parentDecl = parentDecl.getParentDecl();
+                }
+
+                if (parentDecl) {
+                    var enclosingSymbolType = parentDecl.getSymbol().type;
+
+                    if (enclosingSymbolType === lhsType) {
+                        childTypeSymbol = this.getNamedPropertySymbol(rhsName, memberKind, lhsType);
+                    }
+                }
+            }
+
+            if (!childTypeSymbol) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(dottedNameAST.right, TypeScript.DiagnosticCode.The_property_0_does_not_exist_on_value_of_type_1, [dottedNameAST.right.text(), lhsType.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)]));
+                return this.getNewErrorTypeSymbol(rhsName);
+            }
+
+            return childTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.shouldContextuallyTypeAnyFunctionExpression = function (functionExpressionAST, typeParameters, parameters, returnTypeAnnotation, context) {
+            if (typeParameters && typeParameters.typeParameters.nonSeparatorCount() > 0) {
+                return false;
+            }
+
+            if (returnTypeAnnotation) {
+                return false;
+            }
+
+            if (parameters) {
+                for (var i = 0, n = parameters.length; i < n; i++) {
+                    if (parameters.typeAt(i)) {
+                        return false;
+                    }
+                }
+            }
+
+            var contextualFunctionTypeSymbol = context.getContextualType();
+
+            if (contextualFunctionTypeSymbol) {
+                this.resolveDeclaredSymbol(contextualFunctionTypeSymbol, context);
+                var callSignatures = contextualFunctionTypeSymbol.getCallSignatures();
+                var exactlyOneCallSignature = callSignatures && callSignatures.length === 1;
+                if (!exactlyOneCallSignature) {
+                    return false;
+                }
+
+                var callSignatureIsGeneric = callSignatures[0].getTypeParameters().length > 0;
+                return !callSignatureIsGeneric;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.resolveAnyFunctionExpression = function (funcDeclAST, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, isContextuallyTyped, context) {
+            var funcDeclSymbol = null;
+            var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            TypeScript.Debug.assert(functionDecl);
+
+            if (functionDecl && functionDecl.hasSymbol()) {
+                funcDeclSymbol = functionDecl.getSymbol();
+                if (funcDeclSymbol.isResolved || funcDeclSymbol.inResolution) {
+                    return funcDeclSymbol;
+                }
+            }
+
+            funcDeclSymbol = functionDecl.getSymbol();
+            TypeScript.Debug.assert(funcDeclSymbol);
+
+            var funcDeclType = funcDeclSymbol.type;
+            var signature = funcDeclType.getCallSignatures()[0];
+            funcDeclSymbol.startResolving();
+
+            if (typeParameters) {
+                for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) {
+                    this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context);
+                }
+            }
+
+            var assigningFunctionSignature = null;
+            if (isContextuallyTyped && this.shouldContextuallyTypeAnyFunctionExpression(funcDeclAST, typeParameters, parameters, returnTypeAnnotation, context)) {
+                assigningFunctionSignature = context.getContextualType().getCallSignatures()[0];
+            }
+
+            this.resolveAnyFunctionExpressionParameters(funcDeclAST, typeParameters, parameters, returnTypeAnnotation, isContextuallyTyped, context);
+
+            if (returnTypeAnnotation) {
+                signature.returnType = this.resolveTypeReference(returnTypeAnnotation, context);
+            } else {
+                if (assigningFunctionSignature) {
+                    var returnType = assigningFunctionSignature.returnType;
+
+                    if (returnType) {
+                        context.propagateContextualType(returnType);
+                        this.resolveFunctionBodyReturnTypes(funcDeclAST, block, bodyExpression, signature, true, functionDecl, context);
+                        context.popAnyContextualType();
+                    } else {
+                        signature.returnType = this.semanticInfoChain.anyTypeSymbol;
+
+                        if (this.compilationSettings.noImplicitAny()) {
+                            var functionExpressionName = functionDecl.getFunctionExpressionName();
+
+                            if (functionExpressionName != "") {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type, [functionExpressionName]));
+                            } else {
+                                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_any_return_type));
+                            }
+                        }
+                    }
+                } else {
+                    this.resolveFunctionBodyReturnTypes(funcDeclAST, block, bodyExpression, signature, false, functionDecl, context);
+                }
+            }
+
+            context.setTypeInContext(funcDeclSymbol, funcDeclType);
+            funcDeclSymbol.setResolved();
+
+            if (this.canTypeCheckAST(funcDeclAST, context)) {
+                this.typeCheckAnyFunctionExpression(funcDeclAST, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, isContextuallyTyped, context);
+            }
+
+            return funcDeclSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveAnyFunctionExpressionParameters = function (funcDeclAST, typeParameters, parameters, returnTypeAnnotation, isContextuallyTyped, context) {
+            if (!parameters) {
+                return;
+            }
+
+            var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            var contextParams = [];
+
+            var assigningFunctionSignature = null;
+            if (isContextuallyTyped && this.shouldContextuallyTypeAnyFunctionExpression(funcDeclAST, typeParameters, parameters, returnTypeAnnotation, context)) {
+                assigningFunctionSignature = context.getContextualType().getCallSignatures()[0];
+            }
+
+            if (assigningFunctionSignature) {
+                contextParams = assigningFunctionSignature.parameters;
+            }
+
+            var contextualParametersCount = contextParams.length;
+            for (var i = 0, n = parameters.length; i < n; i++) {
+                var actualParameterIsVarArgParameter = (i === (n - 1)) && parameters.lastParameterIsRest();
+                var correspondingContextualParameter = null;
+                var contextualParameterType = null;
+
+                if (i < contextualParametersCount) {
+                    correspondingContextualParameter = contextParams[i];
+                } else if (contextualParametersCount && contextParams[contextualParametersCount - 1].isVarArg) {
+                    correspondingContextualParameter = contextParams[contextualParametersCount - 1];
+                }
+
+                if (correspondingContextualParameter) {
+                    if (correspondingContextualParameter.isVarArg === actualParameterIsVarArgParameter) {
+                        contextualParameterType = correspondingContextualParameter.type;
+                    } else if (correspondingContextualParameter.isVarArg) {
+                        contextualParameterType = correspondingContextualParameter.type.getElementType();
+                    }
+                }
+
+                this.resolveFunctionExpressionParameter(parameters.astAt(i), parameters.identifierAt(i), parameters.typeAt(i), parameters.initializerAt(i), contextualParameterType, functionDecl, context);
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckSimpleArrowFunctionExpression = function (arrowFunction, isContextuallyTyped, context) {
+            return this.typeCheckAnyFunctionExpression(arrowFunction, null, TypeScript.ASTHelpers.parametersFromIdentifier(arrowFunction.identifier), null, arrowFunction.block, arrowFunction.expression, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckParenthesizedArrowFunctionExpression = function (arrowFunction, isContextuallyTyped, context) {
+            return this.typeCheckAnyFunctionExpression(arrowFunction, arrowFunction.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(arrowFunction.callSignature.parameterList), TypeScript.ASTHelpers.getType(arrowFunction), arrowFunction.block, arrowFunction.expression, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckAnyFunctionExpression = function (funcDeclAST, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, isContextuallyTyped, context) {
+            var _this = this;
+            this.setTypeChecked(funcDeclAST, context);
+
+            var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+
+            var funcDeclSymbol = functionDecl.getSymbol();
+            var funcDeclType = funcDeclSymbol.type;
+            var signature = funcDeclType.getCallSignatures()[0];
+            var returnTypeSymbol = signature.returnType;
+
+            if (typeParameters) {
+                for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) {
+                    this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context);
+                }
+            }
+
+            this.resolveAnyFunctionExpressionParameters(funcDeclAST, typeParameters, parameters, returnTypeAnnotation, isContextuallyTyped, context);
+
+            context.pushNewContextualType(null);
+            if (block) {
+                this.resolveAST(block, false, context);
+            } else {
+                var bodyExpressionType = this.resolveReturnExpression(bodyExpression, functionDecl, context);
+                this.typeCheckReturnExpression(bodyExpression, bodyExpressionType, functionDecl, context);
+            }
+
+            context.popAnyContextualType();
+
+            this.checkThatNonVoidFunctionHasReturnExpressionOrThrowStatement(functionDecl, returnTypeAnnotation, returnTypeSymbol, block, context);
+
+            this.validateVariableDeclarationGroups(functionDecl, context);
+
+            this.typeCheckCallBacks.push(function (context) {
+                _this.typeCheckFunctionOverloads(funcDeclAST, context);
+            });
+        };
+
+        PullTypeResolver.prototype.resolveThisExpression = function (thisExpression, context) {
+            var enclosingDecl = this.getEnclosingDeclForAST(thisExpression);
+            var thisTypeSymbol = this.getContextualClassSymbolForEnclosingDecl(thisExpression, enclosingDecl) || this.semanticInfoChain.anyTypeSymbol;
+
+            if (this.canTypeCheckAST(thisExpression, context)) {
+                this.typeCheckThisExpression(thisExpression, context, enclosingDecl);
+            }
+
+            return thisTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.inTypeArgumentList = function (ast) {
+            var previous = null;
+            var current = ast;
+
+            while (current) {
+                switch (current.kind()) {
+                    case 126 /* GenericType */:
+                        var genericType = current;
+                        if (genericType.typeArgumentList === previous) {
+                            return true;
+                        }
+                        break;
+
+                    case 226 /* ArgumentList */:
+                        var argumentList = current;
+                        return argumentList.typeArgumentList === previous;
+                }
+
+                previous = current;
+                current = current.parent;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.inClassExtendsHeritageClause = function (ast) {
+            while (ast) {
+                switch (ast.kind()) {
+                    case 230 /* ExtendsHeritageClause */:
+                        var heritageClause = ast;
+
+                        return heritageClause.parent.parent.kind() === 131 /* ClassDeclaration */;
+
+                    case 137 /* ConstructorDeclaration */:
+                    case 131 /* ClassDeclaration */:
+                    case 130 /* ModuleDeclaration */:
+                        return false;
+                }
+
+                ast = ast.parent;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.inTypeQuery = function (ast) {
+            while (ast) {
+                switch (ast.kind()) {
+                    case 127 /* TypeQuery */:
+                        return true;
+                    case 129 /* FunctionDeclaration */:
+                    case 213 /* InvocationExpression */:
+                    case 137 /* ConstructorDeclaration */:
+                    case 131 /* ClassDeclaration */:
+                    case 130 /* ModuleDeclaration */:
+                        return false;
+                }
+
+                ast = ast.parent;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.inArgumentListOfSuperInvocation = function (ast) {
+            var previous = null;
+            var current = ast;
+            while (current) {
+                switch (current.kind()) {
+                    case 213 /* InvocationExpression */:
+                        var invocationExpression = current;
+                        if (previous === invocationExpression.argumentList && invocationExpression.expression.kind() === 50 /* SuperKeyword */) {
+                            return true;
+                        }
+                        break;
+
+                    case 137 /* ConstructorDeclaration */:
+                    case 131 /* ClassDeclaration */:
+                    case 130 /* ModuleDeclaration */:
+                        return false;
+                }
+
+                previous = current;
+                current = current.parent;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.inConstructorParameterList = function (ast) {
+            var previous = null;
+            var current = ast;
+            while (current) {
+                switch (current.kind()) {
+                    case 142 /* CallSignature */:
+                        var callSignature = current;
+                        if (previous === callSignature.parameterList && callSignature.parent.kind() === 137 /* ConstructorDeclaration */) {
+                            return true;
+                        }
+
+                    case 131 /* ClassDeclaration */:
+                    case 130 /* ModuleDeclaration */:
+                        return false;
+                }
+
+                previous = current;
+                current = current.parent;
+            }
+
+            return false;
+        };
+        PullTypeResolver.prototype.isFunctionAccessorOrNonArrowFunctionExpression = function (decl) {
+            if (decl.kind === 262144 /* GetAccessor */ || decl.kind === 524288 /* SetAccessor */) {
+                return true;
+            }
+
+            return this.isFunctionOrNonArrowFunctionExpression(decl);
+        };
+
+        PullTypeResolver.prototype.isFunctionOrNonArrowFunctionExpression = function (decl) {
+            if (decl.kind === 16384 /* Function */) {
+                return true;
+            } else if (decl.kind === 131072 /* FunctionExpression */ && !TypeScript.hasFlag(decl.flags, 8192 /* ArrowFunction */)) {
+                return true;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.typeCheckThisExpression = function (thisExpression, context, enclosingDecl) {
+            this.checkForThisCaptureInArrowFunction(thisExpression);
+
+            if (this.inConstructorParameterList(thisExpression)) {
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_in_constructor_arguments));
+                return;
+            }
+
+            for (var currentDecl = enclosingDecl; currentDecl !== null; currentDecl = currentDecl.getParentDecl()) {
+                if (this.isFunctionAccessorOrNonArrowFunctionExpression(currentDecl)) {
+                    return;
+                } else if (currentDecl.kind === 4 /* Container */ || currentDecl.kind === 32 /* DynamicModule */) {
+                    if (currentDecl.getParentDecl() === null) {
+                        return;
+                    } else {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_within_module_bodies));
+                        return;
+                    }
+                } else if (currentDecl.kind === 64 /* Enum */) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_in_current_location));
+                    return;
+                } else if (currentDecl.kind === 32768 /* ConstructorMethod */) {
+                    if (this.inArgumentListOfSuperInvocation(thisExpression) && this.superCallMustBeFirstStatementInConstructor(currentDecl)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_in_current_location));
+                    }
+
+                    return;
+                } else if (currentDecl.kind === 8 /* Class */) {
+                    if (this.inStaticMemberVariableDeclaration(thisExpression)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_in_static_initializers_in_a_class_body));
+                    }
+
+                    return;
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.getContextualClassSymbolForEnclosingDecl = function (ast, enclosingDecl) {
+            var declPath = enclosingDecl.getParentPath();
+
+            if (declPath.length) {
+                var isStaticContext = false;
+
+                for (var i = declPath.length - 1; i >= 0; i--) {
+                    var decl = declPath[i];
+                    var declKind = decl.kind;
+                    var declFlags = decl.flags;
+
+                    if (declFlags & 16 /* Static */) {
+                        isStaticContext = true;
+                    } else if (declKind === 131072 /* FunctionExpression */ && !TypeScript.hasFlag(declFlags, 8192 /* ArrowFunction */)) {
+                        return null;
+                    } else if (declKind === 16384 /* Function */) {
+                        return null;
+                    } else if (declKind === 8 /* Class */) {
+                        if (this.inStaticMemberVariableDeclaration(ast)) {
+                            return this.getNewErrorTypeSymbol();
+                        } else {
+                            var classSymbol = decl.getSymbol();
+                            if (isStaticContext) {
+                                var constructorSymbol = classSymbol.getConstructorMethod();
+                                return constructorSymbol.type;
+                            } else {
+                                return classSymbol;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.inStaticMemberVariableDeclaration = function (ast) {
+            while (ast) {
+                if (ast.kind() === 136 /* MemberVariableDeclaration */ && TypeScript.hasModifier(ast.modifiers, 16 /* Static */)) {
+                    return true;
+                }
+
+                ast = ast.parent;
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.resolveSuperExpression = function (ast, context) {
+            var enclosingDecl = this.getEnclosingDeclForAST(ast);
+            var superType = this.semanticInfoChain.anyTypeSymbol;
+
+            var classSymbol = this.getContextualClassSymbolForEnclosingDecl(ast, enclosingDecl);
+
+            if (classSymbol) {
+                this.resolveDeclaredSymbol(classSymbol, context);
+
+                var parents = classSymbol.getExtendedTypes();
+
+                if (parents.length) {
+                    superType = parents[0];
+                }
+            }
+
+            if (this.canTypeCheckAST(ast, context)) {
+                this.typeCheckSuperExpression(ast, context, enclosingDecl);
+            }
+
+            return superType;
+        };
+
+        PullTypeResolver.prototype.typeCheckSuperExpression = function (ast, context, enclosingDecl) {
+            this.setTypeChecked(ast, context);
+
+            this.checkForThisCaptureInArrowFunction(ast);
+
+            var isSuperCall = ast.parent.kind() === 213 /* InvocationExpression */;
+            var isSuperPropertyAccess = ast.parent.kind() === 212 /* MemberAccessExpression */;
+            TypeScript.Debug.assert(isSuperCall || isSuperPropertyAccess);
+
+            if (isSuperPropertyAccess) {
+                for (var currentDecl = enclosingDecl; currentDecl !== null; currentDecl = currentDecl.getParentDecl()) {
+                    if (this.isFunctionOrNonArrowFunctionExpression(currentDecl)) {
+                        break;
+                    } else if (currentDecl.kind === 8 /* Class */) {
+                        if (!this.enclosingClassIsDerived(currentDecl)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_non_derived_classes));
+                            return;
+                        } else if (this.inConstructorParameterList(ast)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_constructor_arguments));
+                            return;
+                        } else if (this.inStaticMemberVariableDeclaration(ast)) {
+                            break;
+                        }
+
+                        return;
+                    }
+                }
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class));
+                return;
+            } else {
+                if (enclosingDecl.kind === 32768 /* ConstructorMethod */) {
+                    var classDecl = enclosingDecl.getParentDecl();
+
+                    if (!this.enclosingClassIsDerived(classDecl)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_non_derived_classes));
+                        return;
+                    } else if (this.inConstructorParameterList(ast)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_constructor_arguments));
+                        return;
+                    }
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveSimplePropertyAssignment = function (propertyAssignment, isContextuallyTyped, context) {
+            return this.resolveAST(propertyAssignment.expression, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.resolveFunctionPropertyAssignment = function (funcProp, isContextuallyTyped, context) {
+            return this.resolveAnyFunctionExpression(funcProp, funcProp.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(funcProp.callSignature.parameterList), TypeScript.ASTHelpers.getType(funcProp), funcProp.block, null, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.typeCheckFunctionPropertyAssignment = function (funcProp, isContextuallyTyped, context) {
+            this.typeCheckAnyFunctionExpression(funcProp, funcProp.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(funcProp.callSignature.parameterList), TypeScript.ASTHelpers.getType(funcProp), funcProp.block, null, isContextuallyTyped, context);
+        };
+
+        PullTypeResolver.prototype.resolveObjectLiteralExpression = function (expressionAST, isContextuallyTyped, context, additionalResults) {
+            var symbol = this.getSymbolForAST(expressionAST, context);
+            var hasResolvedSymbol = symbol && symbol.isResolved;
+
+            if (!hasResolvedSymbol || additionalResults || this.canTypeCheckAST(expressionAST, context)) {
+                if (this.canTypeCheckAST(expressionAST, context)) {
+                    this.setTypeChecked(expressionAST, context);
+                }
+                symbol = this.computeObjectLiteralExpression(expressionAST, isContextuallyTyped, context, additionalResults);
+                this.setSymbolForAST(expressionAST, symbol, context);
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.bindObjectLiteralMembers = function (objectLiteralDeclaration, objectLiteralTypeSymbol, objectLiteralMembers, isUsingExistingSymbol, pullTypeContext) {
+            var boundMemberSymbols = [];
+            var memberSymbol;
+            for (var i = 0, len = objectLiteralMembers.nonSeparatorCount(); i < len; i++) {
+                var propertyAssignment = objectLiteralMembers.nonSeparatorAt(i);
+
+                var id = this.getPropertyAssignmentName(propertyAssignment);
+                var assignmentText = getPropertyAssignmentNameTextFromIdentifier(id);
+
+                var isAccessor = propertyAssignment.kind() === 139 /* GetAccessor */ || propertyAssignment.kind() === 140 /* SetAccessor */;
+                var decl = this.semanticInfoChain.getDeclForAST(propertyAssignment);
+                TypeScript.Debug.assert(decl);
+
+                if (propertyAssignment.kind() === 240 /* SimplePropertyAssignment */) {
+                    if (!isUsingExistingSymbol) {
+                        memberSymbol = new TypeScript.PullSymbol(assignmentText.memberName, 4096 /* Property */);
+                        memberSymbol.addDeclaration(decl);
+                        decl.setSymbol(memberSymbol);
+                    } else {
+                        memberSymbol = decl.getSymbol();
+                    }
+                } else if (propertyAssignment.kind() === 241 /* FunctionPropertyAssignment */) {
+                    memberSymbol = decl.getSymbol();
+                } else {
+                    TypeScript.Debug.assert(isAccessor);
+                    memberSymbol = decl.getSymbol();
+                }
+
+                if (!isUsingExistingSymbol && !isAccessor) {
+                    var existingMember = objectLiteralTypeSymbol.findMember(memberSymbol.name, true);
+                    if (existingMember) {
+                        pullTypeContext.postDiagnostic(this.semanticInfoChain.duplicateIdentifierDiagnosticFromAST(propertyAssignment, assignmentText.actualText, existingMember.getDeclarations()[0].ast()));
+                    }
+
+                    objectLiteralTypeSymbol.addMember(memberSymbol);
+                }
+
+                boundMemberSymbols.push(memberSymbol);
+            }
+
+            return boundMemberSymbols;
+        };
+
+        PullTypeResolver.prototype.resolveObjectLiteralMembers = function (objectLiteralDeclaration, objectLiteralTypeSymbol, objectLiteralContextualType, objectLiteralMembers, stringIndexerSignature, numericIndexerSignature, allMemberTypes, allNumericMemberTypes, boundMemberSymbols, isUsingExistingSymbol, pullTypeContext, additionalResults) {
+            for (var i = 0, len = objectLiteralMembers.nonSeparatorCount(); i < len; i++) {
+                var propertyAssignment = objectLiteralMembers.nonSeparatorAt(i);
+
+                var acceptedContextualType = false;
+                var assigningSymbol = null;
+
+                var id = this.getPropertyAssignmentName(propertyAssignment);
+                var memberSymbol = boundMemberSymbols[i];
+                var contextualMemberType = null;
+
+                if (objectLiteralContextualType) {
+                    assigningSymbol = this.getNamedPropertySymbol(memberSymbol.name, 68147712 /* SomeValue */, objectLiteralContextualType);
+
+                    if (!assigningSymbol) {
+                        if (numericIndexerSignature && TypeScript.PullHelpers.isNameNumeric(memberSymbol.name)) {
+                            assigningSymbol = numericIndexerSignature;
+                        } else if (stringIndexerSignature) {
+                            assigningSymbol = stringIndexerSignature;
+                        }
+                    }
+
+                    if (assigningSymbol) {
+                        this.resolveDeclaredSymbol(assigningSymbol, pullTypeContext);
+
+                        contextualMemberType = assigningSymbol.kind === 4194304 /* IndexSignature */ ? assigningSymbol.returnType : assigningSymbol.type;
+                        pullTypeContext.propagateContextualType(contextualMemberType);
+
+                        acceptedContextualType = true;
+
+                        if (additionalResults) {
+                            additionalResults.membersContextTypeSymbols[i] = contextualMemberType;
+                        }
+                    }
+                }
+
+                var memberSymbolType = this.resolveAST(propertyAssignment, contextualMemberType !== null, pullTypeContext).type;
+
+                if (memberSymbolType) {
+                    if (memberSymbolType.isGeneric()) {
+                        objectLiteralTypeSymbol.setHasGenericMember();
+                    }
+
+                    if (stringIndexerSignature) {
+                        allMemberTypes.push(memberSymbolType);
+                    }
+                    if (numericIndexerSignature && TypeScript.PullHelpers.isNameNumeric(memberSymbol.name)) {
+                        allNumericMemberTypes.push(memberSymbolType);
+                    }
+                }
+
+                if (acceptedContextualType) {
+                    pullTypeContext.popAnyContextualType();
+                }
+
+                var isAccessor = propertyAssignment.kind() === 140 /* SetAccessor */ || propertyAssignment.kind() === 139 /* GetAccessor */;
+                if (!memberSymbol.isResolved) {
+                    if (isAccessor) {
+                        this.setSymbolForAST(id, memberSymbolType, pullTypeContext);
+                    } else {
+                        pullTypeContext.setTypeInContext(memberSymbol, memberSymbolType);
+                        memberSymbol.setResolved();
+
+                        this.setSymbolForAST(id, memberSymbol, pullTypeContext);
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.computeObjectLiteralExpression = function (objectLitAST, isContextuallyTyped, context, additionalResults) {
+            var objectLitDecl = this.semanticInfoChain.getDeclForAST(objectLitAST);
+            TypeScript.Debug.assert(objectLitDecl);
+
+            var typeSymbol = this.getSymbolForAST(objectLitAST, context);
+            var isUsingExistingSymbol = !!typeSymbol;
+
+            if (!typeSymbol) {
+                typeSymbol = new TypeScript.PullTypeSymbol("", 256 /* ObjectLiteral */);
+                typeSymbol.addDeclaration(objectLitDecl);
+                this.setSymbolForAST(objectLitAST, typeSymbol, context);
+                objectLitDecl.setSymbol(typeSymbol);
+            }
+
+            var propertyAssignments = objectLitAST.propertyAssignments;
+            var contextualType = null;
+
+            if (isContextuallyTyped) {
+                contextualType = context.getContextualType();
+                this.resolveDeclaredSymbol(contextualType, context);
+            }
+
+            var stringIndexerSignature = null;
+            var numericIndexerSignature = null;
+            var allMemberTypes = null;
+            var allNumericMemberTypes = null;
+
+            if (contextualType) {
+                var indexSignatures = this.getBothKindsOfIndexSignaturesExcludingAugmentedType(contextualType, context);
+
+                stringIndexerSignature = indexSignatures.stringSignature;
+                numericIndexerSignature = indexSignatures.numericSignature;
+
+                var inInferentialTyping = context.isInferentiallyTyping();
+                if (stringIndexerSignature) {
+                    allMemberTypes = inInferentialTyping ? [] : [stringIndexerSignature.returnType];
+                }
+
+                if (numericIndexerSignature) {
+                    allNumericMemberTypes = inInferentialTyping ? [] : [numericIndexerSignature.returnType];
+                }
+            }
+
+            if (propertyAssignments) {
+                if (additionalResults) {
+                    additionalResults.membersContextTypeSymbols = [];
+                }
+
+                var boundMemberSymbols = this.bindObjectLiteralMembers(objectLitDecl, typeSymbol, propertyAssignments, isUsingExistingSymbol, context);
+
+                this.resolveObjectLiteralMembers(objectLitDecl, typeSymbol, contextualType, propertyAssignments, stringIndexerSignature, numericIndexerSignature, allMemberTypes, allNumericMemberTypes, boundMemberSymbols, isUsingExistingSymbol, context, additionalResults);
+
+                if (!isUsingExistingSymbol) {
+                    this.stampObjectLiteralWithIndexSignature(typeSymbol, allMemberTypes, stringIndexerSignature, context);
+                    this.stampObjectLiteralWithIndexSignature(typeSymbol, allNumericMemberTypes, numericIndexerSignature, context);
+                }
+            }
+
+            typeSymbol.setResolved();
+            return typeSymbol;
+        };
+
+        PullTypeResolver.prototype.getPropertyAssignmentName = function (propertyAssignment) {
+            if (propertyAssignment.kind() === 240 /* SimplePropertyAssignment */) {
+                return propertyAssignment.propertyName;
+            } else if (propertyAssignment.kind() === 241 /* FunctionPropertyAssignment */) {
+                return propertyAssignment.propertyName;
+            } else if (propertyAssignment.kind() === 139 /* GetAccessor */) {
+                return propertyAssignment.propertyName;
+            } else if (propertyAssignment.kind() === 140 /* SetAccessor */) {
+                return propertyAssignment.propertyName;
+            } else {
+                TypeScript.Debug.assert(false);
+            }
+        };
+
+        PullTypeResolver.prototype.stampObjectLiteralWithIndexSignature = function (objectLiteralSymbol, indexerTypeCandidates, contextualIndexSignature, context) {
+            if (contextualIndexSignature) {
+                var typeCollection = {
+                    getLength: function () {
+                        return indexerTypeCandidates.length;
+                    },
+                    getTypeAtIndex: function (index) {
+                        return indexerTypeCandidates[index];
+                    }
+                };
+                var decl = objectLiteralSymbol.getDeclarations()[0];
+                var indexerReturnType = this.findBestCommonType(typeCollection, context).widenedType(this, null, context);
+                if (indexerReturnType === contextualIndexSignature.returnType) {
+                    objectLiteralSymbol.addIndexSignature(contextualIndexSignature);
+                } else {
+                    this.semanticInfoChain.addSyntheticIndexSignature(decl, objectLiteralSymbol, this.getASTForDecl(decl), contextualIndexSignature.parameters[0].name, contextualIndexSignature.parameters[0].type, indexerReturnType);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveArrayLiteralExpression = function (arrayLit, isContextuallyTyped, context) {
+            var symbol = this.getSymbolForAST(arrayLit, context);
+            if (!symbol || this.canTypeCheckAST(arrayLit, context)) {
+                if (this.canTypeCheckAST(arrayLit, context)) {
+                    this.setTypeChecked(arrayLit, context);
+                }
+                symbol = this.computeArrayLiteralExpressionSymbol(arrayLit, isContextuallyTyped, context);
+                this.setSymbolForAST(arrayLit, symbol, context);
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.computeArrayLiteralExpressionSymbol = function (arrayLit, isContextuallyTyped, context) {
+            var elements = arrayLit.expressions;
+            var elementType = null;
+            var elementTypes = [];
+            var comparisonInfo = new TypeComparisonInfo();
+            var contextualElementType = null;
+            comparisonInfo.onlyCaptureFirstError = true;
+
+            if (isContextuallyTyped) {
+                var contextualType = context.getContextualType();
+
+                this.resolveDeclaredSymbol(contextualType, context);
+
+                if (contextualType) {
+                    var indexSignatures = this.getBothKindsOfIndexSignaturesExcludingAugmentedType(contextualType, context);
+                    if (indexSignatures.numericSignature) {
+                        contextualElementType = indexSignatures.numericSignature.returnType;
+                    }
+                }
+            }
+
+            if (elements) {
+                if (contextualElementType) {
+                    context.propagateContextualType(contextualElementType);
+                }
+
+                for (var i = 0, n = elements.nonSeparatorCount(); i < n; i++) {
+                    elementTypes.push(this.resolveAST(elements.nonSeparatorAt(i), contextualElementType !== null, context).type);
+                }
+
+                if (contextualElementType) {
+                    context.popAnyContextualType();
+                }
+            }
+
+            if (elementTypes.length) {
+                elementType = elementTypes[0];
+            }
+            var collection;
+
+            if (contextualElementType && !context.isInferentiallyTyping()) {
+                if (!elementType) {
+                    elementType = contextualElementType;
+                }
+
+                collection = {
+                    getLength: function () {
+                        return elements.nonSeparatorCount() + 1;
+                    },
+                    getTypeAtIndex: function (index) {
+                        return index === 0 ? contextualElementType : elementTypes[index - 1];
+                    }
+                };
+            } else {
+                collection = {
+                    getLength: function () {
+                        return elements.nonSeparatorCount();
+                    },
+                    getTypeAtIndex: function (index) {
+                        return elementTypes[index];
+                    }
+                };
+            }
+
+            elementType = elementType ? this.findBestCommonType(collection, context, comparisonInfo) : elementType;
+
+            if (!elementType) {
+                elementType = this.semanticInfoChain.undefinedTypeSymbol;
+            }
+
+            return this.getArrayType(elementType);
+        };
+
+        PullTypeResolver.prototype.resolveElementAccessExpression = function (callEx, context) {
+            var symbolAndDiagnostic = this.computeElementAccessExpressionSymbolAndDiagnostic(callEx, context);
+
+            if (this.canTypeCheckAST(callEx, context)) {
+                this.typeCheckElementAccessExpression(callEx, context, symbolAndDiagnostic);
+            }
+
+            return symbolAndDiagnostic.symbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckElementAccessExpression = function (callEx, context, symbolAndDiagnostic) {
+            this.setTypeChecked(callEx, context);
+            context.postDiagnostic(symbolAndDiagnostic.diagnostic);
+        };
+
+        PullTypeResolver.prototype.computeElementAccessExpressionSymbolAndDiagnostic = function (callEx, context) {
+            var targetSymbol = this.resolveAST(callEx.expression, false, context);
+            var indexType = this.resolveAST(callEx.argumentExpression, false, context).type;
+
+            var targetTypeSymbol = targetSymbol.type;
+
+            targetTypeSymbol = this.getApparentType(targetTypeSymbol);
+
+            if (this.isAnyOrEquivalent(targetTypeSymbol)) {
+                return { symbol: targetTypeSymbol };
+            }
+
+            var elementType = targetTypeSymbol.getElementType();
+
+            var isNumberIndex = indexType === this.semanticInfoChain.numberTypeSymbol || TypeScript.PullHelpers.symbolIsEnum(indexType);
+
+            if (elementType && isNumberIndex) {
+                return { symbol: elementType };
+            }
+
+            if (callEx.argumentExpression.kind() === 14 /* StringLiteral */ || callEx.argumentExpression.kind() === 13 /* NumericLiteral */) {
+                var memberName = callEx.argumentExpression.kind() === 14 /* StringLiteral */ ? TypeScript.stripStartAndEndQuotes(callEx.argumentExpression.text()) : callEx.argumentExpression.valueText();
+
+                var member = this._getNamedPropertySymbolOfAugmentedType(memberName, targetTypeSymbol);
+
+                if (member) {
+                    this.resolveDeclaredSymbol(member, context);
+
+                    return { symbol: member.type };
+                }
+            }
+
+            var signatures = this.getBothKindsOfIndexSignaturesIncludingAugmentedType(targetTypeSymbol, context);
+
+            var stringSignature = signatures.stringSignature;
+            var numberSignature = signatures.numericSignature;
+
+            if (numberSignature && (isNumberIndex || indexType === this.semanticInfoChain.anyTypeSymbol)) {
+                return { symbol: numberSignature.returnType || this.semanticInfoChain.anyTypeSymbol };
+            } else if (stringSignature && (isNumberIndex || indexType === this.semanticInfoChain.anyTypeSymbol || indexType === this.semanticInfoChain.stringTypeSymbol)) {
+                return { symbol: stringSignature.returnType || this.semanticInfoChain.anyTypeSymbol };
+            } else if (isNumberIndex || indexType === this.semanticInfoChain.anyTypeSymbol || indexType === this.semanticInfoChain.stringTypeSymbol) {
+                if (this.compilationSettings.noImplicitAny()) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(callEx.argumentExpression, TypeScript.DiagnosticCode.Index_signature_of_object_type_implicitly_has_an_any_type));
+                }
+                return { symbol: this.semanticInfoChain.anyTypeSymbol };
+            } else {
+                return {
+                    symbol: this.getNewErrorTypeSymbol(),
+                    diagnostic: this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.Value_of_type_0_is_not_indexable_by_type_1, [targetTypeSymbol.toString(), indexType.toString()])
+                };
+            }
+        };
+
+        PullTypeResolver.prototype.getBothKindsOfIndexSignaturesIncludingAugmentedType = function (enclosingType, context) {
+            return this._getBothKindsOfIndexSignatures(enclosingType, context, true);
+        };
+
+        PullTypeResolver.prototype.getBothKindsOfIndexSignaturesExcludingAugmentedType = function (enclosingType, context) {
+            return this._getBothKindsOfIndexSignatures(enclosingType, context, false);
+        };
+
+        PullTypeResolver.prototype._getBothKindsOfIndexSignatures = function (enclosingType, context, includeAugmentedType) {
+            var signatures = includeAugmentedType ? enclosingType.getIndexSignaturesOfAugmentedType(this, this.cachedFunctionInterfaceType(), this.cachedObjectInterfaceType()) : enclosingType.getIndexSignatures();
+
+            var stringSignature = null;
+            var numberSignature = null;
+            var signature = null;
+            var paramSymbols;
+            var paramType;
+
+            for (var i = 0; i < signatures.length; i++) {
+                if (stringSignature && numberSignature) {
+                    break;
+                }
+
+                signature = signatures[i];
+                if (!signature.isResolved) {
+                    this.resolveDeclaredSymbol(signature, context);
+                }
+
+                paramSymbols = signature.parameters;
+
+                if (paramSymbols.length) {
+                    paramType = paramSymbols[0].type;
+
+                    if (!stringSignature && paramType === this.semanticInfoChain.stringTypeSymbol) {
+                        stringSignature = signature;
+                        continue;
+                    } else if (!numberSignature && paramType === this.semanticInfoChain.numberTypeSymbol) {
+                        numberSignature = signature;
+                        continue;
+                    }
+                }
+            }
+
+            return {
+                numericSignature: numberSignature,
+                stringSignature: stringSignature
+            };
+        };
+
+        PullTypeResolver.prototype._addUnhiddenSignaturesFromBaseType = function (derivedTypeSignatures, baseTypeSignatures, signaturesBeingAggregated) {
+            var _this = this;
+            if (!derivedTypeSignatures) {
+                signaturesBeingAggregated.push.apply(signaturesBeingAggregated, baseTypeSignatures);
+                return;
+            }
+
+            var context = new TypeScript.PullTypeResolutionContext(this);
+            for (var i = 0; i < baseTypeSignatures.length; i++) {
+                var baseSignature = baseTypeSignatures[i];
+
+                var signatureIsHidden = TypeScript.ArrayUtilities.any(derivedTypeSignatures, function (sig) {
+                    return _this.signaturesAreIdenticalWithNewEnclosingTypes(baseSignature, sig, context, false);
+                });
+
+                if (!signatureIsHidden) {
+                    signaturesBeingAggregated.push(baseSignature);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveBinaryAdditionOperation = function (binaryExpression, context) {
+            var lhsExpression = this.resolveAST(binaryExpression.left, false, context);
+            var lhsType = lhsExpression.type;
+            var rhsType = this.resolveAST(binaryExpression.right, false, context).type;
+
+            if (TypeScript.PullHelpers.symbolIsEnum(lhsType)) {
+                lhsType = this.semanticInfoChain.numberTypeSymbol;
+            }
+
+            if (TypeScript.PullHelpers.symbolIsEnum(rhsType)) {
+                rhsType = this.semanticInfoChain.numberTypeSymbol;
+            }
+
+            var isLhsTypeNullOrUndefined = lhsType === this.semanticInfoChain.nullTypeSymbol || lhsType === this.semanticInfoChain.undefinedTypeSymbol;
+            var isRhsTypeNullOrUndefined = rhsType === this.semanticInfoChain.nullTypeSymbol || rhsType === this.semanticInfoChain.undefinedTypeSymbol;
+
+            if (isLhsTypeNullOrUndefined) {
+                if (isRhsTypeNullOrUndefined) {
+                    lhsType = rhsType = this.semanticInfoChain.anyTypeSymbol;
+                } else {
+                    lhsType = rhsType;
+                }
+            } else if (isRhsTypeNullOrUndefined) {
+                rhsType = lhsType;
+            }
+
+            var exprType = null;
+
+            if (lhsType === this.semanticInfoChain.stringTypeSymbol || rhsType === this.semanticInfoChain.stringTypeSymbol) {
+                exprType = this.semanticInfoChain.stringTypeSymbol;
+            } else if (this.isAnyOrEquivalent(lhsType) || this.isAnyOrEquivalent(rhsType)) {
+                exprType = this.semanticInfoChain.anyTypeSymbol;
+            } else if (rhsType === this.semanticInfoChain.numberTypeSymbol && lhsType === this.semanticInfoChain.numberTypeSymbol) {
+                exprType = this.semanticInfoChain.numberTypeSymbol;
+            }
+
+            if (this.canTypeCheckAST(binaryExpression, context)) {
+                this.setTypeChecked(binaryExpression, context);
+
+                if (exprType) {
+                    if (binaryExpression.kind() === 175 /* AddAssignmentExpression */) {
+                        if (!this.isReference(binaryExpression.left, lhsExpression)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_left_hand_side_of_assignment_expression));
+                        }
+
+                        this.checkAssignability(binaryExpression.left, exprType, lhsType, context);
+                    }
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_expression_types_not_known_to_support_the_addition_operator));
+                }
+            }
+
+            if (!exprType) {
+                exprType = this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            return exprType;
+        };
+
+        PullTypeResolver.prototype.bestCommonTypeOfTwoTypes = function (type1, type2, context) {
+            return this.findBestCommonType({
+                getLength: function () {
+                    return 2;
+                },
+                getTypeAtIndex: function (index) {
+                    switch (index) {
+                        case 0:
+                            return type1;
+                        case 1:
+                            return type2;
+                    }
+                }
+            }, context);
+        };
+
+        PullTypeResolver.prototype.bestCommonTypeOfThreeTypes = function (type1, type2, type3, context) {
+            return this.findBestCommonType({
+                getLength: function () {
+                    return 3;
+                },
+                getTypeAtIndex: function (index) {
+                    switch (index) {
+                        case 0:
+                            return type1;
+                        case 1:
+                            return type2;
+                        case 2:
+                            return type3;
+                    }
+                }
+            }, context);
+        };
+
+        PullTypeResolver.prototype.resolveLogicalOrExpression = function (binex, isContextuallyTyped, context) {
+            if (this.canTypeCheckAST(binex, context)) {
+                this.setTypeChecked(binex, context);
+            }
+
+            if (isContextuallyTyped) {
+                var contextualType = context.getContextualType();
+                var leftType = this.resolveAST(binex.left, isContextuallyTyped, context).type;
+                var rightType = this.resolveAST(binex.right, isContextuallyTyped, context).type;
+
+                return context.isInferentiallyTyping() ? this.bestCommonTypeOfTwoTypes(leftType, rightType, context) : this.bestCommonTypeOfThreeTypes(contextualType, leftType, rightType, context);
+            } else {
+                var leftType = this.resolveAST(binex.left, false, context).type;
+
+                context.pushNewContextualType(leftType);
+                var rightType = this.resolveAST(binex.right, true, context).type;
+                context.popAnyContextualType();
+
+                return this.bestCommonTypeOfTwoTypes(leftType, rightType, context);
+            }
+        };
+
+        PullTypeResolver.prototype.resolveLogicalAndExpression = function (binex, context) {
+            if (this.canTypeCheckAST(binex, context)) {
+                this.setTypeChecked(binex, context);
+
+                this.resolveAST(binex.left, false, context);
+            }
+
+            return this.resolveAST(binex.right, false, context).type;
+        };
+
+        PullTypeResolver.prototype.computeTypeOfConditionalExpression = function (leftType, rightType, isContextuallyTyped, context) {
+            if (isContextuallyTyped && !context.isInferentiallyTyping()) {
+                var contextualType = context.getContextualType();
+                return this.bestCommonTypeOfThreeTypes(contextualType, leftType, rightType, context);
+            } else {
+                return this.bestCommonTypeOfTwoTypes(leftType, rightType, context);
+            }
+        };
+
+        PullTypeResolver.prototype.resolveConditionalExpression = function (trinex, isContextuallyTyped, context) {
+            var leftType = this.resolveAST(trinex.whenTrue, isContextuallyTyped, context).type;
+            var rightType = this.resolveAST(trinex.whenFalse, isContextuallyTyped, context).type;
+
+            var expressionType = this.computeTypeOfConditionalExpression(leftType, rightType, isContextuallyTyped, context);
+
+            var conditionalTypesAreValid = this.conditionExpressionTypesAreValid(leftType, rightType, expressionType, isContextuallyTyped, context);
+
+            if (this.canTypeCheckAST(trinex, context)) {
+                this.setTypeChecked(trinex, context);
+                this.resolveAST(trinex.condition, false, context);
+
+                if (!this.conditionExpressionTypesAreValid(leftType, rightType, expressionType, isContextuallyTyped, context)) {
+                    if (isContextuallyTyped) {
+                        var contextualType = context.getContextualType();
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(trinex, TypeScript.DiagnosticCode.Type_of_conditional_0_must_be_identical_to_1_2_or_3, [expressionType.toString(), leftType.toString(), rightType.toString(), contextualType.toString()]));
+                    } else {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(trinex, TypeScript.DiagnosticCode.Type_of_conditional_0_must_be_identical_to_1_or_2, [expressionType.toString(), leftType.toString(), rightType.toString()]));
+                    }
+                }
+            }
+
+            if (!conditionalTypesAreValid) {
+                return this.getNewErrorTypeSymbol();
+            }
+
+            return expressionType;
+        };
+
+        PullTypeResolver.prototype.conditionExpressionTypesAreValid = function (leftType, rightType, expressionType, isContextuallyTyped, context) {
+            if (isContextuallyTyped) {
+                var contextualType = context.getContextualType();
+                if (this.typesAreIdentical(expressionType, leftType, context) || this.typesAreIdentical(expressionType, rightType, context) || this.typesAreIdentical(expressionType, contextualType, context)) {
+                    return true;
+                }
+            } else {
+                if (this.typesAreIdentical(expressionType, leftType, context) || this.typesAreIdentical(expressionType, rightType, context)) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.resolveParenthesizedExpression = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+            }
+
+            return this.resolveAST(ast.expression, false, context);
+        };
+
+        PullTypeResolver.prototype.resolveExpressionStatement = function (ast, context) {
+            if (this.canTypeCheckAST(ast, context)) {
+                this.setTypeChecked(ast, context);
+
+                this.resolveAST(ast.expression, false, context);
+            }
+
+            return this.semanticInfoChain.voidTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.resolveInvocationExpression = function (callEx, context, additionalResults) {
+            var symbol = this.getSymbolForAST(callEx, context);
+
+            if (!symbol || !symbol.isResolved) {
+                if (!additionalResults) {
+                    additionalResults = new PullAdditionalCallResolutionData();
+                }
+                symbol = this.computeInvocationExpressionSymbol(callEx, context, additionalResults);
+                if (this.canTypeCheckAST(callEx, context)) {
+                    this.setTypeChecked(callEx, context);
+                }
+                if (symbol !== this.semanticInfoChain.anyTypeSymbol) {
+                    this.setSymbolForAST(callEx, symbol, context);
+                }
+                this.semanticInfoChain.setCallResolutionDataForAST(callEx, additionalResults);
+            } else {
+                if (this.canTypeCheckAST(callEx, context)) {
+                    this.typeCheckInvocationExpression(callEx, context);
+                }
+
+                var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx);
+                if (additionalResults && (callResolutionData !== additionalResults)) {
+                    additionalResults.actualParametersContextTypeSymbols = callResolutionData.actualParametersContextTypeSymbols;
+                    additionalResults.candidateSignature = callResolutionData.candidateSignature;
+                    additionalResults.resolvedSignatures = callResolutionData.resolvedSignatures;
+                    additionalResults.targetSymbol = callResolutionData.targetSymbol;
+                }
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckInvocationExpression = function (callEx, context) {
+            this.setTypeChecked(callEx, context);
+            var targetSymbol = this.resolveAST(callEx.expression, false, context);
+
+            if (callEx.argumentList.arguments) {
+                var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx);
+
+                var len = callEx.argumentList.arguments.nonSeparatorCount();
+                for (var i = 0; i < len; i++) {
+                    var contextualType = callResolutionData.actualParametersContextTypeSymbols ? callResolutionData.actualParametersContextTypeSymbols[i] : null;
+                    if (contextualType) {
+                        context.pushNewContextualType(contextualType);
+                    }
+
+                    this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType !== null, context);
+
+                    if (contextualType) {
+                        context.popAnyContextualType();
+                        contextualType = null;
+                    }
+                }
+            }
+
+            for (var i = 0; i < callResolutionData.diagnosticsFromOverloadResolution.length; i++) {
+                context.postDiagnostic(callResolutionData.diagnosticsFromOverloadResolution[i]);
+            }
+        };
+
+        PullTypeResolver.prototype.computeInvocationExpressionSymbol = function (callEx, context, additionalResults) {
+            var targetSymbol = this.resolveAST(callEx.expression, false, context);
+            var targetAST = this.getCallTargetErrorSpanAST(callEx);
+
+            var targetTypeSymbol = targetSymbol.type;
+            if (this.isAnyOrEquivalent(targetTypeSymbol)) {
+                this.resolveAST(callEx.argumentList.arguments, false, context);
+
+                if (callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()) {
+                    if (targetTypeSymbol === this.semanticInfoChain.anyTypeSymbol) {
+                        this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Untyped_function_calls_may_not_accept_type_arguments), additionalResults, context);
+                        return this.getNewErrorTypeSymbol();
+                    }
+                }
+
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            var isSuperCall = false;
+
+            if (callEx.expression.kind() === 50 /* SuperKeyword */) {
+                isSuperCall = true;
+
+                if (targetTypeSymbol.isClass()) {
+                    targetSymbol = targetTypeSymbol.getConstructorMethod();
+                    this.resolveDeclaredSymbol(targetSymbol, context);
+                    targetTypeSymbol = targetSymbol.type;
+                } else {
+                    this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Calls_to_super_are_only_valid_inside_a_class), additionalResults, context);
+                    this.resolveAST(callEx.argumentList.arguments, false, context);
+
+                    return this.getNewErrorTypeSymbol();
+                }
+            }
+
+            var signatures = isSuperCall ? targetTypeSymbol.getConstructSignatures() : targetTypeSymbol.getCallSignatures();
+
+            if (!signatures.length && (targetTypeSymbol.kind === 33554432 /* ConstructorType */)) {
+                this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, [targetTypeSymbol.toString()]), additionalResults, context);
+            }
+
+            var explicitTypeArgs = null;
+            var couldNotFindGenericOverload = false;
+            var couldNotAssignToConstraint;
+            var constraintDiagnostic = null;
+            var typeArgumentCountDiagnostic = null;
+            var diagnostics = [];
+
+            if (callEx.argumentList.typeArgumentList) {
+                explicitTypeArgs = [];
+
+                if (callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()) {
+                    for (var i = 0; i < callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount(); i++) {
+                        explicitTypeArgs[i] = this.resolveTypeReference(callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorAt(i), context);
+                    }
+                }
+            }
+
+            var triedToInferTypeArgs = false;
+
+            var resolvedSignatures = [];
+            var inferredOrExplicitTypeArgs;
+            var specializedSignature;
+            var typeParameters;
+            var typeConstraint = null;
+            var beforeResolutionSignatures = signatures;
+            var targetTypeReplacementMap = targetTypeSymbol.getTypeParameterArgumentMap();
+
+            for (var i = 0; i < signatures.length; i++) {
+                typeParameters = signatures[i].getTypeParameters();
+                couldNotAssignToConstraint = false;
+
+                if (signatures[i].isGeneric() && typeParameters.length) {
+                    if (isSuperCall && targetTypeSymbol.isGeneric() && !callEx.argumentList.typeArgumentList) {
+                        explicitTypeArgs = signatures[i].returnType.getTypeArguments();
+                    }
+
+                    if (explicitTypeArgs) {
+                        if (explicitTypeArgs.length === typeParameters.length) {
+                            inferredOrExplicitTypeArgs = explicitTypeArgs;
+                        } else {
+                            typeArgumentCountDiagnostic = typeArgumentCountDiagnostic || this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Signature_expected_0_type_arguments_got_1_instead, [typeParameters.length, explicitTypeArgs.length]);
+                            continue;
+                        }
+                    } else {
+                        TypeScript.Debug.assert(callEx.argumentList);
+                        var typeArgumentInferenceContext = new TypeScript.InvocationTypeArgumentInferenceContext(this, context, signatures[i], callEx.argumentList.arguments);
+                        inferredOrExplicitTypeArgs = this.inferArgumentTypesForSignature(typeArgumentInferenceContext, new TypeComparisonInfo(), context);
+                        triedToInferTypeArgs = true;
+                    }
+
+                    TypeScript.Debug.assert(inferredOrExplicitTypeArgs && inferredOrExplicitTypeArgs.length == typeParameters.length);
+
+                    var mutableTypeReplacementMap = new TypeScript.PullInstantiationHelpers.MutableTypeArgumentMap(targetTypeReplacementMap ? targetTypeReplacementMap : []);
+                    TypeScript.PullInstantiationHelpers.updateMutableTypeParameterArgumentMap(typeParameters, inferredOrExplicitTypeArgs, mutableTypeReplacementMap);
+                    var typeReplacementMap = mutableTypeReplacementMap.typeParameterArgumentMap;
+
+                    if (explicitTypeArgs) {
+                        for (var j = 0; j < typeParameters.length; j++) {
+                            typeConstraint = typeParameters[j].getConstraint();
+
+                            if (typeConstraint) {
+                                if (typeConstraint.isGeneric()) {
+                                    typeConstraint = this.instantiateType(typeConstraint, typeReplacementMap);
+                                }
+
+                                if (!this.sourceIsAssignableToTarget(inferredOrExplicitTypeArgs[j], typeConstraint, targetAST, context, null, true)) {
+                                    var enclosingSymbol = this.getEnclosingSymbolForAST(targetAST);
+                                    constraintDiagnostic = this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2, [inferredOrExplicitTypeArgs[j].toString(enclosingSymbol, true), typeConstraint.toString(enclosingSymbol, true), typeParameters[j].toString(enclosingSymbol, true)]);
+                                    couldNotAssignToConstraint = true;
+                                }
+
+                                if (couldNotAssignToConstraint) {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                    if (couldNotAssignToConstraint) {
+                        continue;
+                    }
+
+                    specializedSignature = this.instantiateSignature(signatures[i], typeReplacementMap);
+
+                    if (specializedSignature) {
+                        resolvedSignatures[resolvedSignatures.length] = specializedSignature;
+                    }
+                } else {
+                    if (!(callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount())) {
+                        resolvedSignatures[resolvedSignatures.length] = signatures[i];
+                    }
+                }
+            }
+
+            if (signatures.length && !resolvedSignatures.length) {
+                couldNotFindGenericOverload = true;
+            }
+
+            signatures = resolvedSignatures;
+
+            var errorCondition = null;
+            if (!signatures.length) {
+                additionalResults.targetSymbol = targetSymbol;
+                additionalResults.resolvedSignatures = beforeResolutionSignatures;
+                additionalResults.candidateSignature = beforeResolutionSignatures && beforeResolutionSignatures.length ? beforeResolutionSignatures[0] : null;
+
+                additionalResults.actualParametersContextTypeSymbols = actualParametersContextTypeSymbols;
+
+                this.resolveAST(callEx.argumentList.arguments, false, context);
+
+                if (!couldNotFindGenericOverload) {
+                    if (this.cachedFunctionInterfaceType() && this.sourceIsAssignableToTarget(targetTypeSymbol, this.cachedFunctionInterfaceType(), targetAST, context)) {
+                        if (callEx.argumentList.typeArgumentList) {
+                            this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Non_generic_functions_may_not_accept_type_arguments), additionalResults, context);
+                        }
+                        return this.semanticInfoChain.anyTypeSymbol;
+                    }
+
+                    this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature), additionalResults, context);
+                } else if (constraintDiagnostic) {
+                    this.postOverloadResolutionDiagnostics(constraintDiagnostic, additionalResults, context);
+                } else if (typeArgumentCountDiagnostic) {
+                    this.postOverloadResolutionDiagnostics(typeArgumentCountDiagnostic, additionalResults, context);
+                } else {
+                    this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.Could_not_select_overload_for_call_expression), additionalResults, context);
+                }
+
+                return this.getNewErrorTypeSymbol();
+            }
+
+            var signature = this.resolveOverloads(callEx, signatures, callEx.argumentList.typeArgumentList !== null, context, diagnostics);
+            var useBeforeResolutionSignatures = signature == null;
+
+            if (!signature) {
+                for (var i = 0; i < diagnostics.length; i++) {
+                    this.postOverloadResolutionDiagnostics(diagnostics[i], additionalResults, context);
+                }
+
+                this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Could_not_select_overload_for_call_expression), additionalResults, context);
+
+                errorCondition = this.getNewErrorTypeSymbol();
+
+                if (!signatures.length) {
+                    return errorCondition;
+                }
+
+                signature = signatures[0];
+            }
+
+            var rootSignature = signature.getRootSymbol();
+            if (!rootSignature.isGeneric() && callEx.argumentList.typeArgumentList) {
+                this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Non_generic_functions_may_not_accept_type_arguments), additionalResults, context);
+            } else if (rootSignature.isGeneric() && callEx.argumentList.typeArgumentList && rootSignature.getTypeParameters() && (callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount() !== rootSignature.getTypeParameters().length)) {
+                this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Signature_expected_0_type_arguments_got_1_instead, [rootSignature.getTypeParameters().length, callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()]), additionalResults, context);
+            }
+
+            var returnType = isSuperCall ? this.semanticInfoChain.voidTypeSymbol : signature.returnType;
+
+            var actualParametersContextTypeSymbols = [];
+            if (callEx.argumentList.arguments) {
+                var len = callEx.argumentList.arguments.nonSeparatorCount();
+                var params = signature.parameters;
+                var contextualType = null;
+                var signatureDecl = signature.getDeclarations()[0];
+
+                for (var i = 0; i < len; i++) {
+                    if (params.length) {
+                        if (i < params.length - 1 || (i < params.length && !signature.hasVarArgs)) {
+                            this.resolveDeclaredSymbol(params[i], context);
+                            contextualType = params[i].type;
+                        } else if (signature.hasVarArgs) {
+                            contextualType = params[params.length - 1].type;
+                            if (contextualType.isArrayNamedTypeReference()) {
+                                contextualType = contextualType.getElementType();
+                            }
+                        }
+                    }
+
+                    if (contextualType) {
+                        context.pushNewContextualType(contextualType);
+                        actualParametersContextTypeSymbols[i] = contextualType;
+                    }
+
+                    this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType !== null, context);
+
+                    if (contextualType) {
+                        context.popAnyContextualType();
+                        contextualType = null;
+                    }
+                }
+            }
+
+            additionalResults.targetSymbol = targetSymbol;
+            if (useBeforeResolutionSignatures && beforeResolutionSignatures) {
+                additionalResults.resolvedSignatures = beforeResolutionSignatures;
+                additionalResults.candidateSignature = beforeResolutionSignatures[0];
+            } else {
+                additionalResults.resolvedSignatures = signatures;
+                additionalResults.candidateSignature = signature;
+            }
+            additionalResults.actualParametersContextTypeSymbols = actualParametersContextTypeSymbols;
+
+            if (errorCondition) {
+                return errorCondition;
+            }
+
+            if (!returnType) {
+                returnType = this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            return returnType;
+        };
+
+        PullTypeResolver.prototype.resolveObjectCreationExpression = function (callEx, context, additionalResults) {
+            var symbol = this.getSymbolForAST(callEx, context);
+
+            if (!symbol || !symbol.isResolved) {
+                if (!additionalResults) {
+                    additionalResults = new PullAdditionalCallResolutionData();
+                }
+                symbol = this.computeObjectCreationExpressionSymbol(callEx, context, additionalResults);
+                if (this.canTypeCheckAST(callEx, context)) {
+                    this.setTypeChecked(callEx, context);
+                }
+                this.setSymbolForAST(callEx, symbol, context);
+                this.semanticInfoChain.setCallResolutionDataForAST(callEx, additionalResults);
+            } else {
+                if (this.canTypeCheckAST(callEx, context)) {
+                    this.typeCheckObjectCreationExpression(callEx, context);
+                }
+
+                var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx);
+                if (additionalResults && (callResolutionData !== additionalResults)) {
+                    additionalResults.actualParametersContextTypeSymbols = callResolutionData.actualParametersContextTypeSymbols;
+                    additionalResults.candidateSignature = callResolutionData.candidateSignature;
+                    additionalResults.resolvedSignatures = callResolutionData.resolvedSignatures;
+                    additionalResults.targetSymbol = callResolutionData.targetSymbol;
+                }
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.typeCheckObjectCreationExpression = function (callEx, context) {
+            this.setTypeChecked(callEx, context);
+            this.resolveAST(callEx.expression, false, context);
+            var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx);
+            if (callEx.argumentList) {
+                var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx);
+                var len = callEx.argumentList.arguments.nonSeparatorCount();
+
+                for (var i = 0; i < len; i++) {
+                    var contextualType = callResolutionData.actualParametersContextTypeSymbols ? callResolutionData.actualParametersContextTypeSymbols[i] : null;
+                    if (contextualType) {
+                        context.pushNewContextualType(contextualType);
+                    }
+
+                    this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType !== null, context);
+
+                    if (contextualType) {
+                        context.popAnyContextualType();
+                        contextualType = null;
+                    }
+                }
+            }
+
+            for (var i = 0; i < callResolutionData.diagnosticsFromOverloadResolution.length; i++) {
+                context.postDiagnostic(callResolutionData.diagnosticsFromOverloadResolution[i]);
+            }
+        };
+
+        PullTypeResolver.prototype.postOverloadResolutionDiagnostics = function (diagnostic, additionalResults, context) {
+            if (!context.inProvisionalResolution()) {
+                additionalResults.diagnosticsFromOverloadResolution.push(diagnostic);
+            }
+            context.postDiagnostic(diagnostic);
+        };
+
+        PullTypeResolver.prototype.computeObjectCreationExpressionSymbol = function (callEx, context, additionalResults) {
+            var _this = this;
+            var returnType = null;
+
+            var targetSymbol = this.resolveAST(callEx.expression, false, context);
+            var targetTypeSymbol = targetSymbol.isType() ? targetSymbol : targetSymbol.type;
+
+            var targetAST = this.getCallTargetErrorSpanAST(callEx);
+
+            var constructSignatures = targetTypeSymbol.getConstructSignatures();
+
+            var explicitTypeArgs = null;
+            var usedCallSignaturesInstead = false;
+            var couldNotAssignToConstraint;
+            var constraintDiagnostic = null;
+            var typeArgumentCountDiagnostic = null;
+            var diagnostics = [];
+
+            if (this.isAnyOrEquivalent(targetTypeSymbol)) {
+                if (callEx.argumentList) {
+                    this.resolveAST(callEx.argumentList.arguments, false, context);
+                }
+
+                return targetTypeSymbol;
+            }
+
+            if (!constructSignatures.length) {
+                constructSignatures = targetTypeSymbol.getCallSignatures();
+                usedCallSignaturesInstead = true;
+
+                if (this.compilationSettings.noImplicitAny()) {
+                    this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.new_expression_which_lacks_a_constructor_signature_implicitly_has_an_any_type), additionalResults, context);
+                }
+            }
+
+            if (constructSignatures.length) {
+                if (callEx.argumentList && callEx.argumentList.typeArgumentList) {
+                    explicitTypeArgs = [];
+
+                    if (callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()) {
+                        for (var i = 0; i < callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount(); i++) {
+                            explicitTypeArgs[i] = this.resolveTypeReference(callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorAt(i), context);
+                        }
+                    }
+                }
+
+                if (targetTypeSymbol.isGeneric()) {
+                    var resolvedSignatures = [];
+                    var inferredOrExplicitTypeArgs;
+                    var specializedSignature;
+                    var typeParameters;
+                    var typeConstraint = null;
+                    var triedToInferTypeArgs;
+                    var targetTypeReplacementMap = targetTypeSymbol.getTypeParameterArgumentMap();
+
+                    for (var i = 0; i < constructSignatures.length; i++) {
+                        couldNotAssignToConstraint = false;
+
+                        if (constructSignatures[i].isGeneric()) {
+                            typeParameters = constructSignatures[i].getTypeParameters();
+
+                            if (explicitTypeArgs) {
+                                if (explicitTypeArgs.length === typeParameters.length) {
+                                    inferredOrExplicitTypeArgs = explicitTypeArgs;
+                                } else {
+                                    typeArgumentCountDiagnostic = typeArgumentCountDiagnostic || this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Signature_expected_0_type_arguments_got_1_instead, [typeParameters.length, explicitTypeArgs.length]);
+                                    continue;
+                                }
+                            } else if (callEx.argumentList) {
+                                var typeArgumentInferenceContext = new TypeScript.InvocationTypeArgumentInferenceContext(this, context, constructSignatures[i], callEx.argumentList.arguments);
+                                inferredOrExplicitTypeArgs = this.inferArgumentTypesForSignature(typeArgumentInferenceContext, new TypeComparisonInfo(), context);
+                                triedToInferTypeArgs = true;
+                            } else {
+                                inferredOrExplicitTypeArgs = TypeScript.ArrayUtilities.select(typeParameters, function (typeParameter) {
+                                    return typeParameter.getDefaultConstraint(_this.semanticInfoChain);
+                                });
+                            }
+
+                            TypeScript.Debug.assert(inferredOrExplicitTypeArgs && inferredOrExplicitTypeArgs.length == typeParameters.length);
+
+                            var mutableTypeReplacementMap = new TypeScript.PullInstantiationHelpers.MutableTypeArgumentMap(targetTypeReplacementMap ? targetTypeReplacementMap : []);
+                            TypeScript.PullInstantiationHelpers.updateMutableTypeParameterArgumentMap(typeParameters, inferredOrExplicitTypeArgs, mutableTypeReplacementMap);
+                            var typeReplacementMap = mutableTypeReplacementMap.typeParameterArgumentMap;
+
+                            if (explicitTypeArgs) {
+                                for (var j = 0; j < typeParameters.length; j++) {
+                                    typeConstraint = typeParameters[j].getConstraint();
+
+                                    if (typeConstraint) {
+                                        if (typeConstraint.isGeneric()) {
+                                            typeConstraint = this.instantiateType(typeConstraint, typeReplacementMap);
+                                        }
+
+                                        if (!this.sourceIsAssignableToTarget(inferredOrExplicitTypeArgs[j], typeConstraint, targetAST, context, null, true)) {
+                                            var enclosingSymbol = this.getEnclosingSymbolForAST(targetAST);
+                                            constraintDiagnostic = this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2, [inferredOrExplicitTypeArgs[j].toString(enclosingSymbol, true), typeConstraint.toString(enclosingSymbol, true), typeParameters[j].toString(enclosingSymbol, true)]);
+                                            couldNotAssignToConstraint = true;
+                                        }
+
+                                        if (couldNotAssignToConstraint) {
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+
+                            if (couldNotAssignToConstraint) {
+                                continue;
+                            }
+
+                            specializedSignature = this.instantiateSignature(constructSignatures[i], typeReplacementMap);
+
+                            if (specializedSignature) {
+                                resolvedSignatures[resolvedSignatures.length] = specializedSignature;
+                            }
+                        } else {
+                            if (!(callEx.argumentList && callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount())) {
+                                resolvedSignatures[resolvedSignatures.length] = constructSignatures[i];
+                            }
+                        }
+                    }
+
+                    constructSignatures = resolvedSignatures;
+                }
+
+                var signature = this.resolveOverloads(callEx, constructSignatures, callEx.argumentList && callEx.argumentList.typeArgumentList !== null, context, diagnostics);
+
+                additionalResults.targetSymbol = targetSymbol;
+                additionalResults.resolvedSignatures = constructSignatures;
+                additionalResults.candidateSignature = signature;
+                additionalResults.actualParametersContextTypeSymbols = [];
+
+                if (!constructSignatures.length) {
+                    if (constraintDiagnostic) {
+                        this.postOverloadResolutionDiagnostics(constraintDiagnostic, additionalResults, context);
+                    } else if (typeArgumentCountDiagnostic) {
+                        this.postOverloadResolutionDiagnostics(typeArgumentCountDiagnostic, additionalResults, context);
+                    }
+
+                    return this.getNewErrorTypeSymbol();
+                }
+
+                var errorCondition = null;
+
+                if (!signature) {
+                    for (var i = 0; i < diagnostics.length; i++) {
+                        this.postOverloadResolutionDiagnostics(diagnostics[i], additionalResults, context);
+                    }
+
+                    this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Could_not_select_overload_for_new_expression), additionalResults, context);
+
+                    errorCondition = this.getNewErrorTypeSymbol();
+
+                    if (!constructSignatures.length) {
+                        return errorCondition;
+                    }
+
+                    signature = constructSignatures[0];
+                }
+
+                returnType = signature.returnType;
+
+                if (returnType && !signature.isGeneric() && returnType.isGeneric() && !returnType.getIsSpecialized()) {
+                    if (explicitTypeArgs && explicitTypeArgs.length) {
+                        returnType = this.createInstantiatedType(returnType, explicitTypeArgs);
+                    } else {
+                        returnType = this.instantiateTypeToAny(returnType, context);
+                    }
+                }
+
+                if (usedCallSignaturesInstead) {
+                    if (returnType !== this.semanticInfoChain.voidTypeSymbol) {
+                        this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Call_signatures_used_in_a_new_expression_must_have_a_void_return_type), additionalResults, context);
+
+                        return this.getNewErrorTypeSymbol();
+                    } else {
+                        returnType = this.semanticInfoChain.anyTypeSymbol;
+                    }
+                }
+
+                if (!returnType) {
+                    returnType = signature.returnType;
+
+                    if (!returnType) {
+                        returnType = targetTypeSymbol;
+                    }
+                }
+
+                var actualParametersContextTypeSymbols = [];
+                if (callEx.argumentList && callEx.argumentList.arguments) {
+                    var len = callEx.argumentList.arguments.nonSeparatorCount();
+                    var params = signature.parameters;
+                    var contextualType = null;
+                    var signatureDecl = signature.getDeclarations()[0];
+
+                    for (var i = 0; i < len; i++) {
+                        if (params.length) {
+                            if (i < params.length - 1 || (i < params.length && !signature.hasVarArgs)) {
+                                this.resolveDeclaredSymbol(params[i], context);
+                                contextualType = params[i].type;
+                            } else if (signature.hasVarArgs) {
+                                contextualType = params[params.length - 1].type;
+                                if (contextualType.isArrayNamedTypeReference()) {
+                                    contextualType = contextualType.getElementType();
+                                }
+                            }
+                        }
+
+                        if (contextualType) {
+                            context.pushNewContextualType(contextualType);
+                            actualParametersContextTypeSymbols[i] = contextualType;
+                        }
+
+                        this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType !== null, context);
+
+                        if (contextualType) {
+                            context.popAnyContextualType();
+                            contextualType = null;
+                        }
+                    }
+                }
+
+                additionalResults.targetSymbol = targetSymbol;
+                additionalResults.resolvedSignatures = constructSignatures;
+                additionalResults.candidateSignature = signature;
+                additionalResults.actualParametersContextTypeSymbols = actualParametersContextTypeSymbols;
+
+                if (errorCondition) {
+                    return errorCondition;
+                }
+
+                if (!returnType) {
+                    returnType = this.semanticInfoChain.anyTypeSymbol;
+                }
+
+                return returnType;
+            } else if (callEx.argumentList) {
+                this.resolveAST(callEx.argumentList.arguments, false, context);
+            }
+
+            this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Invalid_new_expression), additionalResults, context);
+
+            return this.getNewErrorTypeSymbol();
+        };
+
+        PullTypeResolver.prototype.instantiateSignatureInContext = function (signatureAToInstantiate, contextualSignatureB, context, shouldFixContextualSignatureParameterTypes) {
+            var typeReplacementMap = [];
+            var inferredTypeArgs;
+            var specializedSignature;
+            var typeParameters = signatureAToInstantiate.getTypeParameters();
+            var typeConstraint = null;
+
+            var typeArgumentInferenceContext = new TypeScript.ContextualSignatureInstantiationTypeArgumentInferenceContext(this, context, signatureAToInstantiate, contextualSignatureB, shouldFixContextualSignatureParameterTypes);
+            inferredTypeArgs = this.inferArgumentTypesForSignature(typeArgumentInferenceContext, new TypeComparisonInfo(), context);
+
+            var functionTypeA = signatureAToInstantiate.functionType;
+            var functionTypeB = contextualSignatureB.functionType;
+            var enclosingTypeParameterMap;
+
+            if (functionTypeA) {
+                enclosingTypeParameterMap = functionTypeA.getTypeParameterArgumentMap();
+
+                for (var id in enclosingTypeParameterMap) {
+                    typeReplacementMap[id] = enclosingTypeParameterMap[id];
+                }
+            }
+
+            if (functionTypeB) {
+                enclosingTypeParameterMap = functionTypeB.getTypeParameterArgumentMap();
+
+                for (var id in enclosingTypeParameterMap) {
+                    typeReplacementMap[id] = enclosingTypeParameterMap[id];
+                }
+            }
+
+            TypeScript.PullInstantiationHelpers.updateTypeParameterArgumentMap(typeParameters, inferredTypeArgs, typeReplacementMap);
+
+            return this.instantiateSignature(signatureAToInstantiate, typeReplacementMap);
+        };
+
+        PullTypeResolver.prototype.resolveCastExpression = function (assertionExpression, context) {
+            var typeAssertionType = this.resolveTypeReference(assertionExpression.type, context).type;
+
+            if (this.canTypeCheckAST(assertionExpression, context)) {
+                this.typeCheckCastExpression(assertionExpression, context, typeAssertionType);
+            }
+
+            return typeAssertionType;
+        };
+
+        PullTypeResolver.prototype.typeCheckCastExpression = function (assertionExpression, context, typeAssertionType) {
+            this.setTypeChecked(assertionExpression, context);
+
+            context.pushNewContextualType(typeAssertionType);
+            var exprType = this.resolveAST(assertionExpression.expression, true, context).type;
+            context.popAnyContextualType();
+
+            this.resolveDeclaredSymbol(typeAssertionType, context);
+            this.resolveDeclaredSymbol(exprType, context);
+
+            var comparisonInfo = new TypeComparisonInfo();
+
+            var isAssignable = this.sourceIsAssignableToTarget(exprType, typeAssertionType, assertionExpression, context, comparisonInfo);
+
+            if (!isAssignable) {
+                var widenedExprType = exprType.widenedType(this, assertionExpression.expression, context);
+                isAssignable = this.sourceIsAssignableToTarget(typeAssertionType, widenedExprType, assertionExpression, context, comparisonInfo);
+            }
+
+            if (!isAssignable) {
+                var enclosingSymbol = this.getEnclosingSymbolForAST(assertionExpression);
+                if (comparisonInfo.message) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(assertionExpression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [exprType.toString(enclosingSymbol), typeAssertionType.toString(enclosingSymbol), comparisonInfo.message]));
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(assertionExpression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [exprType.toString(enclosingSymbol), typeAssertionType.toString(enclosingSymbol)]));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.resolveAssignmentExpression = function (binaryExpression, context) {
+            var leftExpr = this.resolveAST(binaryExpression.left, false, context);
+            var leftType = leftExpr.type;
+
+            context.pushNewContextualType(leftType);
+            var rightType = this.resolveAST(binaryExpression.right, true, context).type;
+            context.popAnyContextualType();
+
+            rightType = this.getInstanceTypeForAssignment(binaryExpression.left, rightType, context);
+
+            if (this.canTypeCheckAST(binaryExpression, context)) {
+                this.setTypeChecked(binaryExpression, context);
+
+                if (!this.isReference(binaryExpression.left, leftExpr)) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_left_hand_side_of_assignment_expression));
+                } else {
+                    this.checkAssignability(binaryExpression.left, rightType, leftExpr.type, context);
+                }
+            }
+
+            return rightType;
+        };
+
+        PullTypeResolver.prototype.getInstanceTypeForAssignment = function (lhs, type, context) {
+            var typeToReturn = type;
+            if (typeToReturn && typeToReturn.isAlias()) {
+                typeToReturn = typeToReturn.getExportAssignedTypeSymbol();
+            }
+
+            if (typeToReturn && typeToReturn.isContainer() && !typeToReturn.isEnum()) {
+                var instanceTypeSymbol = typeToReturn.getInstanceType();
+
+                if (!instanceTypeSymbol) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(lhs, TypeScript.DiagnosticCode.Tried_to_set_variable_type_to_uninitialized_module_type_0, [type.toString()]));
+                    typeToReturn = null;
+                } else {
+                    typeToReturn = instanceTypeSymbol;
+                }
+            }
+
+            return typeToReturn;
+        };
+
+        PullTypeResolver.prototype.widenType = function (type, ast, context) {
+            if (type === this.semanticInfoChain.undefinedTypeSymbol || type === this.semanticInfoChain.nullTypeSymbol || type.isError()) {
+                return this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            if (type.isArrayNamedTypeReference()) {
+                return this.widenArrayType(type, ast, context);
+            } else if (type.kind === 256 /* ObjectLiteral */) {
+                return this.widenObjectLiteralType(type, ast, context);
+            }
+
+            return type;
+        };
+
+        PullTypeResolver.prototype.widenArrayType = function (type, ast, context) {
+            var elementType = type.getElementType().widenedType(this, ast, context);
+
+            if (this.compilationSettings.noImplicitAny() && ast) {
+                if (elementType === this.semanticInfoChain.anyTypeSymbol && type.getElementType() !== this.semanticInfoChain.anyTypeSymbol) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Array_Literal_implicitly_has_an_any_type_from_widening));
+                }
+            }
+
+            return this.getArrayType(elementType);
+        };
+
+        PullTypeResolver.prototype.widenObjectLiteralType = function (type, ast, context) {
+            if (!this.needsToWidenObjectLiteralType(type, ast, context)) {
+                return type;
+            }
+
+            TypeScript.Debug.assert(type.name === "");
+            var newObjectTypeSymbol = new TypeScript.PullTypeSymbol(type.name, type.kind);
+            var declsOfObjectType = type.getDeclarations();
+            TypeScript.Debug.assert(declsOfObjectType.length === 1);
+            newObjectTypeSymbol.addDeclaration(declsOfObjectType[0]);
+            var members = type.getMembers();
+
+            for (var i = 0; i < members.length; i++) {
+                var memberType = members[i].type;
+
+                var widenedMemberType = members[i].type.widenedType(this, ast, context);
+                var newMember = new TypeScript.PullSymbol(members[i].name, members[i].kind);
+
+                var declsOfMember = members[i].getDeclarations();
+
+                newMember.addDeclaration(declsOfMember[0]);
+                newMember.type = widenedMemberType;
+                newObjectTypeSymbol.addMember(newMember);
+                newMember.setResolved();
+
+                if (this.compilationSettings.noImplicitAny() && ast && widenedMemberType === this.semanticInfoChain.anyTypeSymbol && memberType !== this.semanticInfoChain.anyTypeSymbol) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Object_literal_s_property_0_implicitly_has_an_any_type_from_widening, [members[i].name]));
+                }
+            }
+
+            var indexers = type.getIndexSignatures();
+            for (var i = 0; i < indexers.length; i++) {
+                var newIndexer = new TypeScript.PullSignatureSymbol(4194304 /* IndexSignature */);
+                var parameter = indexers[i].parameters[0];
+                var newParameter = new TypeScript.PullSymbol(parameter.name, parameter.kind);
+                newParameter.type = parameter.type;
+                newIndexer.addParameter(newParameter);
+                newIndexer.returnType = indexers[i].returnType;
+                newObjectTypeSymbol.addIndexSignature(newIndexer);
+            }
+
+            return newObjectTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.needsToWidenObjectLiteralType = function (type, ast, context) {
+            var members = type.getMembers();
+            for (var i = 0; i < members.length; i++) {
+                var memberType = members[i].type;
+                if (memberType !== memberType.widenedType(this, ast, context)) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.findBestCommonType = function (collection, context, comparisonInfo) {
+            var len = collection.getLength();
+
+            for (var i = 0; i < len; i++) {
+                var candidateType = collection.getTypeAtIndex(i);
+                if (this.typeIsBestCommonTypeCandidate(candidateType, collection, context)) {
+                    return candidateType;
+                }
+            }
+
+            return this.semanticInfoChain.emptyTypeSymbol;
+        };
+
+        PullTypeResolver.prototype.typeIsBestCommonTypeCandidate = function (candidateType, collection, context) {
+            for (var i = 0; i < collection.getLength(); i++) {
+                var otherType = collection.getTypeAtIndex(i);
+                if (candidateType === otherType) {
+                    continue;
+                }
+
+                if (!this.sourceIsSubtypeOfTarget(otherType, candidateType, null, context)) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.typesAreIdenticalInEnclosingTypes = function (t1, t2, context) {
+            t1 = this.getSymbolForRelationshipCheck(t1);
+            t2 = this.getSymbolForRelationshipCheck(t2);
+
+            if (t1 === t2) {
+                return true;
+            }
+
+            if (t1 && t2) {
+                if (context.oneOfClassificationsIsInfinitelyExpanding()) {
+                    return this.infinitelyExpandingTypesAreIdentical(t1, t2, context);
+                }
+            }
+
+            return this.typesAreIdentical(t1, t2, context);
+        };
+
+        PullTypeResolver.prototype.typesAreIdenticalWithNewEnclosingTypes = function (t1, t2, context) {
+            var enclosingTypeWalkers = context.resetEnclosingTypeWalkers();
+            var areTypesIdentical = this.typesAreIdentical(t1, t2, context);
+            context.setEnclosingTypeWalkers(enclosingTypeWalkers);
+            return areTypesIdentical;
+        };
+
+        PullTypeResolver.prototype.typesAreIdentical = function (t1, t2, context) {
+            t1 = this.getSymbolForRelationshipCheck(t1);
+            t2 = this.getSymbolForRelationshipCheck(t2);
+
+            if (t1 === t2) {
+                return true;
+            }
+
+            if (!t1 || !t2) {
+                return false;
+            }
+
+            if (TypeScript.hasFlag(t1.kind, 64 /* Enum */) || TypeScript.hasFlag(t2.kind, 64 /* Enum */)) {
+                return false;
+            }
+
+            if (t1.isPrimitive() && t1.isStringConstant() && t2.isPrimitive() && t2.isStringConstant()) {
+                return TypeScript.stripStartAndEndQuotes(t1.name) === TypeScript.stripStartAndEndQuotes(t2.name);
+            }
+
+            if (t1.isPrimitive() || t2.isPrimitive()) {
+                return false;
+            }
+
+            if (t1.isError() && t2.isError()) {
+                return true;
+            }
+
+            var isIdentical = this.identicalCache.valueAt(t1.pullSymbolID, t2.pullSymbolID);
+            if (isIdentical != undefined) {
+                return isIdentical;
+            }
+
+            if (t1.isTypeParameter() !== t2.isTypeParameter()) {
+                return false;
+            } else if (t1.isTypeParameter()) {
+                var t1ParentDeclaration = t1.getDeclarations()[0].getParentDecl();
+                var t2ParentDeclaration = t2.getDeclarations()[0].getParentDecl();
+
+                if (t1ParentDeclaration === t2ParentDeclaration) {
+                    return this.symbolsShareDeclaration(t1, t2);
+                } else {
+                    return false;
+                }
+            }
+
+            if (t1.isPrimitive() !== t2.isPrimitive()) {
+                return false;
+            }
+
+            this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, true);
+            var symbolsWhenStartedWalkingTypes = context.startWalkingTypes(t1, t2);
+            isIdentical = this.typesAreIdenticalWorker(t1, t2, context);
+            context.endWalkingTypes(symbolsWhenStartedWalkingTypes);
+            this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, isIdentical);
+
+            return isIdentical;
+        };
+
+        PullTypeResolver.prototype.typesAreIdenticalWorker = function (t1, t2, context) {
+            if (t1.getIsSpecialized() && t2.getIsSpecialized()) {
+                if (TypeScript.PullHelpers.getRootType(t1) === TypeScript.PullHelpers.getRootType(t2) && TypeScript.PullHelpers.getRootType(t1).isNamedTypeSymbol()) {
+                    var t1TypeArguments = t1.getTypeArguments();
+                    var t2TypeArguments = t2.getTypeArguments();
+
+                    if (t1TypeArguments && t2TypeArguments) {
+                        for (var i = 0; i < t1TypeArguments.length; i++) {
+                            if (!this.typesAreIdenticalWithNewEnclosingTypes(t1TypeArguments[i], t2TypeArguments[i], context)) {
+                                return false;
+                            }
+                        }
+                    }
+
+                    return true;
+                }
+            }
+
+            if (t1.hasMembers() && t2.hasMembers()) {
+                var t1Members = t1.getAllMembers(68147712 /* SomeValue */, 0 /* all */);
+                var t2Members = t2.getAllMembers(68147712 /* SomeValue */, 0 /* all */);
+
+                if (t1Members.length !== t2Members.length) {
+                    return false;
+                }
+
+                var t1MemberSymbol = null;
+                var t2MemberSymbol = null;
+
+                var t1MemberType = null;
+                var t2MemberType = null;
+
+                for (var iMember = 0; iMember < t1Members.length; iMember++) {
+                    t1MemberSymbol = t1Members[iMember];
+                    t2MemberSymbol = this.getNamedPropertySymbol(t1MemberSymbol.name, 68147712 /* SomeValue */, t2);
+
+                    if (!this.propertiesAreIdentical(t1MemberSymbol, t2MemberSymbol, context)) {
+                        return false;
+                    }
+                }
+            } else if (t1.hasMembers() || t2.hasMembers()) {
+                return false;
+            }
+
+            var t1CallSigs = t1.getCallSignatures();
+            var t2CallSigs = t2.getCallSignatures();
+
+            var t1ConstructSigs = t1.getConstructSignatures();
+            var t2ConstructSigs = t2.getConstructSignatures();
+
+            var t1IndexSigs = t1.getIndexSignatures();
+            var t2IndexSigs = t2.getIndexSignatures();
+
+            if (!this.signatureGroupsAreIdentical(t1CallSigs, t2CallSigs, context)) {
+                return false;
+            }
+
+            if (!this.signatureGroupsAreIdentical(t1ConstructSigs, t2ConstructSigs, context)) {
+                return false;
+            }
+
+            if (!this.signatureGroupsAreIdentical(t1IndexSigs, t2IndexSigs, context)) {
+                return false;
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.propertiesAreIdentical = function (propertySymbol1, propertySymbol2, context) {
+            if (!propertySymbol2 || (propertySymbol1.isOptional !== propertySymbol2.isOptional)) {
+                return false;
+            }
+
+            var t1MemberSymbolIsPrivate = propertySymbol1.anyDeclHasFlag(2 /* Private */);
+            var t2MemberSymbolIsPrivate = propertySymbol2.anyDeclHasFlag(2 /* Private */);
+
+            if (t1MemberSymbolIsPrivate !== t2MemberSymbolIsPrivate) {
+                return false;
+            } else if (t2MemberSymbolIsPrivate && t1MemberSymbolIsPrivate) {
+                var t1MemberSymbolDecl = propertySymbol1.getDeclarations()[0];
+                var sourceDecl = propertySymbol2.getDeclarations()[0];
+                if (t1MemberSymbolDecl !== sourceDecl) {
+                    return false;
+                }
+            }
+
+            var t1MemberType = propertySymbol1.type;
+            var t2MemberType = propertySymbol2.type;
+
+            context.walkMemberTypes(propertySymbol1.name);
+            var areMemberTypesIdentical = this.typesAreIdenticalInEnclosingTypes(t1MemberType, t2MemberType, context);
+            context.postWalkMemberTypes();
+            return areMemberTypesIdentical;
+        };
+
+        PullTypeResolver.prototype.propertiesAreIdenticalWithNewEnclosingTypes = function (type1, type2, property1, property2, context) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(type1, type2);
+            var arePropertiesIdentical = this.propertiesAreIdentical(property1, property2, context);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return arePropertiesIdentical;
+        };
+
+        PullTypeResolver.prototype.signatureGroupsAreIdentical = function (sg1, sg2, context) {
+            if (sg1 === sg2) {
+                return true;
+            }
+
+            if (!sg1 || !sg2) {
+                return false;
+            }
+
+            if (sg1.length !== sg2.length) {
+                return false;
+            }
+
+            for (var i = 0; i < sg1.length; i++) {
+                context.walkSignatures(sg1[i].kind, i);
+                var areSignaturesIdentical = this.signaturesAreIdentical(sg1[i], sg2[i], context, true);
+                context.postWalkSignatures();
+                if (!areSignaturesIdentical) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.typeParametersAreIdentical = function (tp1, tp2, context) {
+            var typeParamsAreIdentical = this.typeParametersAreIdenticalWorker(tp1, tp2, context);
+
+            this.setTypeParameterIdentity(tp1, tp2, undefined);
+
+            return typeParamsAreIdentical;
+        };
+
+        PullTypeResolver.prototype.typeParametersAreIdenticalWorker = function (tp1, tp2, context) {
+            if (!!(tp1 && tp1.length) !== !!(tp2 && tp2.length)) {
+                return false;
+            }
+
+            if (tp1 && tp2 && (tp1.length !== tp2.length)) {
+                return false;
+            }
+
+            if (tp1 && tp2) {
+                for (var i = 0; i < tp1.length; i++) {
+                    context.walkTypeParameterConstraints(i);
+                    var areConstraintsIdentical = this.typesAreIdentical(tp1[i].getConstraint(), tp2[i].getConstraint(), context);
+                    context.postWalkTypeParameterConstraints();
+                    if (!areConstraintsIdentical) {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.setTypeParameterIdentity = function (tp1, tp2, val) {
+            if (tp1 && tp2 && tp1.length === tp2.length) {
+                for (var i = 0; i < tp1.length; i++) {
+                    this.identicalCache.setValueAt(tp1[i].pullSymbolID, tp2[i].pullSymbolID, val);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.signaturesAreIdenticalWithNewEnclosingTypes = function (s1, s2, context, includingReturnType) {
+            if (typeof includingReturnType === "undefined") { includingReturnType = true; }
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(s1, s2);
+            var areSignaturesIdentical = this.signaturesAreIdentical(s1, s2, context, includingReturnType);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return areSignaturesIdentical;
+        };
+
+        PullTypeResolver.prototype.signaturesAreIdentical = function (s1, s2, context, includingReturnType) {
+            if (typeof includingReturnType === "undefined") { includingReturnType = true; }
+            if (s1 === s2) {
+                return true;
+            }
+
+            var signaturesIdentical = this.identicalCache.valueAt(s1.pullSymbolID, s2.pullSymbolID);
+            if (signaturesIdentical || (signaturesIdentical != undefined && includingReturnType)) {
+                return signaturesIdentical;
+            }
+
+            var oldValue = signaturesIdentical;
+            this.identicalCache.setValueAt(s1.pullSymbolID, s2.pullSymbolID, true);
+
+            signaturesIdentical = this.signaturesAreIdenticalWorker(s1, s2, context, includingReturnType);
+
+            if (includingReturnType) {
+                this.identicalCache.setValueAt(s1.pullSymbolID, s2.pullSymbolID, signaturesIdentical);
+            } else {
+                this.identicalCache.setValueAt(s1.pullSymbolID, s2.pullSymbolID, oldValue);
+            }
+
+            return signaturesIdentical;
+        };
+
+        PullTypeResolver.prototype.signaturesAreIdenticalWorker = function (s1, s2, context, includingReturnType) {
+            if (typeof includingReturnType === "undefined") { includingReturnType = true; }
+            if (s1.hasVarArgs !== s2.hasVarArgs) {
+                return false;
+            }
+
+            if (s1.nonOptionalParamCount !== s2.nonOptionalParamCount) {
+                return false;
+            }
+
+            if (s1.parameters.length !== s2.parameters.length) {
+                return false;
+            }
+
+            var s1TypeParameters = s1.getTypeParameters();
+            var s2TypeParameters = s2.getTypeParameters();
+            this.setTypeParameterIdentity(s1TypeParameters, s2TypeParameters, true);
+
+            var typeParametersParametersAndReturnTypesAreIdentical = this.signatureTypeParametersParametersAndReturnTypesAreIdentical(s1, s2, context, includingReturnType);
+
+            this.setTypeParameterIdentity(s1TypeParameters, s2TypeParameters, undefined);
+            return typeParametersParametersAndReturnTypesAreIdentical;
+        };
+
+        PullTypeResolver.prototype.signatureTypeParametersParametersAndReturnTypesAreIdentical = function (s1, s2, context, includingReturnType) {
+            if (!this.typeParametersAreIdenticalWorker(s1.getTypeParameters(), s2.getTypeParameters(), context)) {
+                return false;
+            }
+
+            if (includingReturnType) {
+                TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(s1);
+                TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(s2);
+                context.walkReturnTypes();
+                var areReturnTypesIdentical = this.typesAreIdenticalInEnclosingTypes(s1.returnType, s2.returnType, context);
+                context.postWalkReturnTypes();
+                if (!areReturnTypesIdentical) {
+                    return false;
+                }
+            }
+
+            var s1Params = s1.parameters;
+            var s2Params = s2.parameters;
+
+            for (var iParam = 0; iParam < s1Params.length; iParam++) {
+                TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(s1Params[iParam]);
+                TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(s2Params[iParam]);
+                context.walkParameterTypes(iParam);
+                var areParameterTypesIdentical = this.typesAreIdenticalInEnclosingTypes(s1Params[iParam].type, s2Params[iParam].type, context);
+                context.postWalkParameterTypes();
+
+                if (!areParameterTypesIdentical) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.signatureReturnTypesAreIdentical = function (s1, s2, context) {
+            var s1TypeParameters = s1.getTypeParameters();
+            var s2TypeParameters = s2.getTypeParameters();
+            this.setTypeParameterIdentity(s1TypeParameters, s2TypeParameters, true);
+
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(s1, s2);
+            context.walkReturnTypes();
+            var returnTypeIsIdentical = this.typesAreIdenticalInEnclosingTypes(s1.returnType, s2.returnType, context);
+
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+
+            this.setTypeParameterIdentity(s1TypeParameters, s2TypeParameters, undefined);
+
+            return returnTypeIsIdentical;
+        };
+
+        PullTypeResolver.prototype.symbolsShareDeclaration = function (symbol1, symbol2) {
+            var decls1 = symbol1.getDeclarations();
+            var decls2 = symbol2.getDeclarations();
+
+            if (decls1.length && decls2.length) {
+                return decls1[0] === decls2[0];
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.sourceIsSubtypeOfTarget = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            return this.sourceIsRelatableToTarget(source, target, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+        };
+
+        PullTypeResolver.prototype.sourceMembersAreAssignableToTargetMembers = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(source, target);
+            var areSourceMembersAreAssignableToTargetMembers = this.sourceMembersAreRelatableToTargetMembers(source, target, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return areSourceMembersAreAssignableToTargetMembers;
+        };
+
+        PullTypeResolver.prototype.sourcePropertyIsAssignableToTargetProperty = function (source, target, sourceProp, targetProp, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(source, target);
+            var isSourcePropertyIsAssignableToTargetProperty = this.sourcePropertyIsRelatableToTargetProperty(source, target, sourceProp, targetProp, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return isSourcePropertyIsAssignableToTargetProperty;
+        };
+
+        PullTypeResolver.prototype.sourceCallSignaturesAreAssignableToTargetCallSignatures = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(source, target);
+            var areSourceCallSignaturesAssignableToTargetCallSignatures = this.sourceCallSignaturesAreRelatableToTargetCallSignatures(source, target, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return areSourceCallSignaturesAssignableToTargetCallSignatures;
+        };
+
+        PullTypeResolver.prototype.sourceConstructSignaturesAreAssignableToTargetConstructSignatures = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(source, target);
+            var areSourceConstructSignaturesAssignableToTargetConstructSignatures = this.sourceConstructSignaturesAreRelatableToTargetConstructSignatures(source, target, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return areSourceConstructSignaturesAssignableToTargetConstructSignatures;
+        };
+
+        PullTypeResolver.prototype.sourceIndexSignaturesAreAssignableToTargetIndexSignatures = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(source, target);
+            var areSourceIndexSignaturesAssignableToTargetIndexSignatures = this.sourceIndexSignaturesAreRelatableToTargetIndexSignatures(source, target, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return areSourceIndexSignaturesAssignableToTargetIndexSignatures;
+        };
+
+        PullTypeResolver.prototype.typeIsAssignableToFunction = function (source, ast, context) {
+            if (source.isFunctionType()) {
+                return true;
+            }
+
+            return this.cachedFunctionInterfaceType() && this.sourceIsAssignableToTarget(source, this.cachedFunctionInterfaceType(), ast, context);
+        };
+
+        PullTypeResolver.prototype.signatureIsAssignableToTarget = function (s1, s2, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            context.setEnclosingTypes(s1, s2);
+            var isSignatureIsAssignableToTarget = this.signatureIsRelatableToTarget(s1, s2, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return isSignatureIsAssignableToTarget;
+        };
+
+        PullTypeResolver.prototype.sourceIsAssignableToTarget = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            return this.sourceIsRelatableToTarget(source, target, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+        };
+
+        PullTypeResolver.prototype.sourceIsAssignableToTargetWithNewEnclosingTypes = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            return this.sourceIsRelatableToTargetWithNewEnclosingTypes(source, target, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+        };
+
+        PullTypeResolver.prototype.getSymbolForRelationshipCheck = function (symbol) {
+            if (symbol && symbol.isTypeReference()) {
+                return symbol.getReferencedTypeSymbol();
+            }
+
+            return symbol;
+        };
+
+        PullTypeResolver.prototype.sourceIsRelatableToTargetInEnclosingTypes = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            source = this.getSymbolForRelationshipCheck(source);
+            target = this.getSymbolForRelationshipCheck(target);
+
+            if (source === target) {
+                return true;
+            }
+
+            if (source && target) {
+                if (context.oneOfClassificationsIsInfinitelyExpanding()) {
+                    return this.infinitelyExpandingSourceTypeIsRelatableToTargetType(source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+                }
+            }
+
+            return this.sourceIsRelatableToTarget(source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+        };
+
+        PullTypeResolver.prototype.sourceIsRelatableToTargetWithNewEnclosingTypes = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var enclosingWalkers = context.resetEnclosingTypeWalkers();
+            var isSourceRelatable = this.sourceIsRelatableToTarget(source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            context.setEnclosingTypeWalkers(enclosingWalkers);
+            return isSourceRelatable;
+        };
+
+        PullTypeResolver.prototype.sourceIsRelatableToTargetInCache = function (source, target, comparisonCache, comparisonInfo) {
+            var isRelatable = comparisonCache.valueAt(source.pullSymbolID, target.pullSymbolID);
+
+            if (isRelatable) {
+                return { isRelatable: isRelatable };
+            }
+
+            if (isRelatable != undefined && !comparisonInfo) {
+                return { isRelatable: isRelatable };
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.sourceIsRelatableToTarget = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            source = this.getSymbolForRelationshipCheck(source);
+            target = this.getSymbolForRelationshipCheck(target);
+
+            if (source === target) {
+                return true;
+            }
+
+            if (!(source && target)) {
+                return true;
+            }
+
+            var sourceApparentType = this.getApparentType(source);
+
+            var isRelatableInfo = this.sourceIsRelatableToTargetInCache(source, target, comparisonCache, comparisonInfo);
+            if (isRelatableInfo) {
+                return isRelatableInfo.isRelatable;
+            }
+
+            if (source === this.semanticInfoChain.stringTypeSymbol && target.isPrimitive() && target.isStringConstant()) {
+                return comparisonInfo && comparisonInfo.stringConstantVal && (comparisonInfo.stringConstantVal.kind() === 14 /* StringLiteral */) && (TypeScript.stripStartAndEndQuotes(comparisonInfo.stringConstantVal.text()) === TypeScript.stripStartAndEndQuotes(target.name));
+            }
+
+            if (assignableTo) {
+                if (this.isAnyOrEquivalent(source) || this.isAnyOrEquivalent(target)) {
+                    return true;
+                }
+            } else {
+                if (this.isAnyOrEquivalent(target)) {
+                    return true;
+                }
+            }
+
+            if (target === this.semanticInfoChain.stringTypeSymbol && source.isPrimitive() && source.isStringConstant()) {
+                return true;
+            }
+
+            if (source.isPrimitive() && source.isStringConstant() && target.isPrimitive() && target.isStringConstant()) {
+                return TypeScript.stripStartAndEndQuotes(source.name) === TypeScript.stripStartAndEndQuotes(target.name);
+            }
+
+            if (source === this.semanticInfoChain.undefinedTypeSymbol) {
+                return true;
+            }
+
+            if ((source === this.semanticInfoChain.nullTypeSymbol) && (target !== this.semanticInfoChain.undefinedTypeSymbol && target != this.semanticInfoChain.voidTypeSymbol)) {
+                return true;
+            }
+
+            if (target === this.semanticInfoChain.voidTypeSymbol) {
+                if (source === this.semanticInfoChain.undefinedTypeSymbol || source == this.semanticInfoChain.nullTypeSymbol) {
+                    return true;
+                }
+
+                return false;
+            } else if (source === this.semanticInfoChain.voidTypeSymbol) {
+                if (target === this.semanticInfoChain.anyTypeSymbol) {
+                    return true;
+                }
+
+                return false;
+            }
+
+            if (target === this.semanticInfoChain.numberTypeSymbol && TypeScript.PullHelpers.symbolIsEnum(source)) {
+                return true;
+            }
+
+            if (source === this.semanticInfoChain.numberTypeSymbol && TypeScript.PullHelpers.symbolIsEnum(target)) {
+                return assignableTo;
+            }
+
+            if (TypeScript.PullHelpers.symbolIsEnum(target) && TypeScript.PullHelpers.symbolIsEnum(source)) {
+                return this.symbolsShareDeclaration(target, source);
+            }
+
+            if ((source.kind & 64 /* Enum */) || (target.kind & 64 /* Enum */)) {
+                return false;
+            }
+
+            if (source.getIsSpecialized() && target.getIsSpecialized()) {
+                if (TypeScript.PullHelpers.getRootType(source) === TypeScript.PullHelpers.getRootType(target) && TypeScript.PullHelpers.getRootType(source).isNamedTypeSymbol()) {
+                    var sourceTypeArguments = source.getTypeArguments();
+                    var targetTypeArguments = target.getTypeArguments();
+
+                    if (sourceTypeArguments && targetTypeArguments) {
+                        comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, true);
+
+                        for (var i = 0; i < sourceTypeArguments.length; i++) {
+                            if (!this.sourceIsRelatableToTargetWithNewEnclosingTypes(sourceTypeArguments[i], targetTypeArguments[i], assignableTo, comparisonCache, ast, context, null, isComparingInstantiatedSignatures)) {
+                                break;
+                            }
+                        }
+
+                        if (i === sourceTypeArguments.length) {
+                            return true;
+                        } else {
+                            comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, undefined);
+                        }
+                    }
+                }
+            }
+
+            if (target.isTypeParameter()) {
+                if (source.isTypeParameter()) {
+                    if (!source.getConstraint()) {
+                        return this.typesAreIdentical(target, source, context);
+                    } else {
+                        return this.isSourceTypeParameterConstrainedToTargetTypeParameter(source, target);
+                    }
+                } else {
+                    if (isComparingInstantiatedSignatures) {
+                        target = target.getBaseConstraint(this.semanticInfoChain);
+                    } else {
+                        return this.typesAreIdentical(target, sourceApparentType, context);
+                    }
+                }
+            }
+
+            if (sourceApparentType.isPrimitive() || target.isPrimitive()) {
+                return false;
+            }
+
+            comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, true);
+
+            var symbolsWhenStartedWalkingTypes = context.startWalkingTypes(sourceApparentType, target);
+
+            var needsSourceSubstitutionUpdate = source != sourceApparentType && context.enclosingTypeWalker1._canWalkStructure() && context.enclosingTypeWalker1._getCurrentSymbol() != sourceApparentType;
+            if (needsSourceSubstitutionUpdate) {
+                context.enclosingTypeWalker1.setCurrentSymbol(sourceApparentType);
+            }
+
+            var isRelatable = this.sourceIsRelatableToTargetWorker(source, target, sourceApparentType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+
+            if (needsSourceSubstitutionUpdate) {
+                context.enclosingTypeWalker1.setCurrentSymbol(source);
+            }
+            context.endWalkingTypes(symbolsWhenStartedWalkingTypes);
+
+            comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, isRelatable);
+            return isRelatable;
+        };
+
+        PullTypeResolver.prototype.isSourceTypeParameterConstrainedToTargetTypeParameter = function (source, target) {
+            var current = source;
+            while (current && current.isTypeParameter()) {
+                if (current === target) {
+                    return true;
+                }
+
+                current = current.getConstraint();
+            }
+            return false;
+        };
+
+        PullTypeResolver.prototype.sourceIsRelatableToTargetWorker = function (source, target, sourceSubstitution, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            if (target.hasMembers() && !this.sourceMembersAreRelatableToTargetMembers(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) {
+                return false;
+            }
+
+            if (!this.sourceCallSignaturesAreRelatableToTargetCallSignatures(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) {
+                return false;
+            }
+
+            if (!this.sourceConstructSignaturesAreRelatableToTargetConstructSignatures(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) {
+                return false;
+            }
+
+            if (!this.sourceIndexSignaturesAreRelatableToTargetIndexSignatures(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) {
+                return false;
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.sourceMembersAreRelatableToTargetMembers = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var targetProps = target.getAllMembers(68147712 /* SomeValue */, 0 /* all */);
+
+            for (var itargetProp = 0; itargetProp < targetProps.length; itargetProp++) {
+                var targetProp = targetProps[itargetProp];
+
+                var sourceProp = this._getNamedPropertySymbolOfAugmentedType(targetProp.name, source);
+
+                this.resolveDeclaredSymbol(targetProp, context);
+
+                var targetPropType = targetProp.type;
+
+                if (!sourceProp) {
+                    if (!(targetProp.isOptional)) {
+                        if (comparisonInfo) {
+                            var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                            comparisonInfo.flags |= 2 /* RequiredPropertyIsMissing */;
+                            comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_0_is_missing_property_1_from_type_2, [source.toString(enclosingSymbol), targetProp.getScopedNameEx().toString(), target.toString(enclosingSymbol)]));
+                        }
+                        return false;
+                    }
+                    continue;
+                }
+
+                if (!this.sourcePropertyIsRelatableToTargetProperty(source, target, sourceProp, targetProp, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) {
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.infinitelyExpandingSourceTypeIsRelatableToTargetType = function (sourceType, targetType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var widenedTargetType = targetType.widenedType(this, null, context);
+            var widenedSourceType = sourceType.widenedType(this, null, context);
+
+            if ((widenedSourceType !== this.semanticInfoChain.anyTypeSymbol) && (widenedTargetType !== this.semanticInfoChain.anyTypeSymbol)) {
+                var sourceTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(sourceType);
+                var targetTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(targetType);
+
+                if (sourceTypeNamedTypeReference !== targetTypeNamedTypeReference) {
+                    comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false);
+                    if (comparisonInfo) {
+                        var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                        comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_infinitely_expanding_type_reference_do_not_refer_to_same_named_type, [sourceType.getScopedNameEx(enclosingSymbol).toString(), targetType.toString(enclosingSymbol)]));
+                    }
+                    return false;
+                }
+
+                var sourceTypeArguments = sourceType.getTypeArguments();
+                var targetTypeArguments = targetType.getTypeArguments();
+
+                if (!sourceTypeArguments && !targetTypeArguments) {
+                    comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, true);
+                    return true;
+                }
+
+                if (!(sourceTypeArguments && targetTypeArguments) || sourceTypeArguments.length !== targetTypeArguments.length) {
+                    comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false);
+                    if (comparisonInfo) {
+                        var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                        comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_infinitely_expanding_type_reference_have_incompatible_type_arguments, [sourceType.toString(enclosingSymbol), targetType.toString(enclosingSymbol)]));
+                    }
+                    return false;
+                }
+
+                var comparisonInfoTypeArgumentsCheck = null;
+                if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) {
+                    comparisonInfoTypeArgumentsCheck = new TypeComparisonInfo(comparisonInfo);
+                }
+                var isRelatable = true;
+                for (var i = 0; i < sourceTypeArguments.length && isRelatable; i++) {
+                    context.walkTypeArgument(i);
+
+                    if (!this.sourceIsRelatableToTargetInEnclosingTypes(sourceTypeArguments[i], targetTypeArguments[i], assignableTo, comparisonCache, ast, context, comparisonInfoTypeArgumentsCheck, isComparingInstantiatedSignatures)) {
+                        isRelatable = false;
+                        if (comparisonInfo) {
+                            var message;
+                            var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+
+                            if (comparisonInfoTypeArgumentsCheck && comparisonInfoTypeArgumentsCheck.message) {
+                                message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_infinitely_expanding_type_reference_have_incompatible_type_arguments_NL_2, [sourceType.toString(enclosingSymbol), targetType.toString(enclosingSymbol), comparisonInfoTypeArgumentsCheck.message]);
+                            } else {
+                                message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_infinitely_expanding_type_reference_have_incompatible_type_arguments, [sourceType.toString(enclosingSymbol), targetType.toString(enclosingSymbol)]);
+                            }
+                            comparisonInfo.addMessage(message);
+                        }
+                    }
+
+                    context.postWalkTypeArgument();
+                }
+            }
+
+            comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, isRelatable);
+            return isRelatable;
+        };
+
+        PullTypeResolver.prototype.infinitelyExpandingTypesAreIdentical = function (sourceType, targetType, context) {
+            var widenedTargetType = targetType.widenedType(this, null, null);
+            var widenedSourceType = sourceType.widenedType(this, null, null);
+
+            if ((widenedSourceType !== this.semanticInfoChain.anyTypeSymbol) && (widenedTargetType !== this.semanticInfoChain.anyTypeSymbol)) {
+                var sourceTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(sourceType);
+                var targetTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(targetType);
+                if (sourceTypeNamedTypeReference !== targetTypeNamedTypeReference) {
+                    this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false);
+                    return false;
+                }
+
+                var sourceTypeArguments = sourceType.getTypeArguments();
+                var targetTypeArguments = targetType.getTypeArguments();
+
+                if (!sourceTypeArguments && !targetTypeArguments) {
+                    this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, true);
+                    return true;
+                }
+
+                if (!(sourceTypeArguments && targetTypeArguments) || sourceTypeArguments.length !== targetTypeArguments.length) {
+                    this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false);
+                    return false;
+                }
+
+                for (var i = 0; i < sourceTypeArguments.length; i++) {
+                    context.walkTypeArgument(i);
+                    var areIdentical = this.typesAreIdenticalInEnclosingTypes(sourceTypeArguments[i], targetTypeArguments[i], context);
+                    context.postWalkTypeArgument();
+
+                    if (!areIdentical) {
+                        this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false);
+                        return false;
+                    }
+                }
+            }
+
+            this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, true);
+            return true;
+        };
+
+        PullTypeResolver.prototype.sourcePropertyIsRelatableToTargetProperty = function (source, target, sourceProp, targetProp, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var _this = this;
+            var sourceAndTargetAreConstructors = source.isConstructor() && target.isConstructor();
+
+            var getNames = function (takeTypesFromPropertyContainers) {
+                var enclosingSymbol = _this.getEnclosingSymbolForAST(ast);
+                var sourceType = takeTypesFromPropertyContainers ? sourceProp.getContainer() : source;
+                var targetType = takeTypesFromPropertyContainers ? targetProp.getContainer() : target;
+                if (sourceAndTargetAreConstructors) {
+                    sourceType = sourceType.getAssociatedContainerType();
+                    targetType = targetType.getAssociatedContainerType();
+                }
+                return {
+                    propertyName: targetProp.getScopedNameEx().toString(),
+                    sourceTypeName: sourceType.toString(enclosingSymbol),
+                    targetTypeName: targetType.toString(enclosingSymbol)
+                };
+            };
+
+            var targetPropIsPrivate = targetProp.anyDeclHasFlag(2 /* Private */);
+            var sourcePropIsPrivate = sourceProp.anyDeclHasFlag(2 /* Private */);
+
+            if (targetPropIsPrivate !== sourcePropIsPrivate) {
+                if (comparisonInfo) {
+                    var names = getNames(true);
+                    var code;
+                    if (targetPropIsPrivate) {
+                        code = sourceAndTargetAreConstructors ? TypeScript.DiagnosticCode.Static_property_0_defined_as_public_in_type_1_is_defined_as_private_in_type_2 : TypeScript.DiagnosticCode.Property_0_defined_as_public_in_type_1_is_defined_as_private_in_type_2;
+                    } else {
+                        code = sourceAndTargetAreConstructors ? TypeScript.DiagnosticCode.Static_property_0_defined_as_private_in_type_1_is_defined_as_public_in_type_2 : TypeScript.DiagnosticCode.Property_0_defined_as_private_in_type_1_is_defined_as_public_in_type_2;
+                    }
+                    comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(code, [names.propertyName, names.sourceTypeName, names.targetTypeName]));
+                    comparisonInfo.flags |= 128 /* InconsistantPropertyAccesibility */;
+                }
+                return false;
+            } else if (sourcePropIsPrivate && targetPropIsPrivate) {
+                var targetDecl = targetProp.getDeclarations()[0];
+                var sourceDecl = sourceProp.getDeclarations()[0];
+
+                if (targetDecl !== sourceDecl) {
+                    if (comparisonInfo) {
+                        var names = getNames(true);
+
+                        comparisonInfo.flags |= 128 /* InconsistantPropertyAccesibility */;
+                        var code = sourceAndTargetAreConstructors ? TypeScript.DiagnosticCode.Types_0_and_1_define_static_property_2_as_private : TypeScript.DiagnosticCode.Types_0_and_1_define_property_2_as_private;
+                        comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(code, [names.sourceTypeName, names.targetTypeName, names.propertyName]));
+                    }
+
+                    return false;
+                }
+            }
+
+            if (sourceProp.isOptional && !targetProp.isOptional) {
+                if (comparisonInfo) {
+                    var names = getNames(true);
+                    comparisonInfo.flags |= 2 /* RequiredPropertyIsMissing */;
+                    comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Property_0_defined_as_optional_in_type_1_but_is_required_in_type_2, [names.propertyName, names.sourceTypeName, names.targetTypeName]));
+                }
+                return false;
+            }
+
+            this.resolveDeclaredSymbol(sourceProp, context);
+
+            var sourcePropType = sourceProp.type;
+            var targetPropType = targetProp.type;
+
+            var isRelatableInfo = this.sourceIsRelatableToTargetInCache(sourcePropType, targetPropType, comparisonCache, comparisonInfo);
+            if (isRelatableInfo) {
+                return isRelatableInfo.isRelatable;
+            }
+
+            var comparisonInfoPropertyTypeCheck = null;
+            if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) {
+                comparisonInfoPropertyTypeCheck = new TypeComparisonInfo(comparisonInfo);
+            }
+
+            context.walkMemberTypes(targetProp.name);
+            var isSourcePropertyRelatableToTargetProperty = this.sourceIsRelatableToTargetInEnclosingTypes(sourcePropType, targetPropType, assignableTo, comparisonCache, ast, context, comparisonInfoPropertyTypeCheck, isComparingInstantiatedSignatures);
+            context.postWalkMemberTypes();
+
+            if (!isSourcePropertyRelatableToTargetProperty && comparisonInfo) {
+                var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                comparisonInfo.flags |= 32 /* IncompatiblePropertyTypes */;
+                var message;
+                var names = getNames(false);
+                if (comparisonInfoPropertyTypeCheck && comparisonInfoPropertyTypeCheck.message) {
+                    var code = sourceAndTargetAreConstructors ? TypeScript.DiagnosticCode.Types_of_static_property_0_of_class_1_and_class_2_are_incompatible_NL_3 : TypeScript.DiagnosticCode.Types_of_property_0_of_types_1_and_2_are_incompatible_NL_3;
+                    message = TypeScript.getDiagnosticMessage(code, [names.propertyName, names.sourceTypeName, names.targetTypeName, comparisonInfoPropertyTypeCheck.message]);
+                } else {
+                    var code = sourceAndTargetAreConstructors ? TypeScript.DiagnosticCode.Types_of_static_property_0_of_class_1_and_class_2_are_incompatible : TypeScript.DiagnosticCode.Types_of_property_0_of_types_1_and_2_are_incompatible;
+                    message = TypeScript.getDiagnosticMessage(code, [names.propertyName, names.sourceTypeName, names.targetTypeName]);
+                }
+                comparisonInfo.addMessage(message);
+            }
+
+            return isSourcePropertyRelatableToTargetProperty;
+        };
+
+        PullTypeResolver.prototype.sourceCallSignaturesAreRelatableToTargetCallSignatures = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var targetCallSigs = target.getCallSignatures();
+
+            if (targetCallSigs.length) {
+                var comparisonInfoSignatuesTypeCheck = null;
+                if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) {
+                    comparisonInfoSignatuesTypeCheck = new TypeComparisonInfo(comparisonInfo);
+                }
+
+                var sourceCallSigs = source.getCallSignatures();
+                if (!this.signatureGroupIsRelatableToTarget(source, target, sourceCallSigs, targetCallSigs, assignableTo, comparisonCache, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures)) {
+                    if (comparisonInfo) {
+                        var message;
+                        var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                        if (sourceCallSigs.length && targetCallSigs.length) {
+                            if (comparisonInfoSignatuesTypeCheck && comparisonInfoSignatuesTypeCheck.message) {
+                                message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Call_signatures_of_types_0_and_1_are_incompatible_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfoSignatuesTypeCheck.message]);
+                            } else {
+                                message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Call_signatures_of_types_0_and_1_are_incompatible, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)]);
+                            }
+                        } else {
+                            var hasSig = targetCallSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol);
+                            var lacksSig = !targetCallSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol);
+                            message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_0_requires_a_call_signature_but_type_1_lacks_one, [hasSig, lacksSig]);
+                        }
+                        comparisonInfo.flags |= 4 /* IncompatibleSignatures */;
+                        comparisonInfo.addMessage(message);
+                    }
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.sourceConstructSignaturesAreRelatableToTargetConstructSignatures = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var targetConstructSigs = target.getConstructSignatures();
+            if (targetConstructSigs.length) {
+                var comparisonInfoSignatuesTypeCheck = null;
+                if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) {
+                    comparisonInfoSignatuesTypeCheck = new TypeComparisonInfo(comparisonInfo);
+                }
+
+                var sourceConstructSigs = source.getConstructSignatures();
+                if (!this.signatureGroupIsRelatableToTarget(source, target, sourceConstructSigs, targetConstructSigs, assignableTo, comparisonCache, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures)) {
+                    if (comparisonInfo) {
+                        var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                        var message;
+                        if (sourceConstructSigs.length && targetConstructSigs.length) {
+                            if (comparisonInfoSignatuesTypeCheck && comparisonInfoSignatuesTypeCheck.message) {
+                                message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Construct_signatures_of_types_0_and_1_are_incompatible_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfoSignatuesTypeCheck.message]);
+                            } else {
+                                message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Construct_signatures_of_types_0_and_1_are_incompatible, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)]);
+                            }
+                        } else {
+                            var hasSig = targetConstructSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol);
+                            var lacksSig = !targetConstructSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol);
+                            message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_0_requires_a_construct_signature_but_type_1_lacks_one, [hasSig, lacksSig]);
+                        }
+                        comparisonInfo.flags |= 4 /* IncompatibleSignatures */;
+                        comparisonInfo.addMessage(message);
+                    }
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.sourceIndexSignaturesAreRelatableToTargetIndexSignatures = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var targetIndexSigs = this.getBothKindsOfIndexSignaturesExcludingAugmentedType(target, context);
+            var targetStringSig = targetIndexSigs.stringSignature;
+            var targetNumberSig = targetIndexSigs.numericSignature;
+
+            if (targetStringSig || targetNumberSig) {
+                var sourceIndexSigs = this.getBothKindsOfIndexSignaturesIncludingAugmentedType(source, context);
+                var enclosingTypeIndexSigs = context.getBothKindOfIndexSignatures(true, false);
+                var sourceStringSig = sourceIndexSigs.stringSignature;
+                var sourceNumberSig = sourceIndexSigs.numericSignature;
+
+                var comparable = true;
+                var comparisonInfoSignatuesTypeCheck = null;
+                if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) {
+                    comparisonInfoSignatuesTypeCheck = new TypeComparisonInfo(comparisonInfo);
+                }
+
+                if (targetStringSig) {
+                    if (sourceStringSig) {
+                        context.walkIndexSignatureReturnTypes(enclosingTypeIndexSigs, true, true);
+                        comparable = this.sourceIsRelatableToTargetInEnclosingTypes(sourceStringSig.returnType, targetStringSig.returnType, assignableTo, comparisonCache, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures);
+                        context.postWalkIndexSignatureReturnTypes();
+                    } else {
+                        comparable = false;
+                    }
+                }
+
+                if (comparable && targetNumberSig) {
+                    if (sourceNumberSig) {
+                        context.walkIndexSignatureReturnTypes(enclosingTypeIndexSigs, false, false);
+                        comparable = this.sourceIsRelatableToTargetInEnclosingTypes(sourceNumberSig.returnType, targetNumberSig.returnType, assignableTo, comparisonCache, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures);
+                        context.postWalkIndexSignatureReturnTypes();
+                    } else if (sourceStringSig) {
+                        context.walkIndexSignatureReturnTypes(enclosingTypeIndexSigs, true, false);
+                        comparable = this.sourceIsRelatableToTargetInEnclosingTypes(sourceStringSig.returnType, targetNumberSig.returnType, assignableTo, comparisonCache, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures);
+                        context.postWalkIndexSignatureReturnTypes();
+                    } else {
+                        comparable = false;
+                    }
+                }
+
+                if (!comparable) {
+                    if (comparisonInfo) {
+                        var message;
+                        var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                        if (comparisonInfoSignatuesTypeCheck && comparisonInfoSignatuesTypeCheck.message) {
+                            message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Index_signatures_of_types_0_and_1_are_incompatible_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfoSignatuesTypeCheck.message]);
+                        } else {
+                            message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Index_signatures_of_types_0_and_1_are_incompatible, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)]);
+                        }
+                        comparisonInfo.flags |= 4 /* IncompatibleSignatures */;
+                        comparisonInfo.addMessage(message);
+                    }
+                    return false;
+                }
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.signatureGroupIsRelatableToTarget = function (source, target, sourceSG, targetSG, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            if (sourceSG === targetSG) {
+                return true;
+            }
+
+            if (!(sourceSG.length && targetSG.length)) {
+                return false;
+            }
+
+            var foundMatch = false;
+
+            var targetExcludeDefinition = targetSG.length > 1;
+            var sourceExcludeDefinition = sourceSG.length > 1;
+            var sigsCompared = 0;
+            var comparisonInfoSignatuesTypeCheck = null;
+            if (comparisonInfo) {
+                comparisonInfoSignatuesTypeCheck = new TypeComparisonInfo(comparisonInfo, true);
+                comparisonInfoSignatuesTypeCheck.message = comparisonInfo.message;
+            }
+            for (var iMSig = 0; iMSig < targetSG.length; iMSig++) {
+                var mSig = targetSG[iMSig];
+
+                if (mSig.isStringConstantOverloadSignature() || (targetExcludeDefinition && mSig.isDefinition())) {
+                    continue;
+                }
+
+                for (var iNSig = 0; iNSig < sourceSG.length; iNSig++) {
+                    var nSig = sourceSG[iNSig];
+
+                    if (nSig.isStringConstantOverloadSignature() || (sourceExcludeDefinition && nSig.isDefinition())) {
+                        continue;
+                    }
+
+                    context.walkSignatures(nSig.kind, iNSig, iMSig);
+                    var isSignatureRelatableToTarget = this.signatureIsRelatableToTarget(nSig, mSig, assignableTo, comparisonCache, ast, context, sigsCompared == 0 ? comparisonInfoSignatuesTypeCheck : null, isComparingInstantiatedSignatures);
+                    context.postWalkSignatures();
+
+                    sigsCompared++;
+
+                    if (isSignatureRelatableToTarget) {
+                        foundMatch = true;
+                        break;
+                    }
+                }
+
+                if (foundMatch) {
+                    foundMatch = false;
+                    continue;
+                }
+
+                if (comparisonInfo && sigsCompared == 1) {
+                    comparisonInfo.message = comparisonInfoSignatuesTypeCheck.message;
+                }
+
+                return false;
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.signatureIsRelatableToTarget = function (sourceSig, targetSig, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var isRelatableInfo = this.sourceIsRelatableToTargetInCache(sourceSig, targetSig, comparisonCache, comparisonInfo);
+            if (isRelatableInfo) {
+                return isRelatableInfo.isRelatable;
+            }
+
+            comparisonCache.setValueAt(sourceSig.pullSymbolID, targetSig.pullSymbolID, true);
+            var isRelatable = this.signatureIsRelatableToTargetWorker(sourceSig, targetSig, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+            comparisonCache.setValueAt(sourceSig.pullSymbolID, targetSig.pullSymbolID, isRelatable);
+            return isRelatable;
+        };
+
+        PullTypeResolver.prototype.signatureIsRelatableToTargetWorker = function (sourceSig, targetSig, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) {
+            var _this = this;
+            var sourceParameters = sourceSig.parameters;
+            var targetParameters = targetSig.parameters;
+
+            if (!sourceParameters || !targetParameters) {
+                return false;
+            }
+
+            var targetNonOptionalParamCount = targetSig.nonOptionalParamCount;
+            var sourceNonOptionalParamCount = sourceSig.nonOptionalParamCount;
+
+            if (!targetSig.hasVarArgs && sourceNonOptionalParamCount > targetParameters.length) {
+                if (comparisonInfo) {
+                    comparisonInfo.flags |= 3 /* SourceSignatureHasTooManyParameters */;
+                    comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Call_signature_expects_0_or_fewer_parameters, [targetParameters.length]));
+                }
+                return false;
+            }
+
+            if (this.signaturesAreIdentical(sourceSig, targetSig, context)) {
+                return true;
+            }
+
+            if (targetSig.isGeneric()) {
+                targetSig = this.instantiateSignatureToAny(targetSig);
+            }
+
+            if (sourceSig.isGeneric()) {
+                sourceSig = this.instantiateSignatureToAny(sourceSig);
+            }
+
+            var sourceReturnType = sourceSig.returnType;
+            var targetReturnType = targetSig.returnType;
+
+            if (targetReturnType !== this.semanticInfoChain.voidTypeSymbol) {
+                context.walkReturnTypes();
+                var returnTypesAreRelatable = this.sourceIsRelatableToTargetInEnclosingTypes(sourceReturnType, targetReturnType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+                context.postWalkReturnTypes();
+                if (!returnTypesAreRelatable) {
+                    if (comparisonInfo) {
+                        comparisonInfo.flags |= 16 /* IncompatibleReturnTypes */;
+                    }
+
+                    return false;
+                }
+            }
+
+            return targetSig.forAllCorrespondingParameterTypesInThisAndOtherSignature(sourceSig, function (targetParamType, sourceParamType, iParam) {
+                context.walkParameterTypes(iParam);
+                var areParametersRelatable = _this.sourceIsRelatableToTargetInEnclosingTypes(sourceParamType, targetParamType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+                if (!areParametersRelatable) {
+                    context.swapEnclosingTypeWalkers();
+                    areParametersRelatable = _this.sourceIsRelatableToTargetInEnclosingTypes(targetParamType, sourceParamType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures);
+                    context.swapEnclosingTypeWalkers();
+                }
+                context.postWalkParameterTypes();
+
+                if (!areParametersRelatable) {
+                    if (comparisonInfo) {
+                        comparisonInfo.flags |= 64 /* IncompatibleParameterTypes */;
+                    }
+                }
+
+                return areParametersRelatable;
+            });
+        };
+
+        PullTypeResolver.prototype.resolveOverloads = function (application, group, haveTypeArgumentsAtCallSite, context, diagnostics) {
+            var _this = this;
+            var hasOverloads = group.length > 1;
+            var comparisonInfo = new TypeComparisonInfo();
+            var args = application.argumentList ? application.argumentList.arguments : null;
+
+            var initialCandidates = TypeScript.ArrayUtilities.where(group, function (signature) {
+                if (hasOverloads && signature.isDefinition()) {
+                    return false;
+                }
+
+                var rootSignature = signature.getRootSymbol();
+                if (haveTypeArgumentsAtCallSite && !rootSignature.isGeneric()) {
+                    return false;
+                }
+
+                return _this.overloadHasCorrectArity(signature, args);
+            });
+
+            var firstAssignableButNotSupertypeSignature = null;
+            var firstAssignableWithProvisionalErrorsSignature = null;
+
+            for (var i = 0; i < initialCandidates.length; i++) {
+                var applicability = this.overloadIsApplicable(initialCandidates[i], args, context, comparisonInfo);
+                if (applicability === 3 /* Subtype */) {
+                    return initialCandidates[i];
+                } else if (applicability === 2 /* AssignableWithNoProvisionalErrors */ && !firstAssignableButNotSupertypeSignature) {
+                    firstAssignableButNotSupertypeSignature = initialCandidates[i];
+                } else if (applicability === 1 /* AssignableButWithProvisionalErrors */ && !firstAssignableWithProvisionalErrorsSignature) {
+                    firstAssignableWithProvisionalErrorsSignature = initialCandidates[i];
+                }
+            }
+
+            if (firstAssignableButNotSupertypeSignature || firstAssignableWithProvisionalErrorsSignature) {
+                return firstAssignableButNotSupertypeSignature || firstAssignableWithProvisionalErrorsSignature;
+            } else {
+                var target = this.getCallTargetErrorSpanAST(application);
+                if (comparisonInfo.message) {
+                    diagnostics.push(this.semanticInfoChain.diagnosticFromAST(target, TypeScript.DiagnosticCode.Supplied_parameters_do_not_match_any_signature_of_call_target_NL_0, [comparisonInfo.message]));
+                } else {
+                    diagnostics.push(this.semanticInfoChain.diagnosticFromAST(target, TypeScript.DiagnosticCode.Supplied_parameters_do_not_match_any_signature_of_call_target, null));
+                }
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.getCallTargetErrorSpanAST = function (callEx) {
+            return (callEx.expression.kind() === 212 /* MemberAccessExpression */) ? callEx.expression.name : callEx.expression;
+        };
+
+        PullTypeResolver.prototype.overloadHasCorrectArity = function (signature, args) {
+            if (args == null) {
+                return signature.nonOptionalParamCount === 0;
+            }
+
+            var numberOfArgs = (args.nonSeparatorCount() && args.nonSeparatorCount() === args.separatorCount()) ? args.separatorCount() + 1 : args.nonSeparatorCount();
+            if (numberOfArgs < signature.nonOptionalParamCount) {
+                return false;
+            }
+            if (!signature.hasVarArgs && numberOfArgs > signature.parameters.length) {
+                return false;
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.overloadIsApplicable = function (signature, args, context, comparisonInfo) {
+            if (args === null) {
+                return 3 /* Subtype */;
+            }
+
+            var isInVarArg = false;
+            var parameters = signature.parameters;
+            var paramType = null;
+
+            var overloadApplicability = 3 /* Subtype */;
+
+            for (var i = 0; i < args.nonSeparatorCount(); i++) {
+                if (!isInVarArg) {
+                    this.resolveDeclaredSymbol(parameters[i], context);
+
+                    if (parameters[i].isVarArg) {
+                        paramType = parameters[i].type.getElementType() || this.getNewErrorTypeSymbol(parameters[i].type.getName());
+                        isInVarArg = true;
+                    } else {
+                        paramType = parameters[i].type;
+                    }
+                }
+
+                var statusOfCurrentArgument = this.overloadIsApplicableForArgument(paramType, args.nonSeparatorAt(i), i, context, comparisonInfo);
+
+                if (statusOfCurrentArgument === 0 /* NotAssignable */) {
+                    return 0 /* NotAssignable */;
+                } else if (statusOfCurrentArgument === 1 /* AssignableButWithProvisionalErrors */) {
+                    overloadApplicability = 1 /* AssignableButWithProvisionalErrors */;
+                } else if (overloadApplicability !== 1 /* AssignableButWithProvisionalErrors */ && statusOfCurrentArgument === 2 /* AssignableWithNoProvisionalErrors */) {
+                    overloadApplicability = 2 /* AssignableWithNoProvisionalErrors */;
+                }
+            }
+
+            return overloadApplicability;
+        };
+
+        PullTypeResolver.prototype.overloadIsApplicableForArgument = function (paramType, arg, argIndex, context, comparisonInfo) {
+            if (paramType.isAny()) {
+                return 3 /* Subtype */;
+            } else if (paramType.isError()) {
+                return 1 /* AssignableButWithProvisionalErrors */;
+            } else if (arg.kind() === 219 /* SimpleArrowFunctionExpression */) {
+                var simpleArrowFunction = arg;
+                return this.overloadIsApplicableForAnyFunctionExpressionArgument(paramType, arg, null, TypeScript.ASTHelpers.parametersFromIdentifier(simpleArrowFunction.identifier), null, simpleArrowFunction.block, simpleArrowFunction.expression, argIndex, context, comparisonInfo);
+            } else if (arg.kind() === 218 /* ParenthesizedArrowFunctionExpression */) {
+                var arrowFunction = arg;
+                return this.overloadIsApplicableForAnyFunctionExpressionArgument(paramType, arg, arrowFunction.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(arrowFunction.callSignature.parameterList), TypeScript.ASTHelpers.getType(arrowFunction), arrowFunction.block, arrowFunction.expression, argIndex, context, comparisonInfo);
+            } else if (arg.kind() === 222 /* FunctionExpression */) {
+                var functionExpression = arg;
+                return this.overloadIsApplicableForAnyFunctionExpressionArgument(paramType, arg, functionExpression.callSignature.typeParameterList, TypeScript.ASTHelpers.parametersFromParameterList(functionExpression.callSignature.parameterList), TypeScript.ASTHelpers.getType(functionExpression), functionExpression.block, null, argIndex, context, comparisonInfo);
+            } else if (arg.kind() === 215 /* ObjectLiteralExpression */) {
+                return this.overloadIsApplicableForObjectLiteralArgument(paramType, arg, argIndex, context, comparisonInfo);
+            } else if (arg.kind() === 214 /* ArrayLiteralExpression */) {
+                return this.overloadIsApplicableForArrayLiteralArgument(paramType, arg, argIndex, context, comparisonInfo);
+            } else {
+                return this.overloadIsApplicableForOtherArgument(paramType, arg, argIndex, context, comparisonInfo);
+            }
+        };
+
+        PullTypeResolver.prototype.overloadIsApplicableForAnyFunctionExpressionArgument = function (paramType, arg, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, argIndex, context, comparisonInfo) {
+            if (this.cachedFunctionInterfaceType() && paramType === this.cachedFunctionInterfaceType()) {
+                return 2 /* AssignableWithNoProvisionalErrors */;
+            }
+
+            context.pushProvisionalType(paramType);
+
+            var argSym = this.resolveAnyFunctionExpression(arg, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, true, context);
+
+            var applicabilityStatus = this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context);
+
+            context.popAnyContextualType();
+
+            return applicabilityStatus;
+        };
+
+        PullTypeResolver.prototype.overloadIsApplicableForObjectLiteralArgument = function (paramType, arg, argIndex, context, comparisonInfo) {
+            if (this.cachedObjectInterfaceType() && paramType === this.cachedObjectInterfaceType()) {
+                return 2 /* AssignableWithNoProvisionalErrors */;
+            }
+
+            context.pushProvisionalType(paramType);
+            var argSym = this.resolveObjectLiteralExpression(arg, true, context);
+
+            var applicabilityStatus = this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context);
+
+            context.popAnyContextualType();
+
+            return applicabilityStatus;
+        };
+
+        PullTypeResolver.prototype.overloadIsApplicableForArrayLiteralArgument = function (paramType, arg, argIndex, context, comparisonInfo) {
+            if (paramType === this.cachedArrayInterfaceType()) {
+                return 2 /* AssignableWithNoProvisionalErrors */;
+            }
+
+            context.pushProvisionalType(paramType);
+            var argSym = this.resolveArrayLiteralExpression(arg, true, context);
+
+            var applicabilityStatus = this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context);
+
+            context.popAnyContextualType();
+
+            return applicabilityStatus;
+        };
+
+        PullTypeResolver.prototype.overloadIsApplicableForOtherArgument = function (paramType, arg, argIndex, context, comparisonInfo) {
+            var argSym = this.resolveAST(arg, false, context);
+
+            if (argSym.type.isAlias()) {
+                var aliasSym = argSym.type;
+                argSym = aliasSym.getExportAssignedTypeSymbol();
+            }
+
+            comparisonInfo.stringConstantVal = arg;
+            return this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context);
+        };
+
+        PullTypeResolver.prototype.overloadIsApplicableForArgumentHelper = function (paramType, argSym, argumentIndex, comparisonInfo, arg, context) {
+            var tempComparisonInfo = new TypeComparisonInfo();
+            tempComparisonInfo.stringConstantVal = comparisonInfo.stringConstantVal;
+            if (!context.hasProvisionalErrors() && this.sourceIsSubtypeOfTarget(argSym.type, paramType, arg, context, tempComparisonInfo)) {
+                return 3 /* Subtype */;
+            }
+
+            if (this.sourceIsAssignableToTarget(argSym.type, paramType, arg, context, comparisonInfo.message ? tempComparisonInfo : comparisonInfo)) {
+                return context.hasProvisionalErrors() ? 1 /* AssignableButWithProvisionalErrors */ : 2 /* AssignableWithNoProvisionalErrors */;
+            }
+
+            if (!comparisonInfo.message) {
+                var enclosingSymbol = this.getEnclosingSymbolForAST(arg);
+                comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Could_not_apply_type_0_to_argument_1_which_is_of_type_2, [paramType.toString(enclosingSymbol), (argumentIndex + 1), argSym.getTypeName(enclosingSymbol)]));
+            }
+
+            return 0 /* NotAssignable */;
+        };
+
+        PullTypeResolver.prototype.inferArgumentTypesForSignature = function (argContext, comparisonInfo, context) {
+            var inferenceResultTypes = argContext.inferTypeArguments();
+            var typeParameters = argContext.signatureBeingInferred.getTypeParameters();
+            TypeScript.Debug.assert(typeParameters.length == inferenceResultTypes.length);
+
+            var typeReplacementMapForConstraints = null;
+            for (var i = 0; i < inferenceResultTypes.length; i++) {
+                if (typeParameters[i].getConstraint()) {
+                    typeReplacementMapForConstraints = typeReplacementMapForConstraints || TypeScript.PullInstantiationHelpers.createTypeParameterArgumentMap(typeParameters, inferenceResultTypes);
+                    var associatedConstraint = this.instantiateType(typeParameters[i].getConstraint(), typeReplacementMapForConstraints);
+                    if (!this.sourceIsAssignableToTargetWithNewEnclosingTypes(inferenceResultTypes[i], associatedConstraint, null, context, null, false)) {
+                        inferenceResultTypes[i] = associatedConstraint;
+                    }
+                }
+            }
+
+            if (argContext.isInvocationInferenceContext()) {
+                var invocationContext = argContext;
+                if (!this.typeParametersAreInScopeAtArgumentList(typeParameters, invocationContext.argumentASTs)) {
+                    for (var i = 0; i < inferenceResultTypes.length; i++) {
+                        if (inferenceResultTypes[i].wrapsSomeTypeParameter(argContext.candidateCache)) {
+                            inferenceResultTypes[i] = this.semanticInfoChain.anyTypeSymbol;
+                        }
+                    }
+                }
+            }
+
+            return inferenceResultTypes;
+        };
+
+        PullTypeResolver.prototype.typeParametersAreInScopeAtArgumentList = function (typeParameters, args) {
+            var enclosingDecl = this.getEnclosingDeclForAST(args);
+            var typeParameterParentDecl = typeParameters[0].getDeclarations()[0].getParentDecl();
+            return enclosingDecl.getParentPath().indexOf(typeParameterParentDecl) > -1;
+        };
+
+        PullTypeResolver.prototype.relateTypeToTypeParametersInEnclosingType = function (expressionType, parameterType, argContext, context) {
+            if (expressionType && parameterType) {
+                if (context.oneOfClassificationsIsInfinitelyExpanding()) {
+                    this.relateInifinitelyExpandingTypeToTypeParameters(expressionType, parameterType, argContext, context);
+                    return;
+                }
+            }
+            this.relateTypeToTypeParameters(expressionType, parameterType, argContext, context);
+        };
+
+        PullTypeResolver.prototype.relateTypeToTypeParametersWithNewEnclosingTypes = function (expressionType, parameterType, argContext, context) {
+            var enclosingTypeWalkers = context.resetEnclosingTypeWalkers();
+            this.relateTypeToTypeParameters(expressionType, parameterType, argContext, context);
+            context.setEnclosingTypeWalkers(enclosingTypeWalkers);
+        };
+
+        PullTypeResolver.prototype.relateTypeToTypeParameters = function (expressionType, parameterType, argContext, context) {
+            if (!expressionType || !parameterType) {
+                return;
+            }
+
+            if (expressionType.isError()) {
+                expressionType = this.semanticInfoChain.anyTypeSymbol;
+            }
+
+            if (parameterType.isTypeParameter()) {
+                var typeParameter = parameterType;
+                argContext.addCandidateForInference(typeParameter, expressionType);
+                return;
+            }
+
+            if (parameterType.isNamedTypeSymbol() && !parameterType.isGeneric() && !parameterType.getTypeArguments()) {
+                return;
+            }
+
+            if (TypeScript.PullInstantiationHelpers.twoTypesAreInstantiationsOfSameNamedGenericType(expressionType, parameterType)) {
+                this.relateTypeArgumentsOfTypeToTypeParameters(expressionType, parameterType, argContext, context);
+            } else {
+                var symbolsWhenStartedWalkingTypes = context.startWalkingTypes(expressionType, parameterType);
+                this.relateObjectTypeToTypeParameters(expressionType, parameterType, argContext, context);
+                context.endWalkingTypes(symbolsWhenStartedWalkingTypes);
+            }
+        };
+
+        PullTypeResolver.prototype.relateTypeArgumentsOfTypeToTypeParameters = function (expressionType, parameterType, argContext, context) {
+            var parameterSideTypeArguments = parameterType.getTypeArguments();
+            var argumentSideTypeArguments = expressionType.getTypeArguments();
+
+            TypeScript.Debug.assert(parameterSideTypeArguments && argumentSideTypeArguments && parameterSideTypeArguments.length === argumentSideTypeArguments.length);
+            for (var i = 0; i < parameterSideTypeArguments.length; i++) {
+                this.relateTypeToTypeParametersWithNewEnclosingTypes(argumentSideTypeArguments[i], parameterSideTypeArguments[i], argContext, context);
+            }
+        };
+
+        PullTypeResolver.prototype.relateInifinitelyExpandingTypeToTypeParameters = function (expressionType, parameterType, argContext, context) {
+            if (!expressionType || !parameterType) {
+                return;
+            }
+
+            var expressionTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(expressionType);
+            var parameterTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(parameterType);
+            if (expressionTypeNamedTypeReference !== parameterTypeNamedTypeReference) {
+                return;
+            }
+
+            var expressionTypeTypeArguments = expressionType.getTypeArguments();
+            var parameterTypeArguments = parameterType.getTypeArguments();
+
+            if (expressionTypeTypeArguments && parameterTypeArguments && expressionTypeTypeArguments.length === parameterTypeArguments.length) {
+                for (var i = 0; i < expressionTypeTypeArguments.length; i++) {
+                    this.relateTypeArgumentsOfTypeToTypeParameters(expressionType, parameterType, argContext, context);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.relateFunctionSignatureToTypeParameters = function (expressionSignature, parameterSignature, argContext, context) {
+            var _this = this;
+            var expressionReturnType = expressionSignature.returnType;
+            var parameterReturnType = parameterSignature.returnType;
+
+            parameterSignature.forAllCorrespondingParameterTypesInThisAndOtherSignature(expressionSignature, function (parameterSignatureParameterType, expressionSignatureParameterType, i) {
+                context.walkParameterTypes(i);
+                _this.relateTypeToTypeParametersInEnclosingType(expressionSignatureParameterType, parameterSignatureParameterType, argContext, context);
+                context.postWalkParameterTypes();
+                return true;
+            });
+
+            context.walkReturnTypes();
+            this.relateTypeToTypeParametersInEnclosingType(expressionReturnType, parameterReturnType, argContext, context);
+            context.postWalkReturnTypes();
+        };
+
+        PullTypeResolver.prototype.relateObjectTypeToTypeParameters = function (objectType, parameterType, argContext, context) {
+            var parameterTypeMembers = parameterType.getMembers();
+            var parameterSignatures;
+
+            var objectMember;
+            var objectSignatures;
+
+            if (argContext.alreadyRelatingTypes(objectType, parameterType)) {
+                return;
+            }
+
+            for (var i = 0; i < parameterTypeMembers.length; i++) {
+                objectMember = this.getNamedPropertySymbol(parameterTypeMembers[i].name, 68147712 /* SomeValue */, objectType);
+                if (objectMember) {
+                    this.resolveDeclaredSymbol(objectMember);
+                    this.resolveDeclaredSymbol(parameterTypeMembers[i]);
+                    context.walkMemberTypes(parameterTypeMembers[i].name);
+                    this.relateTypeToTypeParametersInEnclosingType(objectMember.type, parameterTypeMembers[i].type, argContext, context);
+                    context.postWalkMemberTypes();
+                }
+            }
+
+            this.relateSignatureGroupToTypeParameters(objectType.getCallSignatures(), parameterType.getCallSignatures(), 1048576 /* CallSignature */, argContext, context);
+
+            this.relateSignatureGroupToTypeParameters(objectType.getConstructSignatures(), parameterType.getConstructSignatures(), 2097152 /* ConstructSignature */, argContext, context);
+
+            var parameterIndexSignatures = this.getBothKindsOfIndexSignaturesExcludingAugmentedType(parameterType, context);
+            var objectIndexSignatures = this.getBothKindsOfIndexSignaturesExcludingAugmentedType(objectType, context);
+            var indexSigInfo = context.getBothKindOfIndexSignatures(false, false);
+
+            if (parameterIndexSignatures.stringSignature && objectIndexSignatures.stringSignature) {
+                context.walkIndexSignatureReturnTypes(indexSigInfo, true, true, true);
+                this.relateFunctionSignatureToTypeParameters(objectIndexSignatures.stringSignature, parameterIndexSignatures.stringSignature, argContext, context);
+                context.postWalkIndexSignatureReturnTypes(true);
+            }
+            if (parameterIndexSignatures.numericSignature && objectIndexSignatures.numericSignature) {
+                context.walkIndexSignatureReturnTypes(indexSigInfo, false, false, true);
+                this.relateFunctionSignatureToTypeParameters(objectIndexSignatures.numericSignature, parameterIndexSignatures.numericSignature, argContext, context);
+                context.postWalkIndexSignatureReturnTypes(true);
+            }
+        };
+
+        PullTypeResolver.prototype.relateSignatureGroupToTypeParameters = function (argumentSignatures, parameterSignatures, signatureKind, argContext, context) {
+            for (var i = 0; i < parameterSignatures.length; i++) {
+                var paramSignature = parameterSignatures[i];
+                if (argumentSignatures.length > 0 && paramSignature.isGeneric()) {
+                    paramSignature = this.instantiateSignatureToAny(paramSignature);
+                }
+                for (var j = 0; j < argumentSignatures.length; j++) {
+                    var argumentSignature = argumentSignatures[j];
+                    if (argumentSignature.nonOptionalParamCount > paramSignature.nonOptionalParamCount) {
+                        continue;
+                    }
+
+                    if (argumentSignature.isGeneric()) {
+                        argumentSignature = this.instantiateSignatureToAny(argumentSignature);
+                    }
+
+                    context.walkSignatures(signatureKind, j, i);
+                    this.relateFunctionSignatureToTypeParameters(argumentSignature, paramSignature, argContext, context);
+                    context.postWalkSignatures();
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.alterPotentialGenericFunctionTypeToInstantiatedFunctionTypeForTypeArgumentInference = function (expressionSymbol, context) {
+            var inferentialType = context.getContextualType();
+            TypeScript.Debug.assert(inferentialType);
+            var expressionType = expressionSymbol.type;
+            if (this.isFunctionTypeWithExactlyOneCallSignatureAndNoOtherMembers(expressionType, true) && this.isFunctionTypeWithExactlyOneCallSignatureAndNoOtherMembers(inferentialType, false)) {
+                var genericExpressionSignature = expressionType.getCallSignatures()[0];
+                var contextualSignature = inferentialType.getCallSignatures()[0];
+
+                var instantiatedSignature = this.instantiateSignatureInContext(genericExpressionSignature, contextualSignature, context, true);
+                if (instantiatedSignature === null) {
+                    return expressionSymbol;
+                }
+
+                var newType = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */);
+                newType.appendCallSignature(instantiatedSignature);
+                return newType;
+            }
+
+            return expressionSymbol;
+        };
+
+        PullTypeResolver.prototype.isFunctionTypeWithExactlyOneCallSignatureAndNoOtherMembers = function (type, callSignatureShouldBeGeneric) {
+            TypeScript.Debug.assert(type);
+            if (type.getCallSignatures().length !== 1) {
+                return false;
+            }
+
+            var callSignatureIsGeneric = type.getCallSignatures()[0].isGeneric();
+            if (callSignatureIsGeneric !== callSignatureShouldBeGeneric) {
+                return false;
+            }
+
+            var typeHasOtherMembers = type.getConstructSignatures().length || type.getIndexSignatures().length || type.getAllMembers(68147712 /* SomeValue */, 0 /* all */).length;
+            if (typeHasOtherMembers) {
+                return false;
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.instantiateTypeToAny = function (typeToSpecialize, context) {
+            var typeParameters = typeToSpecialize.getTypeParameters();
+
+            if (!typeParameters.length) {
+                return typeToSpecialize;
+            }
+
+            var typeArguments = null;
+
+            if (!this._cachedAnyTypeArgs) {
+                this._cachedAnyTypeArgs = [
+                    [this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol]
+                ];
+            }
+
+            if (typeParameters.length < this._cachedAnyTypeArgs.length) {
+                typeArguments = this._cachedAnyTypeArgs[typeParameters.length - 1];
+            } else {
+                typeArguments = [];
+
+                for (var i = 0; i < typeParameters.length; i++) {
+                    typeArguments[typeArguments.length] = this.semanticInfoChain.anyTypeSymbol;
+                }
+            }
+
+            var type = this.createInstantiatedType(typeToSpecialize, typeArguments);
+
+            return type;
+        };
+
+        PullTypeResolver.prototype.instantiateSignatureToAny = function (signature) {
+            var typeParameters = signature.getTypeParameters();
+            if (!this._cachedAnyTypeArgs) {
+                this._cachedAnyTypeArgs = [
+                    [this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol],
+                    [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol]
+                ];
+            }
+
+            if (typeParameters.length < this._cachedAnyTypeArgs.length) {
+                var typeArguments = this._cachedAnyTypeArgs[typeParameters.length - 1];
+            } else {
+                var typeArguments = [];
+
+                for (var i = 0; i < typeParameters.length; i++) {
+                    typeArguments[typeArguments.length] = this.semanticInfoChain.anyTypeSymbol;
+                }
+            }
+
+            var typeParameterArgumentMap = TypeScript.PullInstantiationHelpers.createTypeParameterArgumentMap(typeParameters, typeArguments);
+            return this.instantiateSignature(signature, typeParameterArgumentMap);
+        };
+
+        PullTypeResolver.typeCheck = function (compilationSettings, semanticInfoChain, document) {
+            var sourceUnit = document.sourceUnit();
+
+            var resolver = semanticInfoChain.getResolver();
+            var context = new TypeScript.PullTypeResolutionContext(resolver, true, sourceUnit.fileName());
+
+            if (resolver.canTypeCheckAST(sourceUnit, context)) {
+                resolver.resolveAST(sourceUnit, false, context);
+                resolver.validateVariableDeclarationGroups(semanticInfoChain.getDeclForAST(sourceUnit), context);
+
+                while (resolver.typeCheckCallBacks.length) {
+                    var callBack = resolver.typeCheckCallBacks.pop();
+                    callBack(context);
+                }
+
+                resolver.processPostTypeCheckWorkItems(context);
+            }
+        };
+
+        PullTypeResolver.prototype.validateVariableDeclarationGroups = function (enclosingDecl, context) {
+            var _this = this;
+            this.scanVariableDeclarationGroups(enclosingDecl, function (_) {
+            }, function (subsequentDecl, firstSymbol) {
+                if (TypeScript.hasFlag(subsequentDecl.kind, 2048 /* Parameter */) || TypeScript.hasFlag(subsequentDecl.flags, 8388608 /* PropertyParameter */)) {
+                    return;
+                }
+
+                var boundDeclAST = _this.semanticInfoChain.getASTForDecl(subsequentDecl);
+
+                var symbol = subsequentDecl.getSymbol();
+                var symbolType = symbol.type;
+                var firstSymbolType = firstSymbol.type;
+
+                if (symbolType && firstSymbolType && symbolType !== firstSymbolType && !_this.typesAreIdentical(symbolType, firstSymbolType, context)) {
+                    context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(boundDeclAST, TypeScript.DiagnosticCode.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2, [symbol.getScopedName(), firstSymbolType.toString(firstSymbol), symbolType.toString(symbol)]));
+                }
+            });
+        };
+
+        PullTypeResolver.prototype.typeCheckFunctionOverloads = function (funcDecl, context, signature, allSignatures) {
+            if (!signature) {
+                var functionSignatureInfo = TypeScript.PullHelpers.getSignatureForFuncDecl(this.semanticInfoChain.getDeclForAST(funcDecl));
+                signature = functionSignatureInfo.signature;
+                allSignatures = functionSignatureInfo.allSignatures;
+            }
+            var functionDeclaration = this.semanticInfoChain.getDeclForAST(funcDecl);
+            var funcSymbol = functionDeclaration.getSymbol();
+
+            var definitionSignature = null;
+            for (var i = allSignatures.length - 1; i >= 0; i--) {
+                if (allSignatures[i].isDefinition()) {
+                    definitionSignature = allSignatures[i];
+                    break;
+                }
+            }
+
+            if (!signature.isDefinition()) {
+                var signatureParentDecl = signature.getDeclarations()[0].getParentDecl();
+                for (var i = 0; i < allSignatures.length; i++) {
+                    if (allSignatures[i] === signature) {
+                        break;
+                    }
+
+                    var allSignaturesParentDecl = allSignatures[i].getDeclarations()[0].getParentDecl();
+                    if (allSignaturesParentDecl !== signatureParentDecl) {
+                        continue;
+                    }
+
+                    if (this.signaturesAreIdenticalWithNewEnclosingTypes(allSignatures[i], signature, context, false)) {
+                        if (!this.signatureReturnTypesAreIdentical(allSignatures[i], signature, context)) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overloads_cannot_differ_only_by_return_type));
+                        } else if (funcDecl.kind() === 137 /* ConstructorDeclaration */) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_constructor_overload_signature));
+                        } else if (functionDeclaration.kind === 2097152 /* ConstructSignature */) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_overload_construct_signature));
+                        } else if (functionDeclaration.kind === 1048576 /* CallSignature */) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_overload_call_signature));
+                        } else {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_overload_signature_for_0, [funcSymbol.getScopedNameEx().toString()]));
+                        }
+
+                        break;
+                    }
+                }
+            }
+
+            var isConstantOverloadSignature = signature.isStringConstantOverloadSignature();
+            if (isConstantOverloadSignature) {
+                if (signature.isDefinition()) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overload_signature_implementation_cannot_use_specialized_type));
+                } else {
+                    var foundSubtypeSignature = false;
+                    for (var i = 0; i < allSignatures.length; i++) {
+                        if (allSignatures[i].isDefinition() || allSignatures[i] === signature) {
+                            continue;
+                        }
+
+                        if (!allSignatures[i].isResolved) {
+                            this.resolveDeclaredSymbol(allSignatures[i], context);
+                        }
+
+                        if (allSignatures[i].isStringConstantOverloadSignature()) {
+                            continue;
+                        }
+
+                        if (this.signatureIsAssignableToTarget(signature, allSignatures[i], null, context)) {
+                            foundSubtypeSignature = true;
+                            break;
+                        }
+                    }
+
+                    if (!foundSubtypeSignature) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature));
+                    }
+                }
+            } else if (definitionSignature && definitionSignature !== signature) {
+                var comparisonInfo = new TypeComparisonInfo();
+
+                if (!definitionSignature.isResolved) {
+                    this.resolveDeclaredSymbol(definitionSignature, context);
+                }
+
+                if (!this.signatureIsAssignableToTarget(definitionSignature, signature, funcDecl, context, comparisonInfo)) {
+                    if (comparisonInfo.message) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overload_signature_is_not_compatible_with_function_definition_NL_0, [comparisonInfo.message]));
+                    } else {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overload_signature_is_not_compatible_with_function_definition));
+                    }
+                }
+            }
+
+            var signatureForVisibilityCheck = definitionSignature;
+            if (!definitionSignature) {
+                if (allSignatures[0] === signature) {
+                    return;
+                }
+                signatureForVisibilityCheck = allSignatures[0];
+            }
+
+            if (funcDecl.kind() !== 137 /* ConstructorDeclaration */ && functionDeclaration.kind !== 2097152 /* ConstructSignature */ && signatureForVisibilityCheck && signature !== signatureForVisibilityCheck) {
+                var errorCode;
+
+                if (signatureForVisibilityCheck.anyDeclHasFlag(2 /* Private */) !== signature.anyDeclHasFlag(2 /* Private */)) {
+                    errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_public_or_private;
+                } else if (signatureForVisibilityCheck.anyDeclHasFlag(1 /* Exported */) !== signature.anyDeclHasFlag(1 /* Exported */)) {
+                    errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_exported_or_not_exported;
+                } else if (signatureForVisibilityCheck.anyDeclHasFlag(8 /* Ambient */) !== signature.anyDeclHasFlag(8 /* Ambient */)) {
+                    errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_ambient_or_non_ambient;
+                } else if (signatureForVisibilityCheck.anyDeclHasFlag(128 /* Optional */) !== signature.anyDeclHasFlag(128 /* Optional */)) {
+                    errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_optional_or_required;
+                }
+
+                if (errorCode) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, errorCode));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.checkSymbolPrivacy = function (declSymbol, symbol, privacyErrorReporter) {
+            if (!symbol || symbol.kind === 2 /* Primitive */) {
+                return;
+            }
+
+            if (symbol.isType()) {
+                var typeSymbol = symbol;
+                var isNamedType = typeSymbol.isNamedTypeSymbol();
+
+                if (typeSymbol.isArrayNamedTypeReference()) {
+                    this.checkSymbolPrivacy(declSymbol, typeSymbol.getElementType(), privacyErrorReporter);
+                    return;
+                }
+
+                if (!isNamedType) {
+                    var typeOfSymbol = typeSymbol.getTypeOfSymbol();
+                    if (typeOfSymbol) {
+                        this.checkSymbolPrivacy(declSymbol, typeOfSymbol, privacyErrorReporter);
+                        return;
+                    }
+                }
+
+                if (typeSymbol.inSymbolPrivacyCheck) {
+                    return;
+                }
+
+                typeSymbol.inSymbolPrivacyCheck = true;
+
+                var typars = typeSymbol.getTypeArgumentsOrTypeParameters();
+                if (typars) {
+                    for (var i = 0; i < typars.length; i++) {
+                        this.checkSymbolPrivacy(declSymbol, typars[i], privacyErrorReporter);
+                    }
+                }
+
+                if (!isNamedType) {
+                    var members = typeSymbol.getMembers();
+                    for (var i = 0; i < members.length; i++) {
+                        this.checkSymbolPrivacy(declSymbol, members[i].type, privacyErrorReporter);
+                    }
+
+                    this.checkTypePrivacyOfSignatures(declSymbol, typeSymbol.getCallSignatures(), privacyErrorReporter);
+                    this.checkTypePrivacyOfSignatures(declSymbol, typeSymbol.getConstructSignatures(), privacyErrorReporter);
+                    this.checkTypePrivacyOfSignatures(declSymbol, typeSymbol.getIndexSignatures(), privacyErrorReporter);
+                } else if (typeSymbol.kind === 8192 /* TypeParameter */) {
+                    this.checkSymbolPrivacy(declSymbol, typeSymbol.getConstraint(), privacyErrorReporter);
+                }
+
+                typeSymbol.inSymbolPrivacyCheck = false;
+
+                if (!isNamedType) {
+                    return;
+                }
+            }
+
+            if (declSymbol.isExternallyVisible()) {
+                var symbolIsVisible = symbol.isExternallyVisible();
+
+                if (symbolIsVisible && symbol.kind !== 8192 /* TypeParameter */) {
+                    var symbolPath = symbol.pathToRoot();
+                    var declSymbolPath = declSymbol.pathToRoot();
+
+                    if (symbolPath[symbolPath.length - 1].kind === 32 /* DynamicModule */ && declSymbolPath[declSymbolPath.length - 1].kind === 32 /* DynamicModule */ && declSymbolPath[declSymbolPath.length - 1] !== symbolPath[symbolPath.length - 1]) {
+                        symbolIsVisible = false;
+                        var declSymbolScope = declSymbolPath[declSymbolPath.length - 1];
+                        for (var i = symbolPath.length - 1; i >= 0; i--) {
+                            var aliasSymbols = symbolPath[i].getExternalAliasedSymbols(declSymbolScope);
+                            if (aliasSymbols) {
+                                symbolIsVisible = true;
+                                aliasSymbols[0].setTypeUsedExternally();
+                                break;
+                            }
+                        }
+                        symbol = symbolPath[symbolPath.length - 1];
+                    }
+                } else if (symbol.kind === 128 /* TypeAlias */) {
+                    var aliasSymbol = symbol;
+                    symbolIsVisible = true;
+                    aliasSymbol.setTypeUsedExternally();
+                }
+
+                if (!symbolIsVisible) {
+                    privacyErrorReporter(symbol);
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.checkTypePrivacyOfSignatures = function (declSymbol, signatures, privacyErrorReporter) {
+            for (var i = 0; i < signatures.length; i++) {
+                var signature = signatures[i];
+                if (signatures.length > 1 && signature.isDefinition()) {
+                    continue;
+                }
+
+                var typeParams = signature.getTypeParameters();
+                for (var j = 0; j < typeParams.length; j++) {
+                    this.checkSymbolPrivacy(declSymbol, typeParams[j], privacyErrorReporter);
+                }
+
+                var params = signature.parameters;
+                for (var j = 0; j < params.length; j++) {
+                    var paramType = params[j].type;
+                    this.checkSymbolPrivacy(declSymbol, paramType, privacyErrorReporter);
+                }
+
+                var returnType = signature.returnType;
+                this.checkSymbolPrivacy(declSymbol, returnType, privacyErrorReporter);
+            }
+        };
+
+        PullTypeResolver.prototype.typeParameterOfTypeDeclarationPrivacyErrorReporter = function (classOrInterface, typeParameterAST, typeParameter, symbol, context) {
+            var decl = this.semanticInfoChain.getDeclForAST(classOrInterface);
+            var enclosingDecl = this.getEnclosingDecl(decl);
+            var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null;
+            var messageCode;
+
+            var typeParameters = classOrInterface.kind() === 131 /* ClassDeclaration */ ? classOrInterface.typeParameterList : classOrInterface.typeParameterList;
+
+            var typeSymbol = symbol;
+            var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol);
+            if (typeSymbol.isContainer() && !typeSymbol.isEnum()) {
+                if (!TypeScript.isQuoted(typeSymbolName)) {
+                    typeSymbolName = "'" + typeSymbolName + "'";
+                }
+                if (classOrInterface.kind() === 131 /* ClassDeclaration */) {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_class_is_using_inaccessible_module_1;
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_interface_is_using_inaccessible_module_1;
+                }
+            } else {
+                if (classOrInterface.kind() === 131 /* ClassDeclaration */) {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_class_has_or_is_using_private_type_1;
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_interface_has_or_is_using_private_type_1;
+                }
+            }
+
+            var messageArguments = [typeParameter.getScopedName(enclosingSymbol, false, true), typeSymbolName];
+            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeParameterAST, messageCode, messageArguments));
+        };
+
+        PullTypeResolver.prototype.baseListPrivacyErrorReporter = function (classOrInterface, declSymbol, baseAst, isExtendedType, symbol, context) {
+            var decl = this.semanticInfoChain.getDeclForAST(classOrInterface);
+            var enclosingDecl = this.getEnclosingDecl(decl);
+            var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null;
+            var messageCode;
+
+            var typeSymbol = symbol;
+            var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol);
+            if (typeSymbol.isContainer() && !typeSymbol.isEnum()) {
+                if (!TypeScript.isQuoted(typeSymbolName)) {
+                    typeSymbolName = "'" + typeSymbolName + "'";
+                }
+                if (classOrInterface.kind() === 131 /* ClassDeclaration */) {
+                    if (isExtendedType) {
+                        messageCode = TypeScript.DiagnosticCode.Exported_class_0_extends_class_from_inaccessible_module_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Exported_class_0_implements_interface_from_inaccessible_module_1;
+                    }
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.Exported_interface_0_extends_interface_from_inaccessible_module_1;
+                }
+            } else {
+                if (classOrInterface.kind() === 131 /* ClassDeclaration */) {
+                    if (isExtendedType) {
+                        messageCode = TypeScript.DiagnosticCode.Exported_class_0_extends_private_class_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Exported_class_0_implements_private_interface_1;
+                    }
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.Exported_interface_0_extends_private_interface_1;
+                }
+            }
+
+            var messageArguments = [declSymbol.getScopedName(enclosingSymbol), typeSymbolName];
+            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseAst, messageCode, messageArguments));
+        };
+
+        PullTypeResolver.prototype.variablePrivacyErrorReporter = function (declAST, declSymbol, symbol, context) {
+            var typeSymbol = symbol;
+            var enclosingDecl = this.getEnclosingDecl(declSymbol.getDeclarations()[0]);
+            var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null;
+
+            var isProperty = declSymbol.kind === 4096 /* Property */;
+            var isPropertyOfClass = false;
+            var declParent = declSymbol.getContainer();
+            if (declParent && (declParent.kind === 8 /* Class */ || declParent.kind === 32768 /* ConstructorMethod */)) {
+                isPropertyOfClass = true;
+            }
+
+            var messageCode;
+            var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol);
+            if (typeSymbol.isContainer() && !typeSymbol.isEnum()) {
+                if (!TypeScript.isQuoted(typeSymbolName)) {
+                    typeSymbolName = "'" + typeSymbolName + "'";
+                }
+
+                if (declSymbol.anyDeclHasFlag(16 /* Static */)) {
+                    messageCode = TypeScript.DiagnosticCode.Public_static_property_0_of_exported_class_is_using_inaccessible_module_1;
+                } else if (isProperty) {
+                    if (isPropertyOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.Public_property_0_of_exported_class_is_using_inaccessible_module_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Property_0_of_exported_interface_is_using_inaccessible_module_1;
+                    }
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.Exported_variable_0_is_using_inaccessible_module_1;
+                }
+            } else {
+                if (declSymbol.anyDeclHasFlag(16 /* Static */)) {
+                    messageCode = TypeScript.DiagnosticCode.Public_static_property_0_of_exported_class_has_or_is_using_private_type_1;
+                } else if (isProperty) {
+                    if (isPropertyOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.Public_property_0_of_exported_class_has_or_is_using_private_type_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Property_0_of_exported_interface_has_or_is_using_private_type_1;
+                    }
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.Exported_variable_0_has_or_is_using_private_type_1;
+                }
+            }
+
+            var messageArguments = [declSymbol.getScopedName(enclosingSymbol), typeSymbolName];
+            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(declAST, messageCode, messageArguments));
+        };
+
+        PullTypeResolver.prototype.checkFunctionTypePrivacy = function (funcDeclAST, isStatic, typeParameters, parameters, returnTypeAnnotation, block, context) {
+            var _this = this;
+            if (funcDeclAST.kind() === 222 /* FunctionExpression */ || funcDeclAST.kind() === 241 /* FunctionPropertyAssignment */ || (funcDeclAST.kind() === 139 /* GetAccessor */ && funcDeclAST.parent.parent.kind() === 215 /* ObjectLiteralExpression */) || (funcDeclAST.kind() === 140 /* SetAccessor */ && funcDeclAST.parent.parent.kind() === 215 /* ObjectLiteralExpression */)) {
+                return;
+            }
+
+            var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST);
+            var functionSymbol = functionDecl.getSymbol();
+            ;
+            var functionSignature;
+
+            var isGetter = funcDeclAST.kind() === 139 /* GetAccessor */;
+            var isSetter = funcDeclAST.kind() === 140 /* SetAccessor */;
+            var isIndexSignature = functionDecl.kind === 4194304 /* IndexSignature */;
+
+            if (isGetter || isSetter) {
+                var accessorSymbol = functionSymbol;
+                functionSignature = (isGetter ? accessorSymbol.getGetter() : accessorSymbol.getSetter()).type.getCallSignatures()[0];
+            } else {
+                if (!functionSymbol) {
+                    var parentDecl = functionDecl.getParentDecl();
+                    functionSymbol = parentDecl.getSymbol();
+                    if (functionSymbol && functionSymbol.isType() && !functionSymbol.isNamedTypeSymbol()) {
+                        return;
+                    }
+                } else if (functionSymbol.kind === 65536 /* Method */ && !isStatic && !functionSymbol.getContainer().isNamedTypeSymbol()) {
+                    return;
+                }
+                functionSignature = functionDecl.getSignatureSymbol();
+            }
+
+            if (typeParameters && !isGetter && !isSetter && !isIndexSignature && funcDeclAST.kind() !== 137 /* ConstructorDeclaration */) {
+                for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) {
+                    var typeParameterAST = typeParameters.typeParameters.nonSeparatorAt(i);
+                    var typeParameter = this.resolveTypeParameterDeclaration(typeParameterAST, context);
+                    this.checkSymbolPrivacy(functionSymbol, typeParameter, function (symbol) {
+                        return _this.functionTypeArgumentArgumentTypePrivacyErrorReporter(funcDeclAST, isStatic, typeParameterAST, typeParameter, symbol, context);
+                    });
+                }
+            }
+
+            if (!isGetter && !isIndexSignature) {
+                var funcParams = functionSignature.parameters;
+                for (var i = 0; i < funcParams.length; i++) {
+                    this.checkSymbolPrivacy(functionSymbol, funcParams[i].type, function (symbol) {
+                        return _this.functionArgumentTypePrivacyErrorReporter(funcDeclAST, isStatic, parameters, i, funcParams[i], symbol, context);
+                    });
+                }
+            }
+
+            if (!isSetter) {
+                this.checkSymbolPrivacy(functionSymbol, functionSignature.returnType, function (symbol) {
+                    return _this.functionReturnTypePrivacyErrorReporter(funcDeclAST, isStatic, returnTypeAnnotation, block, functionSignature.returnType, symbol, context);
+                });
+            }
+        };
+
+        PullTypeResolver.prototype.functionTypeArgumentArgumentTypePrivacyErrorReporter = function (declAST, isStatic, typeParameterAST, typeParameter, symbol, context) {
+            var decl = this.semanticInfoChain.getDeclForAST(declAST);
+            var enclosingDecl = this.getEnclosingDecl(decl);
+            var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null;
+
+            var isMethod = decl.kind === 65536 /* Method */;
+            var isMethodOfClass = false;
+            var declParent = decl.getParentDecl();
+            if (declParent && (declParent.kind === 8 /* Class */ || isStatic)) {
+                isMethodOfClass = true;
+            }
+
+            var typeSymbol = symbol;
+            var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol);
+            var messageCode;
+            if (typeSymbol.isContainer() && !typeSymbol.isEnum()) {
+                if (!TypeScript.isQuoted(typeSymbolName)) {
+                    typeSymbolName = "'" + typeSymbolName + "'";
+                }
+
+                if (decl.kind === 2097152 /* ConstructSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1;
+                } else if (decl.kind === 1048576 /* CallSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1;
+                } else if (isMethod) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1;
+                    } else if (isMethodOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1;
+                    }
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_function_is_using_inaccessible_module_1;
+                }
+            } else {
+                if (decl.kind === 2097152 /* ConstructSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1;
+                } else if (decl.kind === 1048576 /* CallSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1;
+                } else if (isMethod) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1;
+                    } else if (isMethodOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1;
+                    }
+                } else {
+                    messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_function_has_or_is_using_private_type_1;
+                }
+            }
+
+            if (messageCode) {
+                var messageArgs = [typeParameter.getScopedName(enclosingSymbol, false, true), typeSymbolName];
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeParameterAST, messageCode, messageArgs));
+            }
+        };
+
+        PullTypeResolver.prototype.functionArgumentTypePrivacyErrorReporter = function (declAST, isStatic, parameters, argIndex, paramSymbol, symbol, context) {
+            var decl = this.semanticInfoChain.getDeclForAST(declAST);
+            var enclosingDecl = this.getEnclosingDecl(decl);
+            var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null;
+
+            var isGetter = declAST.kind() === 139 /* GetAccessor */;
+            var isSetter = declAST.kind() === 140 /* SetAccessor */;
+            var isMethod = decl.kind === 65536 /* Method */;
+            var isMethodOfClass = false;
+            var declParent = decl.getParentDecl();
+            if (declParent && (declParent.kind === 8 /* Class */ || isStatic)) {
+                isMethodOfClass = true;
+            }
+
+            var typeSymbol = symbol;
+            var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol);
+            var messageCode;
+            if (typeSymbol.isContainer() && !typeSymbol.isEnum()) {
+                if (!TypeScript.isQuoted(typeSymbolName)) {
+                    typeSymbolName = "'" + typeSymbolName + "'";
+                }
+
+                if (declAST.kind() === 137 /* ConstructorDeclaration */) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_from_exported_class_is_using_inaccessible_module_1;
+                } else if (isSetter) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_property_setter_from_exported_class_is_using_inaccessible_module_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_property_setter_from_exported_class_is_using_inaccessible_module_1;
+                    }
+                } else if (decl.kind === 2097152 /* ConstructSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1;
+                } else if (decl.kind === 1048576 /* CallSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1;
+                } else if (isMethod) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1;
+                    } else if (isMethodOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1;
+                    }
+                } else if (!isGetter) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_exported_function_is_using_inaccessible_module_1;
+                }
+            } else {
+                if (declAST.kind() === 137 /* ConstructorDeclaration */) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_type_1;
+                } else if (isSetter) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_type_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_type_1;
+                    }
+                } else if (decl.kind === 2097152 /* ConstructSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1;
+                } else if (decl.kind === 1048576 /* CallSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1;
+                } else if (isMethod) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1;
+                    } else if (isMethodOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1;
+                    }
+                } else if (!isGetter && decl.kind !== 4194304 /* IndexSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Parameter_0_of_exported_function_has_or_is_using_private_type_1;
+                }
+            }
+
+            if (messageCode) {
+                var parameter = parameters.astAt(argIndex);
+
+                var messageArgs = [paramSymbol.getScopedName(enclosingSymbol), typeSymbolName];
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(parameter, messageCode, messageArgs));
+            }
+        };
+
+        PullTypeResolver.prototype.functionReturnTypePrivacyErrorReporter = function (declAST, isStatic, returnTypeAnnotation, block, funcReturnType, symbol, context) {
+            var _this = this;
+            var decl = this.semanticInfoChain.getDeclForAST(declAST);
+            var enclosingDecl = this.getEnclosingDecl(decl);
+
+            var isGetter = declAST.kind() === 139 /* GetAccessor */;
+            var isSetter = declAST.kind() === 140 /* SetAccessor */;
+            var isMethod = decl.kind === 65536 /* Method */;
+            var isMethodOfClass = false;
+            var declParent = decl.getParentDecl();
+            if (declParent && (declParent.kind === 8 /* Class */ || isStatic)) {
+                isMethodOfClass = true;
+            }
+
+            var messageCode = null;
+            var typeSymbol = symbol;
+            var typeSymbolName = typeSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null);
+            if (typeSymbol.isContainer() && !typeSymbol.isEnum()) {
+                if (!TypeScript.isQuoted(typeSymbolName)) {
+                    typeSymbolName = "'" + typeSymbolName + "'";
+                }
+
+                if (isGetter) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_property_getter_from_exported_class_is_using_inaccessible_module_0;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_property_getter_from_exported_class_is_using_inaccessible_module_0;
+                    }
+                } else if (decl.kind === 2097152 /* ConstructSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_0;
+                } else if (decl.kind === 1048576 /* CallSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_call_signature_from_exported_interface_is_using_inaccessible_module_0;
+                } else if (decl.kind === 4194304 /* IndexSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_index_signature_from_exported_interface_is_using_inaccessible_module_0;
+                } else if (isMethod) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_method_from_exported_class_is_using_inaccessible_module_0;
+                    } else if (isMethodOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_method_from_exported_class_is_using_inaccessible_module_0;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_method_from_exported_interface_is_using_inaccessible_module_0;
+                    }
+                } else if (!isSetter && declAST.kind() !== 137 /* ConstructorDeclaration */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_exported_function_is_using_inaccessible_module_0;
+                }
+            } else {
+                if (isGetter) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_type_0;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_type_0;
+                    }
+                } else if (decl.kind === 2097152 /* ConstructSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_0;
+                } else if (decl.kind === 1048576 /* CallSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_type_0;
+                } else if (decl.kind === 4194304 /* IndexSignature */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_type_0;
+                } else if (isMethod) {
+                    if (isStatic) {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_type_0;
+                    } else if (isMethodOfClass) {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_public_method_from_exported_class_has_or_is_using_private_type_0;
+                    } else {
+                        messageCode = TypeScript.DiagnosticCode.Return_type_of_method_from_exported_interface_has_or_is_using_private_type_0;
+                    }
+                } else if (!isSetter && declAST.kind() !== 137 /* ConstructorDeclaration */) {
+                    messageCode = TypeScript.DiagnosticCode.Return_type_of_exported_function_has_or_is_using_private_type_0;
+                }
+            }
+
+            if (messageCode) {
+                var messageArguments = [typeSymbolName];
+                var reportOnFuncDecl = false;
+
+                if (returnTypeAnnotation) {
+                    var returnExpressionSymbol = this.resolveTypeReference(returnTypeAnnotation, context);
+
+                    if (TypeScript.PullHelpers.typeSymbolsAreIdentical(returnExpressionSymbol, funcReturnType)) {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, messageCode, messageArguments));
+                    }
+                }
+
+                if (block) {
+                    var reportErrorOnReturnExpressions = function (ast, walker) {
+                        var go = true;
+                        switch (ast.kind()) {
+                            case 129 /* FunctionDeclaration */:
+                            case 219 /* SimpleArrowFunctionExpression */:
+                            case 218 /* ParenthesizedArrowFunctionExpression */:
+                            case 222 /* FunctionExpression */:
+                                go = false;
+                                break;
+
+                            case 150 /* ReturnStatement */:
+                                var returnStatement = ast;
+                                var returnExpressionSymbol = _this.resolveAST(returnStatement.expression, false, context).type;
+
+                                if (TypeScript.PullHelpers.typeSymbolsAreIdentical(returnExpressionSymbol, funcReturnType)) {
+                                    context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(returnStatement, messageCode, messageArguments));
+                                } else {
+                                    reportOnFuncDecl = true;
+                                }
+                                go = false;
+                                break;
+
+                            default:
+                                break;
+                        }
+
+                        walker.options.goChildren = go;
+                        return ast;
+                    };
+
+                    TypeScript.getAstWalkerFactory().walk(block, reportErrorOnReturnExpressions);
+                }
+
+                if (reportOnFuncDecl) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(declAST, messageCode, messageArguments));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.enclosingClassIsDerived = function (classDecl) {
+            TypeScript.Debug.assert(classDecl.kind === 8 /* Class */);
+
+            var classSymbol = classDecl.getSymbol();
+            return classSymbol.getExtendedTypes().length > 0;
+        };
+
+        PullTypeResolver.prototype.isSuperInvocationExpression = function (ast) {
+            if (ast.kind() === 213 /* InvocationExpression */) {
+                var invocationExpression = ast;
+                if (invocationExpression.expression.kind() === 50 /* SuperKeyword */) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.isSuperInvocationExpressionStatement = function (node) {
+            if (node && node.kind() === 149 /* ExpressionStatement */) {
+                var expressionStatement = node;
+                if (this.isSuperInvocationExpression(expressionStatement.expression)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+
+        PullTypeResolver.prototype.getFirstStatementOfBlockOrNull = function (block) {
+            if (block && block.statements && block.statements.childCount() > 0) {
+                return block.statements.childAt(0);
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.superCallMustBeFirstStatementInConstructor = function (constructorDecl) {
+            TypeScript.Debug.assert(constructorDecl.kind === 32768 /* ConstructorMethod */);
+
+            if (constructorDecl) {
+                var enclosingClass = constructorDecl.getParentDecl();
+
+                var classSymbol = enclosingClass.getSymbol();
+                if (classSymbol.getExtendedTypes().length === 0) {
+                    return false;
+                }
+
+                var classMembers = classSymbol.getMembers();
+                for (var i = 0, n1 = classMembers.length; i < n1; i++) {
+                    var member = classMembers[i];
+
+                    if (member.kind === 4096 /* Property */) {
+                        var declarations = member.getDeclarations();
+                        for (var j = 0, n2 = declarations.length; j < n2; j++) {
+                            var declaration = declarations[j];
+                            var ast = this.semanticInfoChain.getASTForDecl(declaration);
+                            if (ast.kind() === 242 /* Parameter */) {
+                                return true;
+                            }
+
+                            if (ast.kind() === 136 /* MemberVariableDeclaration */) {
+                                var variableDeclarator = ast;
+                                if (variableDeclarator.variableDeclarator.equalsValueClause) {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.checkForThisCaptureInArrowFunction = function (expression) {
+            var enclosingDecl = this.getEnclosingDeclForAST(expression);
+
+            var declPath = enclosingDecl.getParentPath();
+
+            if (declPath.length) {
+                var inArrowFunction = false;
+                for (var i = declPath.length - 1; i >= 0; i--) {
+                    var decl = declPath[i];
+                    var declKind = decl.kind;
+                    var declFlags = decl.flags;
+
+                    if (declKind === 131072 /* FunctionExpression */ && TypeScript.hasFlag(declFlags, 8192 /* ArrowFunction */)) {
+                        inArrowFunction = true;
+                        continue;
+                    }
+
+                    if (inArrowFunction) {
+                        if (declKind === 16384 /* Function */ || declKind === 65536 /* Method */ || declKind === 32768 /* ConstructorMethod */ || declKind === 262144 /* GetAccessor */ || declKind === 524288 /* SetAccessor */ || declKind === 131072 /* FunctionExpression */ || declKind === 8 /* Class */ || declKind === 4 /* Container */ || declKind === 32 /* DynamicModule */ || declKind === 1 /* Script */) {
+                            decl.setFlags(decl.flags | 262144 /* MustCaptureThis */);
+
+                            if (declKind === 8 /* Class */) {
+                                var constructorSymbol = decl.getSymbol().getConstructorMethod();
+                                var constructorDecls = constructorSymbol.getDeclarations();
+                                for (var i = 0; i < constructorDecls.length; i++) {
+                                    constructorDecls[i].flags = constructorDecls[i].flags | 262144 /* MustCaptureThis */;
+                                }
+                            }
+                            break;
+                        }
+                    } else if (declKind === 16384 /* Function */ || declKind === 131072 /* FunctionExpression */) {
+                        break;
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckMembersAgainstIndexer = function (containerType, containerTypeDecl, context) {
+            var indexSignatures = this.getBothKindsOfIndexSignaturesExcludingAugmentedType(containerType, context);
+            var stringSignature = indexSignatures.stringSignature;
+            var numberSignature = indexSignatures.numericSignature;
+
+            if (stringSignature || numberSignature) {
+                var members = containerTypeDecl.getChildDecls();
+                for (var i = 0; i < members.length; i++) {
+                    var member = members[i];
+                    if ((member.name || (member.kind === 4096 /* Property */ && member.name === "")) && member.kind !== 32768 /* ConstructorMethod */ && !TypeScript.hasFlag(member.flags, 16 /* Static */)) {
+                        var memberSymbol = member.getSymbol();
+                        var relevantSignature = this.determineRelevantIndexerForMember(memberSymbol, numberSignature, stringSignature);
+                        if (relevantSignature) {
+                            var comparisonInfo = new TypeComparisonInfo();
+                            if (!this.sourceIsAssignableToTarget(memberSymbol.type, relevantSignature.returnType, member.ast(), context, comparisonInfo)) {
+                                this.reportErrorThatMemberIsNotSubtypeOfIndexer(memberSymbol, relevantSignature, member.ast(), context, comparisonInfo);
+                            }
+                        }
+                    }
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.determineRelevantIndexerForMember = function (member, numberIndexSignature, stringIndexSignature) {
+            if (numberIndexSignature && TypeScript.PullHelpers.isNameNumeric(member.name)) {
+                return numberIndexSignature;
+            } else if (stringIndexSignature) {
+                return stringIndexSignature;
+            }
+
+            return null;
+        };
+
+        PullTypeResolver.prototype.reportErrorThatMemberIsNotSubtypeOfIndexer = function (member, indexSignature, astForError, context, comparisonInfo) {
+            var enclosingSymbol = this.getEnclosingSymbolForAST(astForError);
+            if (indexSignature.parameters[0].type === this.semanticInfoChain.numberTypeSymbol) {
+                if (comparisonInfo.message) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_numerically_named_properties_must_be_assignable_to_numeric_indexer_type_0_NL_1, [indexSignature.returnType.toString(enclosingSymbol), comparisonInfo.message]));
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_numerically_named_properties_must_be_assignable_to_numeric_indexer_type_0, [indexSignature.returnType.toString(enclosingSymbol)]));
+                }
+            } else {
+                if (comparisonInfo.message) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_named_properties_must_be_assignable_to_string_indexer_type_0_NL_1, [indexSignature.returnType.toString(enclosingSymbol), comparisonInfo.message]));
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_named_properties_must_be_assignable_to_string_indexer_type_0, [indexSignature.returnType.toString(enclosingSymbol)]));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckIfTypeMemberPropertyOkToOverride = function (typeSymbol, extendedType, typeMember, extendedTypeMember, enclosingDecl, comparisonInfo) {
+            if (!typeSymbol.isClass()) {
+                return true;
+            }
+
+            var typeMemberKind = typeMember.kind;
+            var extendedMemberKind = extendedTypeMember.kind;
+
+            if (typeMemberKind === extendedMemberKind) {
+                return true;
+            }
+
+            var errorCode;
+            if (typeMemberKind === 4096 /* Property */) {
+                if (typeMember.isAccessor()) {
+                    errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function;
+                } else {
+                    errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function;
+                }
+            } else if (typeMemberKind === 65536 /* Method */) {
+                if (extendedTypeMember.isAccessor()) {
+                    errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor;
+                } else {
+                    errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property;
+                }
+            }
+
+            var message = TypeScript.getDiagnosticMessage(errorCode, [typeSymbol.toString(), typeMember.getScopedNameEx().toString(), extendedType.toString()]);
+            comparisonInfo.addMessage(message);
+            return false;
+        };
+
+        PullTypeResolver.prototype.typeCheckIfTypeExtendsType = function (classOrInterface, name, typeSymbol, extendedType, enclosingDecl, context) {
+            var typeMembers = typeSymbol.getMembers();
+
+            var comparisonInfo = new TypeComparisonInfo();
+            var foundError = false;
+            var foundError1 = false;
+            var foundError2 = false;
+
+            for (var i = 0; i < typeMembers.length; i++) {
+                var propName = typeMembers[i].name;
+                var extendedTypeProp = extendedType.findMember(propName, true);
+                if (extendedTypeProp) {
+                    this.resolveDeclaredSymbol(extendedTypeProp, context);
+                    foundError1 = !this.typeCheckIfTypeMemberPropertyOkToOverride(typeSymbol, extendedType, typeMembers[i], extendedTypeProp, enclosingDecl, comparisonInfo);
+
+                    if (!foundError1) {
+                        foundError2 = !this.sourcePropertyIsAssignableToTargetProperty(typeSymbol, extendedType, typeMembers[i], extendedTypeProp, classOrInterface, context, comparisonInfo);
+                    }
+
+                    if (foundError1 || foundError2) {
+                        foundError = true;
+                        break;
+                    }
+                }
+            }
+
+            if (!foundError && typeSymbol.hasOwnCallSignatures()) {
+                foundError = !this.sourceCallSignaturesAreAssignableToTargetCallSignatures(typeSymbol, extendedType, classOrInterface, context, comparisonInfo);
+            }
+
+            if (!foundError && typeSymbol.hasOwnConstructSignatures()) {
+                foundError = !this.sourceConstructSignaturesAreAssignableToTargetConstructSignatures(typeSymbol, extendedType, classOrInterface, context, comparisonInfo);
+            }
+
+            if (!foundError && typeSymbol.hasOwnIndexSignatures()) {
+                foundError = !this.sourceIndexSignaturesAreAssignableToTargetIndexSignatures(typeSymbol, extendedType, classOrInterface, context, comparisonInfo);
+            }
+
+            if (!foundError && typeSymbol.isClass()) {
+                var typeConstructorType = typeSymbol.getConstructorMethod().type;
+                var typeConstructorTypeMembers = typeConstructorType.getMembers();
+                if (typeConstructorTypeMembers.length) {
+                    var extendedConstructorType = extendedType.getConstructorMethod().type;
+                    var comparisonInfoForPropTypeCheck = new TypeComparisonInfo(comparisonInfo);
+
+                    for (var i = 0; i < typeConstructorTypeMembers.length; i++) {
+                        var propName = typeConstructorTypeMembers[i].name;
+                        var extendedConstructorTypeProp = extendedConstructorType.findMember(propName, true);
+                        if (extendedConstructorTypeProp) {
+                            if (!extendedConstructorTypeProp.isResolved) {
+                                this.resolveDeclaredSymbol(extendedConstructorTypeProp, context);
+                            }
+
+                            if (!this.sourcePropertyIsAssignableToTargetProperty(typeConstructorType, extendedConstructorType, typeConstructorTypeMembers[i], extendedConstructorTypeProp, classOrInterface, context, comparisonInfo)) {
+                                foundError = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (foundError) {
+                var errorCode;
+                if (typeSymbol.isClass()) {
+                    errorCode = TypeScript.DiagnosticCode.Class_0_cannot_extend_class_1_NL_2;
+                } else {
+                    if (extendedType.isClass()) {
+                        errorCode = TypeScript.DiagnosticCode.Interface_0_cannot_extend_class_1_NL_2;
+                    } else {
+                        errorCode = TypeScript.DiagnosticCode.Interface_0_cannot_extend_interface_1_NL_2;
+                    }
+                }
+
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, errorCode, [typeSymbol.getScopedName(), extendedType.getScopedName(), comparisonInfo.message]));
+            }
+        };
+
+        PullTypeResolver.prototype.typeCheckIfClassImplementsType = function (classDecl, classSymbol, implementedType, enclosingDecl, context) {
+            var comparisonInfo = new TypeComparisonInfo();
+            var foundError = !this.sourceMembersAreAssignableToTargetMembers(classSymbol, implementedType, classDecl, context, comparisonInfo);
+            if (!foundError) {
+                foundError = !this.sourceCallSignaturesAreAssignableToTargetCallSignatures(classSymbol, implementedType, classDecl, context, comparisonInfo);
+                if (!foundError) {
+                    foundError = !this.sourceConstructSignaturesAreAssignableToTargetConstructSignatures(classSymbol, implementedType, classDecl, context, comparisonInfo);
+                    if (!foundError) {
+                        foundError = !this.sourceIndexSignaturesAreAssignableToTargetIndexSignatures(classSymbol, implementedType, classDecl, context, comparisonInfo);
+                    }
+                }
+            }
+
+            if (foundError) {
+                var enclosingSymbol = this.getEnclosingSymbolForAST(classDecl);
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(classDecl.identifier, TypeScript.DiagnosticCode.Class_0_declares_interface_1_but_does_not_implement_it_NL_2, [classSymbol.getScopedName(enclosingSymbol), implementedType.getScopedName(enclosingSymbol), comparisonInfo.message]));
+            }
+        };
+
+        PullTypeResolver.prototype.computeValueSymbolFromAST = function (valueDeclAST, context) {
+            var prevInTypeCheck = context.inTypeCheck;
+            context.inTypeCheck = false;
+
+            var typeSymbolAlias = this.semanticInfoChain.getAliasSymbolForAST(valueDeclAST);
+
+            if (valueDeclAST.kind() == 11 /* IdentifierName */) {
+                var valueSymbol = this.computeNameExpression(valueDeclAST, context);
+            } else {
+                TypeScript.Debug.assert(valueDeclAST.kind() == 121 /* QualifiedName */);
+                var qualifiedName = valueDeclAST;
+
+                var lhs = this.computeValueSymbolFromAST(qualifiedName.left, context);
+                var valueSymbol = this.computeDottedNameExpressionFromLHS(lhs.symbol, qualifiedName.left, qualifiedName.right, context, false);
+            }
+            var valueSymbolAlias = this.semanticInfoChain.getAliasSymbolForAST(valueDeclAST);
+
+            this.semanticInfoChain.setAliasSymbolForAST(valueDeclAST, typeSymbolAlias);
+            context.inTypeCheck = prevInTypeCheck;
+
+            return { symbol: valueSymbol, alias: valueSymbolAlias };
+        };
+
+        PullTypeResolver.prototype.hasClassTypeSymbolConflictAsValue = function (baseDeclAST, typeSymbol, enclosingDecl, context) {
+            var typeSymbolAlias = this.semanticInfoChain.getAliasSymbolForAST(baseDeclAST);
+
+            var valueDeclAST = baseDeclAST.kind() == 126 /* GenericType */ ? baseDeclAST.name : baseDeclAST;
+            var valueSymbolInfo = this.computeValueSymbolFromAST(valueDeclAST, context);
+            var valueSymbol = valueSymbolInfo.symbol;
+            var valueSymbolAlias = valueSymbolInfo.alias;
+
+            if (typeSymbolAlias && valueSymbolAlias) {
+                return typeSymbolAlias !== valueSymbolAlias;
+            }
+
+            if (!valueSymbol.anyDeclHasFlag(16384 /* ClassConstructorVariable */)) {
+                return true;
+            }
+
+            var associatedContainerType = valueSymbol.type ? valueSymbol.type.getAssociatedContainerType() : null;
+
+            if (associatedContainerType) {
+                return associatedContainerType !== typeSymbol.getRootSymbol();
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.typeCheckBase = function (classOrInterface, name, typeSymbol, baseDeclAST, isExtendedType, enclosingDecl, context) {
+            var _this = this;
+            var typeDecl = this.semanticInfoChain.getDeclForAST(classOrInterface);
+
+            var baseType = this.resolveTypeReference(baseDeclAST, context).type;
+
+            if (!baseType) {
+                return;
+            }
+
+            var typeDeclIsClass = typeSymbol.isClass();
+
+            if (!typeSymbol.isValidBaseKind(baseType, isExtendedType)) {
+                if (!baseType.isError()) {
+                    if (isExtendedType) {
+                        if (typeDeclIsClass) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.A_class_may_only_extend_another_class));
+                        } else {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.An_interface_may_only_extend_another_class_or_interface));
+                        }
+                    } else {
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.A_class_may_only_implement_another_class_or_interface));
+                    }
+                }
+                return;
+            } else if (typeDeclIsClass && isExtendedType) {
+                if (this.hasClassTypeSymbolConflictAsValue(baseDeclAST, baseType, enclosingDecl, context)) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_1, [TypeScript.ASTHelpers.getNameOfIdenfierOrQualifiedName(baseDeclAST.kind() == 126 /* GenericType */ ? baseDeclAST.name : baseDeclAST), baseType.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)]));
+                }
+            }
+
+            if (baseType.hasBase(typeSymbol)) {
+                typeSymbol.setHasBaseTypeConflict();
+                baseType.setHasBaseTypeConflict();
+
+                context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, typeDeclIsClass ? TypeScript.DiagnosticCode.Class_0_is_recursively_referenced_as_a_base_type_of_itself : TypeScript.DiagnosticCode.Interface_0_is_recursively_referenced_as_a_base_type_of_itself, [typeSymbol.getScopedName()]));
+                return;
+            }
+
+            if (isExtendedType) {
+                this.typeCheckCallBacks.push(function (context) {
+                    return _this.typeCheckIfTypeExtendsType(classOrInterface, name, typeSymbol, baseType, enclosingDecl, context);
+                });
+            } else {
+                TypeScript.Debug.assert(classOrInterface.kind() === 131 /* ClassDeclaration */);
+
+                this.typeCheckCallBacks.push(function (context) {
+                    return _this.typeCheckIfClassImplementsType(classOrInterface, typeSymbol, baseType, enclosingDecl, context);
+                });
+            }
+
+            this.checkSymbolPrivacy(typeSymbol, baseType, function (errorSymbol) {
+                return _this.baseListPrivacyErrorReporter(classOrInterface, typeSymbol, baseDeclAST, isExtendedType, errorSymbol, context);
+            });
+        };
+
+        PullTypeResolver.prototype.typeCheckBases = function (classOrInterface, name, heritageClauses, typeSymbol, enclosingDecl, context) {
+            var _this = this;
+            var extendsClause = TypeScript.ASTHelpers.getExtendsHeritageClause(heritageClauses);
+            var implementsClause = TypeScript.ASTHelpers.getImplementsHeritageClause(heritageClauses);
+            if (!extendsClause && !implementsClause) {
+                return;
+            }
+
+            if (extendsClause) {
+                for (var i = 0; i < extendsClause.typeNames.nonSeparatorCount(); i++) {
+                    this.typeCheckBase(classOrInterface, name, typeSymbol, extendsClause.typeNames.nonSeparatorAt(i), true, enclosingDecl, context);
+                }
+            }
+
+            if (typeSymbol.isClass()) {
+                if (implementsClause) {
+                    for (var i = 0; i < implementsClause.typeNames.nonSeparatorCount(); i++) {
+                        this.typeCheckBase(classOrInterface, name, typeSymbol, implementsClause.typeNames.nonSeparatorAt(i), false, enclosingDecl, context);
+                    }
+                }
+            } else if (extendsClause && !typeSymbol.hasBaseTypeConflict() && typeSymbol.getExtendedTypes().length > 1) {
+                var firstInterfaceASTWithExtendsClause = TypeScript.ArrayUtilities.firstOrDefault(typeSymbol.getDeclarations(), function (decl) {
+                    return decl.ast().heritageClauses !== null;
+                }).ast();
+                if (classOrInterface === firstInterfaceASTWithExtendsClause) {
+                    this.typeCheckCallBacks.push(function (context) {
+                        _this.checkTypeCompatibilityBetweenBases(classOrInterface.identifier, typeSymbol, context);
+                    });
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.checkTypeCompatibilityBetweenBases = function (name, typeSymbol, context) {
+            var derivedIndexSignatures = typeSymbol.getOwnIndexSignatures();
+
+            var inheritedMembersMap = TypeScript.createIntrinsicsObject();
+            var inheritedIndexSignatures = new InheritedIndexSignatureInfo();
+
+            var typeHasOwnNumberIndexer = false;
+            var typeHasOwnStringIndexer = false;
+
+            if (typeSymbol.hasOwnIndexSignatures()) {
+                var ownIndexSignatures = typeSymbol.getOwnIndexSignatures();
+                for (var i = 0; i < ownIndexSignatures.length; i++) {
+                    if (ownIndexSignatures[i].parameters[0].type === this.semanticInfoChain.numberTypeSymbol) {
+                        typeHasOwnNumberIndexer = true;
+                    } else {
+                        typeHasOwnStringIndexer = true;
+                    }
+                }
+            }
+            var baseTypes = typeSymbol.getExtendedTypes();
+            for (var i = 0; i < baseTypes.length; i++) {
+                if (this.checkNamedPropertyIdentityBetweenBases(name, typeSymbol, baseTypes[i], inheritedMembersMap, context) || this.checkIndexSignatureIdentityBetweenBases(name, typeSymbol, baseTypes[i], inheritedIndexSignatures, typeHasOwnNumberIndexer, typeHasOwnStringIndexer, context)) {
+                    return;
+                }
+            }
+
+            if (this.checkThatInheritedNumberSignatureIsSubtypeOfInheritedStringSignature(name, typeSymbol, inheritedIndexSignatures, context)) {
+                return;
+            }
+
+            this.checkInheritedMembersAgainstInheritedIndexSignatures(name, typeSymbol, inheritedIndexSignatures, inheritedMembersMap, context);
+        };
+
+        PullTypeResolver.prototype.checkNamedPropertyIdentityBetweenBases = function (interfaceName, interfaceSymbol, baseTypeSymbol, inheritedMembersMap, context) {
+            var baseMembers = baseTypeSymbol.getAllMembers(4096 /* Property */ | 65536 /* Method */, 0 /* all */);
+            for (var i = 0; i < baseMembers.length; i++) {
+                var member = baseMembers[i];
+                var memberName = member.name;
+
+                if (interfaceSymbol.findMember(memberName, false)) {
+                    continue;
+                }
+
+                this.resolveDeclaredSymbol(member, context);
+
+                if (inheritedMembersMap[memberName]) {
+                    var prevMember = inheritedMembersMap[memberName];
+                    if (prevMember.baseOrigin !== baseTypeSymbol && !this.propertiesAreIdenticalWithNewEnclosingTypes(baseTypeSymbol, prevMember.baseOrigin, member, prevMember.memberSymbol, context)) {
+                        var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Named_properties_0_of_types_1_and_2_are_not_identical, [memberName, prevMember.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName()]);
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(), prevMember.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName(), innerDiagnostic]));
+                        return true;
+                    }
+                } else {
+                    inheritedMembersMap[memberName] = new MemberWithBaseOrigin(member, baseTypeSymbol);
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.checkIndexSignatureIdentityBetweenBases = function (interfaceName, interfaceSymbol, baseTypeSymbol, allInheritedSignatures, derivedTypeHasOwnNumberSignature, derivedTypeHasOwnStringSignature, context) {
+            if (derivedTypeHasOwnNumberSignature && derivedTypeHasOwnStringSignature) {
+                return false;
+            }
+
+            var indexSignaturesFromThisBaseType = baseTypeSymbol.getIndexSignatures();
+            for (var i = 0; i < indexSignaturesFromThisBaseType.length; i++) {
+                var currentInheritedSignature = indexSignaturesFromThisBaseType[i];
+
+                var parameterTypeIsString = currentInheritedSignature.parameters[0].type === this.semanticInfoChain.stringTypeSymbol;
+                var parameterTypeIsNumber = currentInheritedSignature.parameters[0].type === this.semanticInfoChain.numberTypeSymbol;
+
+                if (parameterTypeIsString && derivedTypeHasOwnStringSignature || parameterTypeIsNumber && derivedTypeHasOwnNumberSignature) {
+                    continue;
+                }
+
+                if (parameterTypeIsString) {
+                    if (allInheritedSignatures.stringSignatureWithBaseOrigin) {
+                        if (allInheritedSignatures.stringSignatureWithBaseOrigin.baseOrigin !== baseTypeSymbol && !this.typesAreIdentical(allInheritedSignatures.stringSignatureWithBaseOrigin.signature.returnType, currentInheritedSignature.returnType, context)) {
+                            var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_string_indexer_of_types_0_and_1_are_not_identical, [allInheritedSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName()]);
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(), allInheritedSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName(), innerDiagnostic]));
+                            return true;
+                        }
+                    } else {
+                        allInheritedSignatures.stringSignatureWithBaseOrigin = new SignatureWithBaseOrigin(currentInheritedSignature, baseTypeSymbol);
+                    }
+                } else if (parameterTypeIsNumber) {
+                    if (allInheritedSignatures.numberSignatureWithBaseOrigin) {
+                        if (allInheritedSignatures.numberSignatureWithBaseOrigin.baseOrigin !== baseTypeSymbol && !this.typesAreIdentical(allInheritedSignatures.numberSignatureWithBaseOrigin.signature.returnType, currentInheritedSignature.returnType, context)) {
+                            var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_number_indexer_of_types_0_and_1_are_not_identical, [allInheritedSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName()]);
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(), allInheritedSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName(), innerDiagnostic]));
+                            return true;
+                        }
+                    } else {
+                        allInheritedSignatures.numberSignatureWithBaseOrigin = new SignatureWithBaseOrigin(currentInheritedSignature, baseTypeSymbol);
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.checkInheritedMembersAgainstInheritedIndexSignatures = function (interfaceName, interfaceSymbol, inheritedIndexSignatures, inheritedMembers, context) {
+            if (!inheritedIndexSignatures.stringSignatureWithBaseOrigin && !inheritedIndexSignatures.numberSignatureWithBaseOrigin) {
+                return false;
+            }
+
+            var comparisonInfo = new TypeComparisonInfo();
+            var stringSignature = inheritedIndexSignatures.stringSignatureWithBaseOrigin && inheritedIndexSignatures.stringSignatureWithBaseOrigin.signature;
+            var numberSignature = inheritedIndexSignatures.numberSignatureWithBaseOrigin && inheritedIndexSignatures.numberSignatureWithBaseOrigin.signature;
+            for (var memberName in inheritedMembers) {
+                var memberWithBaseOrigin = inheritedMembers[memberName];
+                if (!memberWithBaseOrigin) {
+                    continue;
+                }
+
+                var relevantSignature = this.determineRelevantIndexerForMember(memberWithBaseOrigin.memberSymbol, numberSignature, stringSignature);
+                if (!relevantSignature) {
+                    continue;
+                }
+
+                var relevantSignatureIsNumberSignature = relevantSignature.parameters[0].type === this.semanticInfoChain.numberTypeSymbol;
+                var signatureBaseOrigin = relevantSignatureIsNumberSignature ? inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin : inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin;
+
+                if (signatureBaseOrigin === memberWithBaseOrigin.baseOrigin) {
+                    continue;
+                }
+
+                var memberIsSubtype = this.sourceIsAssignableToTarget(memberWithBaseOrigin.memberSymbol.type, relevantSignature.returnType, interfaceName, context, comparisonInfo);
+
+                if (!memberIsSubtype) {
+                    var enclosingSymbol = this.getEnclosingSymbolForAST(interfaceName);
+                    if (relevantSignatureIsNumberSignature) {
+                        var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_of_property_0_in_type_1_is_not_assignable_to_number_indexer_type_in_type_2_NL_3, [memberName, memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), comparisonInfo.message]);
+
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(enclosingSymbol), memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), innerDiagnostic]));
+                    } else {
+                        var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_of_property_0_in_type_1_is_not_assignable_to_string_indexer_type_in_type_2_NL_3, [memberName, memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), comparisonInfo.message]);
+
+                        context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(enclosingSymbol), memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), innerDiagnostic]));
+                    }
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.checkThatInheritedNumberSignatureIsSubtypeOfInheritedStringSignature = function (interfaceName, interfaceSymbol, inheritedIndexSignatures, context) {
+            if (inheritedIndexSignatures.numberSignatureWithBaseOrigin && inheritedIndexSignatures.stringSignatureWithBaseOrigin) {
+                if (inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin === inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin) {
+                    return false;
+                }
+
+                var comparisonInfo = new TypeComparisonInfo();
+                var signatureIsSubtype = this.sourceIsAssignableToTarget(inheritedIndexSignatures.numberSignatureWithBaseOrigin.signature.returnType, inheritedIndexSignatures.stringSignatureWithBaseOrigin.signature.returnType, interfaceName, context, comparisonInfo);
+
+                if (!signatureIsSubtype) {
+                    var enclosingSymbol = this.getEnclosingSymbolForAST(interfaceName);
+                    var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_of_number_indexer_in_type_0_is_not_assignable_to_string_indexer_type_in_type_1_NL_2, [
+                        inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol),
+                        inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), comparisonInfo.message]);
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [
+                        interfaceSymbol.getDisplayName(enclosingSymbol), inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(),
+                        inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), innerDiagnostic]));
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.checkAssignability = function (ast, source, target, context) {
+            var comparisonInfo = new TypeComparisonInfo();
+
+            var isAssignable = this.sourceIsAssignableToTarget(source, target, ast, context, comparisonInfo);
+
+            if (!isAssignable) {
+                var enclosingSymbol = this.getEnclosingSymbolForAST(ast);
+                if (comparisonInfo.message) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfo.message]));
+                } else {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)]));
+                }
+            }
+        };
+
+        PullTypeResolver.prototype.isReference = function (ast, astSymbol) {
+            if (ast.kind() === 217 /* ParenthesizedExpression */) {
+                return this.isReference(ast.expression, astSymbol);
+            }
+
+            if (ast.kind() !== 11 /* IdentifierName */ && ast.kind() !== 212 /* MemberAccessExpression */ && ast.kind() !== 221 /* ElementAccessExpression */) {
+                return false;
+            }
+
+            if (ast.kind() === 11 /* IdentifierName */) {
+                if (astSymbol.kind === 512 /* Variable */ && astSymbol.anyDeclHasFlag(4096 /* Enum */)) {
+                    return false;
+                }
+
+                if (astSymbol.kind === 512 /* Variable */ && astSymbol.anyDeclHasFlag(102400 /* SomeInitializedModule */)) {
+                    return false;
+                }
+
+                if (astSymbol.kind === 32768 /* ConstructorMethod */ || astSymbol.kind === 16384 /* Function */) {
+                    return false;
+                }
+            }
+
+            if (ast.kind() === 212 /* MemberAccessExpression */ && astSymbol.kind === 67108864 /* EnumMember */) {
+                return false;
+            }
+
+            return true;
+        };
+
+        PullTypeResolver.prototype.checkForSuperMemberAccess = function (expression, name, resolvedName, context) {
+            if (resolvedName) {
+                if (expression.kind() === 50 /* SuperKeyword */ && !resolvedName.isError() && resolvedName.kind !== 65536 /* Method */) {
+                    context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode.Only_public_methods_of_the_base_class_are_accessible_via_the_super_keyword));
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.getEnclosingDeclForAST = function (ast) {
+            return this.semanticInfoChain.getEnclosingDecl(ast);
+        };
+
+        PullTypeResolver.prototype.getEnclosingSymbolForAST = function (ast) {
+            var enclosingDecl = this.getEnclosingDeclForAST(ast);
+            return enclosingDecl ? enclosingDecl.getSymbol() : null;
+        };
+
+        PullTypeResolver.prototype.checkForPrivateMemberAccess = function (name, expressionType, resolvedName, context) {
+            if (resolvedName) {
+                if (resolvedName.anyDeclHasFlag(2 /* Private */)) {
+                    var memberContainer = resolvedName.getContainer();
+                    if (memberContainer && memberContainer.kind === 33554432 /* ConstructorType */) {
+                        memberContainer = memberContainer.getAssociatedContainerType();
+                    }
+
+                    if (memberContainer && memberContainer.isClass()) {
+                        var memberClass = memberContainer.getDeclarations()[0].ast();
+                        TypeScript.Debug.assert(memberClass);
+
+                        var containingClass = this.getEnclosingClassDeclaration(name);
+
+                        if (!containingClass || containingClass !== memberClass) {
+                            context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode._0_1_is_inaccessible, [memberContainer.toString(null, false), name.text()]));
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        PullTypeResolver.prototype.instantiateType = function (type, typeParameterArgumentMap) {
+            if (type.isPrimitive()) {
+                return type;
+            }
+
+            if (type.isError()) {
+                return type;
+            }
+
+            if (typeParameterArgumentMap[type.pullSymbolID]) {
+                return typeParameterArgumentMap[type.pullSymbolID];
+            }
+
+            type._resolveDeclaredSymbol();
+            if (type.isTypeParameter()) {
+                return this.instantiateTypeParameter(type, typeParameterArgumentMap);
+            }
+
+            if (type.wrapsSomeTypeParameter(typeParameterArgumentMap)) {
+                return TypeScript.PullInstantiatedTypeReferenceSymbol.create(this, type, typeParameterArgumentMap);
+            }
+
+            return type;
+        };
+
+        PullTypeResolver.prototype.instantiateTypeParameter = function (typeParameter, typeParameterArgumentMap) {
+            var constraint = typeParameter.getConstraint();
+            if (!constraint) {
+                return typeParameter;
+            }
+
+            var instantiatedConstraint = this.instantiateType(constraint, typeParameterArgumentMap);
+
+            if (instantiatedConstraint == constraint) {
+                return typeParameter;
+            }
+
+            var rootTypeParameter = typeParameter.getRootSymbol();
+            var instantiation = rootTypeParameter.getSpecialization([instantiatedConstraint]);
+            if (instantiation) {
+                return instantiation;
+            }
+
+            instantiation = new TypeScript.PullInstantiatedTypeParameterSymbol(rootTypeParameter, instantiatedConstraint);
+            return instantiation;
+        };
+
+        PullTypeResolver.prototype.instantiateSignature = function (signature, typeParameterArgumentMap) {
+            if (!signature.wrapsSomeTypeParameter(typeParameterArgumentMap)) {
+                return signature;
+            }
+
+            var rootSignature = signature.getRootSymbol();
+            var mutableTypeParameterMap = new TypeScript.PullInstantiationHelpers.MutableTypeArgumentMap(typeParameterArgumentMap);
+            TypeScript.PullInstantiationHelpers.instantiateTypeArgument(this, signature, mutableTypeParameterMap);
+
+            var instantiatedSignature = rootSignature.getSpecialization(mutableTypeParameterMap.typeParameterArgumentMap);
+            if (instantiatedSignature) {
+                return instantiatedSignature;
+            }
+
+            TypeScript.PullInstantiationHelpers.cleanUpTypeArgumentMap(signature, mutableTypeParameterMap);
+            typeParameterArgumentMap = mutableTypeParameterMap.typeParameterArgumentMap;
+
+            instantiatedSignature = new TypeScript.PullInstantiatedSignatureSymbol(rootSignature, typeParameterArgumentMap);
+
+            instantiatedSignature.returnType = this.instantiateType((rootSignature.returnType || this.semanticInfoChain.anyTypeSymbol), typeParameterArgumentMap);
+            instantiatedSignature.functionType = this.instantiateType(rootSignature.functionType, typeParameterArgumentMap);
+
+            var parameters = rootSignature.parameters;
+            var parameter = null;
+
+            if (parameters) {
+                for (var j = 0; j < parameters.length; j++) {
+                    parameter = new TypeScript.PullSymbol(parameters[j].name, 2048 /* Parameter */);
+                    parameter.setRootSymbol(parameters[j]);
+
+                    if (parameters[j].isOptional) {
+                        parameter.isOptional = true;
+                    }
+                    if (parameters[j].isVarArg) {
+                        parameter.isVarArg = true;
+                        instantiatedSignature.hasVarArgs = true;
+                    }
+                    instantiatedSignature.addParameter(parameter, parameter.isOptional);
+
+                    parameter.type = this.instantiateType(parameters[j].type, typeParameterArgumentMap);
+                }
+            }
+
+            return instantiatedSignature;
+        };
+        PullTypeResolver.globalTypeCheckPhase = 0;
+        return PullTypeResolver;
+    })();
+    TypeScript.PullTypeResolver = PullTypeResolver;
+
+    var TypeComparisonInfo = (function () {
+        function TypeComparisonInfo(sourceComparisonInfo, useSameIndent) {
+            this.onlyCaptureFirstError = false;
+            this.flags = 0 /* SuccessfulComparison */;
+            this.message = "";
+            this.stringConstantVal = null;
+            this.indent = 1;
+            if (sourceComparisonInfo) {
+                this.flags = sourceComparisonInfo.flags;
+                this.onlyCaptureFirstError = sourceComparisonInfo.onlyCaptureFirstError;
+                this.stringConstantVal = sourceComparisonInfo.stringConstantVal;
+                this.indent = sourceComparisonInfo.indent;
+                if (!useSameIndent) {
+                    this.indent++;
+                }
+            }
+        }
+        TypeComparisonInfo.prototype.indentString = function () {
+            var result = "";
+
+            for (var i = 0; i < this.indent; i++) {
+                result += "\t";
+            }
+
+            return result;
+        };
+
+        TypeComparisonInfo.prototype.addMessage = function (message) {
+            if (!this.onlyCaptureFirstError && this.message) {
+                this.message = this.message + TypeScript.newLine() + this.indentString() + message;
+            } else {
+                this.message = this.indentString() + message;
+            }
+        };
+        return TypeComparisonInfo;
+    })();
+    TypeScript.TypeComparisonInfo = TypeComparisonInfo;
+
+    function getPropertyAssignmentNameTextFromIdentifier(identifier) {
+        if (identifier.kind() === 11 /* IdentifierName */) {
+            return { actualText: identifier.text(), memberName: identifier.valueText() };
+        } else if (identifier.kind() === 14 /* StringLiteral */) {
+            return { actualText: identifier.text(), memberName: identifier.valueText() };
+        } else if (identifier.kind() === 13 /* NumericLiteral */) {
+            return { actualText: identifier.text(), memberName: identifier.valueText() };
+        } else {
+            throw TypeScript.Errors.invalidOperation();
+        }
+    }
+    TypeScript.getPropertyAssignmentNameTextFromIdentifier = getPropertyAssignmentNameTextFromIdentifier;
+
+    function isTypesOnlyLocation(ast) {
+        while (ast && ast.parent) {
+            switch (ast.parent.kind()) {
+                case 244 /* TypeAnnotation */:
+                    return true;
+                case 127 /* TypeQuery */:
+                    return false;
+                case 125 /* ConstructorType */:
+                    var constructorType = ast.parent;
+                    if (constructorType.type === ast) {
+                        return true;
+                    }
+                    break;
+                case 123 /* FunctionType */:
+                    var functionType = ast.parent;
+                    if (functionType.type === ast) {
+                        return true;
+                    }
+                    break;
+                case 239 /* Constraint */:
+                    var constraint = ast.parent;
+                    if (constraint.type === ast) {
+                        return true;
+                    }
+                    break;
+                case 220 /* CastExpression */:
+                    var castExpression = ast.parent;
+                    return castExpression.type === ast;
+                case 230 /* ExtendsHeritageClause */:
+                case 231 /* ImplementsHeritageClause */:
+                    return true;
+                case 228 /* TypeArgumentList */:
+                    return true;
+                case 131 /* ClassDeclaration */:
+                case 128 /* InterfaceDeclaration */:
+                case 130 /* ModuleDeclaration */:
+                case 129 /* FunctionDeclaration */:
+                case 145 /* MethodSignature */:
+                case 212 /* MemberAccessExpression */:
+                case 242 /* Parameter */:
+                    return false;
+            }
+
+            ast = ast.parent;
+        }
+
+        return false;
+    }
+    TypeScript.isTypesOnlyLocation = isTypesOnlyLocation;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    TypeScript.declCacheHit = 0;
+    TypeScript.declCacheMiss = 0;
+    TypeScript.symbolCacheHit = 0;
+    TypeScript.symbolCacheMiss = 0;
+
+    var sentinalEmptyArray = [];
+
+    var SemanticInfoChain = (function () {
+        function SemanticInfoChain(compiler, logger) {
+            this.compiler = compiler;
+            this.logger = logger;
+            this.documents = [];
+            this.fileNameToDocument = TypeScript.createIntrinsicsObject();
+            this.anyTypeDecl = null;
+            this.booleanTypeDecl = null;
+            this.numberTypeDecl = null;
+            this.stringTypeDecl = null;
+            this.nullTypeDecl = null;
+            this.undefinedTypeDecl = null;
+            this.voidTypeDecl = null;
+            this.undefinedValueDecl = null;
+            this.anyTypeSymbol = null;
+            this.booleanTypeSymbol = null;
+            this.numberTypeSymbol = null;
+            this.stringTypeSymbol = null;
+            this.nullTypeSymbol = null;
+            this.undefinedTypeSymbol = null;
+            this.voidTypeSymbol = null;
+            this.undefinedValueSymbol = null;
+            this.emptyTypeSymbol = null;
+            this.astSymbolMap = [];
+            this.astAliasSymbolMap = [];
+            this.astCallResolutionDataMap = [];
+            this.declSymbolMap = [];
+            this.declSignatureSymbolMap = [];
+            this.declCache = null;
+            this.symbolCache = null;
+            this.fileNameToDiagnostics = null;
+            this._binder = null;
+            this._resolver = null;
+            this._topLevelDecls = null;
+            this._fileNames = null;
+            var globalDecl = new TypeScript.RootPullDecl("", "", 0 /* Global */, 0 /* None */, this, false);
+            this.documents[0] = new TypeScript.Document(this.compiler, this, "", [], null, 0 /* None */, 0, false, null, globalDecl);
+
+            this.anyTypeDecl = new TypeScript.NormalPullDecl("any", "any", 2 /* Primitive */, 0 /* None */, globalDecl);
+            this.booleanTypeDecl = new TypeScript.NormalPullDecl("boolean", "boolean", 2 /* Primitive */, 0 /* None */, globalDecl);
+            this.numberTypeDecl = new TypeScript.NormalPullDecl("number", "number", 2 /* Primitive */, 0 /* None */, globalDecl);
+            this.stringTypeDecl = new TypeScript.NormalPullDecl("string", "string", 2 /* Primitive */, 0 /* None */, globalDecl);
+            this.voidTypeDecl = new TypeScript.NormalPullDecl("void", "void", 2 /* Primitive */, 0 /* None */, globalDecl);
+
+            this.nullTypeDecl = new TypeScript.RootPullDecl("null", "", 2 /* Primitive */, 0 /* None */, this, false);
+            this.undefinedTypeDecl = new TypeScript.RootPullDecl("undefined", "", 2 /* Primitive */, 0 /* None */, this, false);
+            this.undefinedValueDecl = new TypeScript.NormalPullDecl("undefined", "undefined", 512 /* Variable */, 8 /* Ambient */, globalDecl);
+
+            this.invalidate();
+        }
+        SemanticInfoChain.prototype.getDocument = function (fileName) {
+            var document = this.fileNameToDocument[fileName];
+            return document || null;
+        };
+
+        SemanticInfoChain.prototype.lineMap = function (fileName) {
+            return this.getDocument(fileName).lineMap();
+        };
+
+        SemanticInfoChain.prototype.fileNames = function () {
+            if (this._fileNames === null) {
+                this._fileNames = this.documents.slice(1).map(function (s) {
+                    return s.fileName;
+                });
+            }
+
+            return this._fileNames;
+        };
+
+        SemanticInfoChain.prototype.bindPrimitiveSymbol = function (decl, newSymbol) {
+            newSymbol.addDeclaration(decl);
+            decl.setSymbol(newSymbol);
+            newSymbol.setResolved();
+
+            return newSymbol;
+        };
+
+        SemanticInfoChain.prototype.addPrimitiveTypeSymbol = function (decl) {
+            var newSymbol = new TypeScript.PullPrimitiveTypeSymbol(decl.name);
+            return this.bindPrimitiveSymbol(decl, newSymbol);
+        };
+
+        SemanticInfoChain.prototype.addPrimitiveValueSymbol = function (decl, type) {
+            var newSymbol = new TypeScript.PullSymbol(decl.name, 512 /* Variable */);
+            newSymbol.type = type;
+            return this.bindPrimitiveSymbol(decl, newSymbol);
+        };
+
+        SemanticInfoChain.prototype.resetGlobalSymbols = function () {
+            this.anyTypeSymbol = this.addPrimitiveTypeSymbol(this.anyTypeDecl);
+            this.booleanTypeSymbol = this.addPrimitiveTypeSymbol(this.booleanTypeDecl);
+            this.numberTypeSymbol = this.addPrimitiveTypeSymbol(this.numberTypeDecl);
+            this.stringTypeSymbol = this.addPrimitiveTypeSymbol(this.stringTypeDecl);
+            this.voidTypeSymbol = this.addPrimitiveTypeSymbol(this.voidTypeDecl);
+            this.nullTypeSymbol = this.addPrimitiveTypeSymbol(this.nullTypeDecl);
+            this.undefinedTypeSymbol = this.addPrimitiveTypeSymbol(this.undefinedTypeDecl);
+            this.undefinedValueSymbol = this.addPrimitiveValueSymbol(this.undefinedValueDecl, this.undefinedTypeSymbol);
+
+            var emptyTypeDecl = new TypeScript.PullSynthesizedDecl("{}", "{}", 8388608 /* ObjectType */, 0 /* None */, null, this);
+            var emptyTypeSymbol = new TypeScript.PullTypeSymbol("{}", 8388608 /* ObjectType */);
+            emptyTypeDecl.setSymbol(emptyTypeSymbol);
+            emptyTypeSymbol.addDeclaration(emptyTypeDecl);
+            emptyTypeSymbol.setResolved();
+            this.emptyTypeSymbol = emptyTypeSymbol;
+        };
+
+        SemanticInfoChain.prototype.addDocument = function (document) {
+            var fileName = document.fileName;
+
+            var existingIndex = TypeScript.ArrayUtilities.indexOf(this.documents, function (u) {
+                return u.fileName === fileName;
+            });
+            if (existingIndex < 0) {
+                this.documents.push(document);
+            } else {
+                this.documents[existingIndex] = document;
+            }
+
+            this.fileNameToDocument[fileName] = document;
+
+            this.invalidate();
+        };
+
+        SemanticInfoChain.prototype.removeDocument = function (fileName) {
+            TypeScript.Debug.assert(fileName !== "", "Can't remove the semantic info for the global decl.");
+            var index = TypeScript.ArrayUtilities.indexOf(this.documents, function (u) {
+                return u.fileName === fileName;
+            });
+            if (index > 0) {
+                this.fileNameToDocument[fileName] = undefined;
+                this.documents.splice(index, 1);
+                this.invalidate();
+            }
+        };
+
+        SemanticInfoChain.prototype.getDeclPathCacheID = function (declPath, declKind) {
+            var cacheID = "";
+
+            for (var i = 0; i < declPath.length; i++) {
+                cacheID += "#" + declPath[i];
+            }
+
+            return cacheID + "#" + declKind.toString();
+        };
+
+        SemanticInfoChain.prototype.findTopLevelSymbol = function (name, kind, doNotGoPastThisDecl) {
+            var cacheID = this.getDeclPathCacheID([name], kind);
+
+            var symbol = this.symbolCache[cacheID];
+
+            if (!symbol) {
+                for (var i = 0, n = this.documents.length; i < n; i++) {
+                    var topLevelDecl = this.documents[i].topLevelDecl();
+
+                    var symbol = this.findTopLevelSymbolInDecl(topLevelDecl, name, kind, doNotGoPastThisDecl);
+                    if (symbol) {
+                        break;
+                    }
+
+                    if (doNotGoPastThisDecl && topLevelDecl.name === doNotGoPastThisDecl.fileName()) {
+                        return null;
+                    }
+                }
+
+                if (symbol) {
+                    this.symbolCache[cacheID] = symbol;
+                }
+            }
+
+            return symbol;
+        };
+
+        SemanticInfoChain.prototype.findTopLevelSymbolInDecl = function (topLevelDecl, name, kind, doNotGoPastThisDecl) {
+            var doNotGoPastThisPosition = doNotGoPastThisDecl && doNotGoPastThisDecl.fileName() === topLevelDecl.fileName() ? doNotGoPastThisDecl.ast().start() : -1;
+
+            var foundDecls = topLevelDecl.searchChildDecls(name, kind);
+
+            for (var j = 0; j < foundDecls.length; j++) {
+                var foundDecl = foundDecls[j];
+
+                if (doNotGoPastThisPosition !== -1 && foundDecl.ast() && foundDecl.ast().start() > doNotGoPastThisPosition) {
+                    break;
+                }
+
+                var symbol = foundDecls[j].getSymbol();
+                if (symbol) {
+                    return symbol;
+                }
+            }
+
+            return null;
+        };
+
+        SemanticInfoChain.prototype.findExternalModule = function (id) {
+            id = TypeScript.normalizePath(id);
+
+            var tsFile = id + ".ts";
+            var tsCacheID = this.getDeclPathCacheID([tsFile], 32 /* DynamicModule */);
+            symbol = this.symbolCache[tsCacheID];
+            if (symbol != undefined) {
+                return symbol;
+            }
+
+            var dtsFile = id + ".d.ts";
+            var dtsCacheID = this.getDeclPathCacheID([dtsFile], 32 /* DynamicModule */);
+            var symbol = this.symbolCache[dtsCacheID];
+            if (symbol) {
+                return symbol;
+            }
+
+            var dtsSymbol;
+            for (var i = 0; i < this.documents.length; i++) {
+                var document = this.documents[i];
+                var topLevelDecl = document.topLevelDecl();
+
+                if (topLevelDecl.isExternalModule()) {
+                    var isTsFile = document.fileName === tsFile;
+                    if (isTsFile || document.fileName === dtsFile) {
+                        var dynamicModuleDecl = topLevelDecl.getChildDecls()[0];
+                        symbol = dynamicModuleDecl.getSymbol();
+
+                        if (isTsFile) {
+                            this.symbolCache[tsCacheID] = symbol;
+
+                            return symbol;
+                        } else {
+                            dtsSymbol = symbol;
+                        }
+                    }
+                }
+            }
+
+            if (dtsSymbol) {
+                this.symbolCache[dtsCacheID] = symbol;
+                return dtsSymbol;
+            }
+
+            this.symbolCache[dtsCacheID] = null;
+            this.symbolCache[tsCacheID] = null;
+
+            return null;
+        };
+
+        SemanticInfoChain.prototype.findAmbientExternalModuleInGlobalContext = function (id) {
+            var cacheID = this.getDeclPathCacheID([id], 32 /* DynamicModule */);
+
+            var symbol = this.symbolCache[cacheID];
+            if (symbol == undefined) {
+                symbol = null;
+                for (var i = 0; i < this.documents.length; i++) {
+                    var document = this.documents[i];
+                    var topLevelDecl = document.topLevelDecl();
+
+                    if (!topLevelDecl.isExternalModule()) {
+                        var dynamicModules = topLevelDecl.searchChildDecls(id, 32 /* DynamicModule */);
+                        if (dynamicModules.length) {
+                            symbol = dynamicModules[0].getSymbol();
+                            break;
+                        }
+                    }
+                }
+
+                this.symbolCache[cacheID] = symbol;
+            }
+
+            return symbol;
+        };
+
+        SemanticInfoChain.prototype.findDecls = function (declPath, declKind) {
+            var cacheID = this.getDeclPathCacheID(declPath, declKind);
+
+            if (declPath.length) {
+                var cachedDecls = this.declCache[cacheID];
+
+                if (cachedDecls && cachedDecls.length) {
+                    TypeScript.declCacheHit++;
+                    return cachedDecls;
+                }
+            }
+
+            TypeScript.declCacheMiss++;
+
+            var declsToSearch = this.topLevelDecls();
+
+            var decls = TypeScript.sentinelEmptyArray;
+            var path;
+            var foundDecls = TypeScript.sentinelEmptyArray;
+
+            for (var i = 0; i < declPath.length; i++) {
+                path = declPath[i];
+                decls = TypeScript.sentinelEmptyArray;
+
+                var kind = (i === declPath.length - 1) ? declKind : 164 /* SomeContainer */;
+                for (var j = 0; j < declsToSearch.length; j++) {
+                    foundDecls = declsToSearch[j].searchChildDecls(path, kind);
+
+                    for (var k = 0; k < foundDecls.length; k++) {
+                        if (decls === TypeScript.sentinelEmptyArray) {
+                            decls = [];
+                        }
+                        decls[decls.length] = foundDecls[k];
+                    }
+                }
+
+                declsToSearch = decls;
+
+                if (!declsToSearch) {
+                    break;
+                }
+            }
+
+            if (decls.length) {
+                this.declCache[cacheID] = decls;
+            }
+
+            return decls;
+        };
+
+        SemanticInfoChain.prototype.findDeclsFromPath = function (declPath, declKind) {
+            var declString = [];
+
+            for (var i = 0, n = declPath.length; i < n; i++) {
+                if (declPath[i].kind & 1 /* Script */) {
+                    continue;
+                }
+
+                declString.push(declPath[i].name);
+            }
+
+            return this.findDecls(declString, declKind);
+        };
+
+        SemanticInfoChain.prototype.findSymbol = function (declPath, declType) {
+            var cacheID = this.getDeclPathCacheID(declPath, declType);
+
+            if (declPath.length) {
+                var cachedSymbol = this.symbolCache[cacheID];
+
+                if (cachedSymbol) {
+                    TypeScript.symbolCacheHit++;
+                    return cachedSymbol;
+                }
+            }
+
+            TypeScript.symbolCacheMiss++;
+
+            var decls = this.findDecls(declPath, declType);
+            var symbol = null;
+
+            if (decls.length) {
+                var decl = decls[0];
+                if (TypeScript.hasFlag(decl.kind, 164 /* SomeContainer */)) {
+                    var valueDecl = decl.getValueDecl();
+                    if (valueDecl) {
+                        valueDecl.ensureSymbolIsBound();
+                    }
+                }
+                symbol = decl.getSymbol();
+
+                if (symbol) {
+                    for (var i = 1; i < decls.length; i++) {
+                        decls[i].ensureSymbolIsBound();
+                    }
+
+                    this.symbolCache[cacheID] = symbol;
+                }
+            }
+
+            return symbol;
+        };
+
+        SemanticInfoChain.prototype.cacheGlobalSymbol = function (symbol, kind) {
+            var cacheID1 = this.getDeclPathCacheID([symbol.name], kind);
+            var cacheID2 = this.getDeclPathCacheID([symbol.name], symbol.kind);
+
+            if (!this.symbolCache[cacheID1]) {
+                this.symbolCache[cacheID1] = symbol;
+            }
+
+            if (!this.symbolCache[cacheID2]) {
+                this.symbolCache[cacheID2] = symbol;
+            }
+        };
+
+        SemanticInfoChain.prototype.invalidate = function (oldSettings, newSettings) {
+            if (typeof oldSettings === "undefined") { oldSettings = null; }
+            if (typeof newSettings === "undefined") { newSettings = null; }
+            TypeScript.PullTypeResolver.globalTypeCheckPhase++;
+
+            var cleanStart = new Date().getTime();
+
+            this.astSymbolMap.length = 0;
+            this.astAliasSymbolMap.length = 0;
+            this.astCallResolutionDataMap.length = 0;
+
+            this.declCache = TypeScript.createIntrinsicsObject();
+            this.symbolCache = TypeScript.createIntrinsicsObject();
+            this.fileNameToDiagnostics = TypeScript.createIntrinsicsObject();
+            this._binder = null;
+            this._resolver = null;
+            this._topLevelDecls = null;
+            this._fileNames = null;
+
+            this.declSymbolMap.length = 0;
+            this.declSignatureSymbolMap.length = 0;
+
+            if (oldSettings && newSettings) {
+                if (this.settingsChangeAffectsSyntax(oldSettings, newSettings)) {
+                    for (var i = 1, n = this.documents.length; i < n; i++) {
+                        this.documents[i].invalidate();
+                    }
+                }
+            }
+
+            TypeScript.pullSymbolID = 0;
+
+            this.resetGlobalSymbols();
+
+            var cleanEnd = new Date().getTime();
+        };
+
+        SemanticInfoChain.prototype.settingsChangeAffectsSyntax = function (before, after) {
+            return before.allowAutomaticSemicolonInsertion() !== after.allowAutomaticSemicolonInsertion() || before.codeGenTarget() !== after.codeGenTarget() || before.propagateEnumConstants() !== after.propagateEnumConstants();
+        };
+
+        SemanticInfoChain.prototype.setSymbolForAST = function (ast, symbol) {
+            this.astSymbolMap[ast.syntaxID()] = symbol;
+        };
+
+        SemanticInfoChain.prototype.getSymbolForAST = function (ast) {
+            return this.astSymbolMap[ast.syntaxID()] || null;
+        };
+
+        SemanticInfoChain.prototype.setAliasSymbolForAST = function (ast, symbol) {
+            this.astAliasSymbolMap[ast.syntaxID()] = symbol;
+        };
+
+        SemanticInfoChain.prototype.getAliasSymbolForAST = function (ast) {
+            return this.astAliasSymbolMap[ast.syntaxID()];
+        };
+
+        SemanticInfoChain.prototype.getCallResolutionDataForAST = function (ast) {
+            return this.astCallResolutionDataMap[ast.syntaxID()];
+        };
+
+        SemanticInfoChain.prototype.setCallResolutionDataForAST = function (ast, callResolutionData) {
+            if (callResolutionData) {
+                this.astCallResolutionDataMap[ast.syntaxID()] = callResolutionData;
+            }
+        };
+
+        SemanticInfoChain.prototype.setSymbolForDecl = function (decl, symbol) {
+            this.declSymbolMap[decl.declID] = symbol;
+        };
+
+        SemanticInfoChain.prototype.getSymbolForDecl = function (decl) {
+            return this.declSymbolMap[decl.declID];
+        };
+
+        SemanticInfoChain.prototype.setSignatureSymbolForDecl = function (decl, signatureSymbol) {
+            this.declSignatureSymbolMap[decl.declID] = signatureSymbol;
+        };
+
+        SemanticInfoChain.prototype.getSignatureSymbolForDecl = function (decl) {
+            return this.declSignatureSymbolMap[decl.declID];
+        };
+
+        SemanticInfoChain.prototype.addDiagnostic = function (diagnostic) {
+            var fileName = diagnostic.fileName();
+            var diagnostics = this.fileNameToDiagnostics[fileName];
+            if (!diagnostics) {
+                diagnostics = [];
+                this.fileNameToDiagnostics[fileName] = diagnostics;
+            }
+
+            diagnostics.push(diagnostic);
+        };
+
+        SemanticInfoChain.prototype.getDiagnostics = function (fileName) {
+            var diagnostics = this.fileNameToDiagnostics[fileName];
+            return diagnostics || [];
+        };
+
+        SemanticInfoChain.prototype.getBinder = function () {
+            if (!this._binder) {
+                this._binder = new TypeScript.PullSymbolBinder(this);
+            }
+
+            return this._binder;
+        };
+
+        SemanticInfoChain.prototype.getResolver = function () {
+            if (!this._resolver) {
+                this._resolver = new TypeScript.PullTypeResolver(this.compiler.compilationSettings(), this);
+            }
+
+            return this._resolver;
+        };
+
+        SemanticInfoChain.prototype.addSyntheticIndexSignature = function (containingDecl, containingSymbol, ast, indexParamName, indexParamType, returnType) {
+            var indexSignature = new TypeScript.PullSignatureSymbol(4194304 /* IndexSignature */);
+            var indexParameterSymbol = new TypeScript.PullSymbol(indexParamName, 2048 /* Parameter */);
+            indexParameterSymbol.type = indexParamType;
+            indexSignature.addParameter(indexParameterSymbol);
+            indexSignature.returnType = returnType;
+            indexSignature.setResolved();
+            indexParameterSymbol.setResolved();
+
+            containingSymbol.addIndexSignature(indexSignature);
+
+            var indexSigDecl = new TypeScript.PullSynthesizedDecl("", "", 4194304 /* IndexSignature */, 2048 /* Signature */, containingDecl, containingDecl.semanticInfoChain);
+            var indexParamDecl = new TypeScript.PullSynthesizedDecl(indexParamName, indexParamName, 2048 /* Parameter */, 0 /* None */, indexSigDecl, containingDecl.semanticInfoChain);
+            indexSigDecl.setSignatureSymbol(indexSignature);
+            indexParamDecl.setSymbol(indexParameterSymbol);
+            indexSignature.addDeclaration(indexSigDecl);
+            indexParameterSymbol.addDeclaration(indexParamDecl);
+        };
+
+        SemanticInfoChain.prototype.getDeclForAST = function (ast) {
+            var document = this.getDocument(ast.fileName());
+
+            if (document) {
+                return document._getDeclForAST(ast);
+            }
+
+            return null;
+        };
+
+        SemanticInfoChain.prototype.getEnclosingDecl = function (ast) {
+            return this.getDocument(ast.fileName()).getEnclosingDecl(ast);
+        };
+
+        SemanticInfoChain.prototype.setDeclForAST = function (ast, decl) {
+            this.getDocument(decl.fileName())._setDeclForAST(ast, decl);
+        };
+
+        SemanticInfoChain.prototype.getASTForDecl = function (decl) {
+            var document = this.getDocument(decl.fileName());
+            if (document) {
+                return document._getASTForDecl(decl);
+            }
+
+            return null;
+        };
+
+        SemanticInfoChain.prototype.setASTForDecl = function (decl, ast) {
+            this.getDocument(decl.fileName())._setASTForDecl(decl, ast);
+        };
+
+        SemanticInfoChain.prototype.topLevelDecl = function (fileName) {
+            var document = this.getDocument(fileName);
+            if (document) {
+                return document.topLevelDecl();
+            }
+
+            return null;
+        };
+
+        SemanticInfoChain.prototype.topLevelDecls = function () {
+            if (!this._topLevelDecls) {
+                this._topLevelDecls = TypeScript.ArrayUtilities.select(this.documents, function (u) {
+                    return u.topLevelDecl();
+                });
+            }
+
+            return this._topLevelDecls;
+        };
+
+        SemanticInfoChain.prototype.addDiagnosticFromAST = function (ast, diagnosticKey, _arguments, additionalLocations) {
+            if (typeof _arguments === "undefined") { _arguments = null; }
+            if (typeof additionalLocations === "undefined") { additionalLocations = null; }
+            this.addDiagnostic(this.diagnosticFromAST(ast, diagnosticKey, _arguments, additionalLocations));
+        };
+
+        SemanticInfoChain.prototype.diagnosticFromAST = function (ast, diagnosticKey, _arguments, additionalLocations) {
+            if (typeof _arguments === "undefined") { _arguments = null; }
+            if (typeof additionalLocations === "undefined") { additionalLocations = null; }
+            return new TypeScript.Diagnostic(ast.fileName(), this.lineMap(ast.fileName()), ast.start(), ast.width(), diagnosticKey, _arguments, additionalLocations);
+        };
+
+        SemanticInfoChain.prototype.locationFromAST = function (ast) {
+            return new TypeScript.Location(ast.fileName(), this.lineMap(ast.fileName()), ast.start(), ast.width());
+        };
+
+        SemanticInfoChain.prototype.duplicateIdentifierDiagnosticFromAST = function (ast, identifier, additionalLocationAST) {
+            return this.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Duplicate_identifier_0, [identifier], additionalLocationAST ? [this.locationFromAST(additionalLocationAST)] : null);
+        };
+
+        SemanticInfoChain.prototype.addDuplicateIdentifierDiagnosticFromAST = function (ast, identifier, additionalLocationAST) {
+            this.addDiagnostic(this.duplicateIdentifierDiagnosticFromAST(ast, identifier, additionalLocationAST));
+        };
+        return SemanticInfoChain;
+    })();
+    TypeScript.SemanticInfoChain = SemanticInfoChain;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var DeclCollectionContext = (function () {
+        function DeclCollectionContext(document, semanticInfoChain, propagateEnumConstants) {
+            this.document = document;
+            this.semanticInfoChain = semanticInfoChain;
+            this.propagateEnumConstants = propagateEnumConstants;
+            this.isDeclareFile = false;
+            this.parentChain = [];
+        }
+        DeclCollectionContext.prototype.getParent = function () {
+            return this.parentChain ? this.parentChain[this.parentChain.length - 1] : null;
+        };
+
+        DeclCollectionContext.prototype.pushParent = function (parentDecl) {
+            if (parentDecl) {
+                this.parentChain[this.parentChain.length] = parentDecl;
+            }
+        };
+
+        DeclCollectionContext.prototype.popParent = function () {
+            this.parentChain.length--;
+        };
+        return DeclCollectionContext;
+    })();
+
+    function moduleElementsHasExportAssignment(moduleElements) {
+        return moduleElements.any(function (m) {
+            return m.kind() === 134 /* ExportAssignment */;
+        });
+    }
+
+    function containingModuleHasExportAssignment(ast) {
+        ast = ast.parent;
+        while (ast) {
+            if (ast.kind() === 130 /* ModuleDeclaration */) {
+                var moduleDecl = ast;
+                return moduleElementsHasExportAssignment(moduleDecl.moduleElements);
+            } else if (ast.kind() === 120 /* SourceUnit */) {
+                var sourceUnit = ast;
+                return moduleElementsHasExportAssignment(sourceUnit.moduleElements);
+            }
+
+            ast = ast.parent;
+        }
+
+        return false;
+    }
+
+    function isParsingAmbientModule(ast, context) {
+        ast = ast.parent;
+        while (ast) {
+            if (ast.kind() === 130 /* ModuleDeclaration */) {
+                if (TypeScript.hasModifier(ast.modifiers, 8 /* Ambient */)) {
+                    return true;
+                }
+            }
+
+            ast = ast.parent;
+        }
+
+        return false;
+    }
+
+    function preCollectImportDecls(ast, context) {
+        var importDecl = ast;
+        var declFlags = 0 /* None */;
+
+        var parent = context.getParent();
+
+        if (TypeScript.hasModifier(importDecl.modifiers, 1 /* Exported */) && !containingModuleHasExportAssignment(ast)) {
+            declFlags |= 1 /* Exported */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(importDecl.identifier.valueText(), importDecl.identifier.text(), 128 /* TypeAlias */, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(ast, decl);
+        context.semanticInfoChain.setASTForDecl(decl, ast);
+    }
+
+    function preCollectScriptDecls(sourceUnit, context) {
+        var fileName = sourceUnit.fileName();
+
+        var isExternalModule = context.document.isExternalModule();
+
+        var decl = new TypeScript.RootPullDecl(fileName, fileName, 1 /* Script */, 0 /* None */, context.semanticInfoChain, isExternalModule);
+        context.semanticInfoChain.setDeclForAST(sourceUnit, decl);
+        context.semanticInfoChain.setASTForDecl(decl, sourceUnit);
+
+        context.isDeclareFile = context.document.isDeclareFile();
+
+        context.pushParent(decl);
+
+        if (isExternalModule) {
+            var declFlags = 1 /* Exported */;
+            if (TypeScript.isDTSFile(fileName)) {
+                declFlags |= 8 /* Ambient */;
+            }
+
+            var moduleContainsExecutableCode = containsExecutableCode(sourceUnit.moduleElements);
+            var kind = 32 /* DynamicModule */;
+            var valueText = TypeScript.quoteStr(fileName);
+
+            var decl = new TypeScript.NormalPullDecl(valueText, fileName, kind, declFlags, context.getParent());
+
+            context.semanticInfoChain.setASTForDecl(decl, sourceUnit);
+
+            context.semanticInfoChain.setDeclForAST(sourceUnit, decl);
+
+            if (!moduleElementsHasExportAssignment(sourceUnit.moduleElements) || moduleContainsExecutableCode) {
+                createModuleVariableDecl(decl, sourceUnit, context);
+            }
+
+            context.pushParent(decl);
+        }
+    }
+
+    function preCollectEnumDecls(enumDecl, context) {
+        var declFlags = 0 /* None */;
+        var enumName = enumDecl.identifier.valueText();
+
+        if ((TypeScript.hasModifier(enumDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(enumDecl, context)) && !containingModuleHasExportAssignment(enumDecl)) {
+            declFlags |= 1 /* Exported */;
+        }
+
+        if (TypeScript.hasModifier(enumDecl.modifiers, 8 /* Ambient */) || isParsingAmbientModule(enumDecl, context) || context.isDeclareFile) {
+            declFlags |= 8 /* Ambient */;
+        }
+
+        declFlags |= 4096 /* Enum */;
+        var kind = 64 /* Enum */;
+
+        var enumDeclaration = new TypeScript.NormalPullDecl(enumName, enumDecl.identifier.text(), kind, declFlags, context.getParent());
+        context.semanticInfoChain.setDeclForAST(enumDecl, enumDeclaration);
+        context.semanticInfoChain.setASTForDecl(enumDeclaration, enumDecl);
+
+        var valueDecl = new TypeScript.NormalPullDecl(enumDeclaration.name, enumDeclaration.getDisplayName(), 512 /* Variable */, enumDeclaration.flags, context.getParent());
+        enumDeclaration.setValueDecl(valueDecl);
+        context.semanticInfoChain.setASTForDecl(valueDecl, enumDecl);
+
+        context.pushParent(enumDeclaration);
+    }
+
+    function createEnumElementDecls(propertyDecl, context) {
+        var parent = context.getParent();
+
+        var decl = new TypeScript.PullEnumElementDecl(propertyDecl.propertyName.valueText(), propertyDecl.propertyName.text(), parent);
+        context.semanticInfoChain.setDeclForAST(propertyDecl, decl);
+        context.semanticInfoChain.setASTForDecl(decl, propertyDecl);
+    }
+
+    function preCollectModuleDecls(moduleDecl, context) {
+        var declFlags = 0 /* None */;
+
+        var moduleContainsExecutableCode = containsExecutableCode(moduleDecl.moduleElements);
+
+        var isDynamic = moduleDecl.stringLiteral !== null;
+
+        if ((TypeScript.hasModifier(moduleDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(moduleDecl, context)) && !containingModuleHasExportAssignment(moduleDecl)) {
+            declFlags |= 1 /* Exported */;
+        }
+
+        if (TypeScript.hasModifier(moduleDecl.modifiers, 8 /* Ambient */) || isParsingAmbientModule(moduleDecl, context) || context.isDeclareFile) {
+            declFlags |= 8 /* Ambient */;
+        }
+
+        var kind = isDynamic ? 32 /* DynamicModule */ : 4 /* Container */;
+
+        if (moduleDecl.stringLiteral) {
+            var valueText = TypeScript.quoteStr(moduleDecl.stringLiteral.valueText());
+            var text = moduleDecl.stringLiteral.text();
+
+            var decl = new TypeScript.NormalPullDecl(valueText, text, kind, declFlags, context.getParent());
+
+            context.semanticInfoChain.setDeclForAST(moduleDecl, decl);
+            context.semanticInfoChain.setDeclForAST(moduleDecl.stringLiteral, decl);
+            context.semanticInfoChain.setASTForDecl(decl, moduleDecl.stringLiteral);
+
+            if (!moduleElementsHasExportAssignment(moduleDecl.moduleElements) || moduleContainsExecutableCode) {
+                createModuleVariableDecl(decl, moduleDecl.stringLiteral, context);
+            }
+
+            context.pushParent(decl);
+        } else {
+            var moduleNames = TypeScript.ASTHelpers.getModuleNames(moduleDecl.name);
+            for (var i = 0, n = moduleNames.length; i < n; i++) {
+                var moduleName = moduleNames[i];
+
+                var specificFlags = declFlags;
+                if (i > 0) {
+                    specificFlags |= 1 /* Exported */;
+                }
+
+                var decl = new TypeScript.NormalPullDecl(moduleName.valueText(), moduleName.text(), kind, specificFlags, context.getParent());
+
+                context.semanticInfoChain.setDeclForAST(moduleDecl, decl);
+                context.semanticInfoChain.setDeclForAST(moduleName, decl);
+                context.semanticInfoChain.setASTForDecl(decl, moduleName);
+
+                if (moduleContainsExecutableCode) {
+                    createModuleVariableDecl(decl, moduleName, context);
+                }
+
+                context.pushParent(decl);
+            }
+        }
+    }
+
+    function createModuleVariableDecl(decl, moduleNameAST, context) {
+        decl.setFlags(decl.flags | getInitializationFlag(decl));
+
+        var valueDecl = new TypeScript.NormalPullDecl(decl.name, decl.getDisplayName(), 512 /* Variable */, decl.flags, context.getParent());
+        decl.setValueDecl(valueDecl);
+        context.semanticInfoChain.setASTForDecl(valueDecl, moduleNameAST);
+    }
+
+    function containsExecutableCode(members) {
+        for (var i = 0, n = members.childCount(); i < n; i++) {
+            var member = members.childAt(i);
+
+            if (member.kind() === 130 /* ModuleDeclaration */) {
+                var moduleDecl = member;
+
+                if (containsExecutableCode(moduleDecl.moduleElements)) {
+                    return true;
+                }
+            } else if (member.kind() === 133 /* ImportDeclaration */) {
+                if (TypeScript.hasModifier(member.modifiers, 1 /* Exported */)) {
+                    return true;
+                }
+            } else if (member.kind() !== 128 /* InterfaceDeclaration */ && member.kind() !== 134 /* ExportAssignment */) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    function preCollectClassDecls(classDecl, context) {
+        var declFlags = 0 /* None */;
+
+        if ((TypeScript.hasModifier(classDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(classDecl, context)) && !containingModuleHasExportAssignment(classDecl)) {
+            declFlags |= 1 /* Exported */;
+        }
+
+        if (TypeScript.hasModifier(classDecl.modifiers, 8 /* Ambient */) || isParsingAmbientModule(classDecl, context) || context.isDeclareFile) {
+            declFlags |= 8 /* Ambient */;
+        }
+
+        var parent = context.getParent();
+
+        var decl = new TypeScript.NormalPullDecl(classDecl.identifier.valueText(), classDecl.identifier.text(), 8 /* Class */, declFlags, parent);
+
+        var constructorDecl = new TypeScript.NormalPullDecl(classDecl.identifier.valueText(), classDecl.identifier.text(), 512 /* Variable */, declFlags | 16384 /* ClassConstructorVariable */, parent);
+
+        decl.setValueDecl(constructorDecl);
+
+        context.semanticInfoChain.setDeclForAST(classDecl, decl);
+        context.semanticInfoChain.setASTForDecl(decl, classDecl);
+        context.semanticInfoChain.setASTForDecl(constructorDecl, classDecl);
+
+        context.pushParent(decl);
+    }
+
+    function preCollectObjectTypeDecls(objectType, context) {
+        if (objectType.parent.kind() === 128 /* InterfaceDeclaration */) {
+            return;
+        }
+
+        var declFlags = 0 /* None */;
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl("", "", 8388608 /* ObjectType */, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(objectType, decl);
+        context.semanticInfoChain.setASTForDecl(decl, objectType);
+
+        context.pushParent(decl);
+    }
+
+    function preCollectInterfaceDecls(interfaceDecl, context) {
+        var declFlags = 0 /* None */;
+
+        if ((TypeScript.hasModifier(interfaceDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(interfaceDecl, context)) && !containingModuleHasExportAssignment(interfaceDecl)) {
+            declFlags |= 1 /* Exported */;
+        }
+
+        var parent = context.getParent();
+
+        var decl = new TypeScript.NormalPullDecl(interfaceDecl.identifier.valueText(), interfaceDecl.identifier.text(), 16 /* Interface */, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(interfaceDecl, decl);
+        context.semanticInfoChain.setASTForDecl(decl, interfaceDecl);
+
+        context.pushParent(decl);
+    }
+
+    function preCollectParameterDecl(argDecl, context) {
+        var declFlags = 0 /* None */;
+
+        if (TypeScript.hasModifier(argDecl.modifiers, 2 /* Private */)) {
+            declFlags |= 2 /* Private */;
+        } else {
+            declFlags |= 4 /* Public */;
+        }
+
+        if (argDecl.questionToken !== null || argDecl.equalsValueClause !== null || argDecl.dotDotDotToken !== null) {
+            declFlags |= 128 /* Optional */;
+        }
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(argDecl.identifier.valueText(), argDecl.identifier.text(), 2048 /* Parameter */, declFlags, parent);
+
+        if (argDecl.equalsValueClause) {
+            parent.flags |= 33554432 /* HasDefaultArgs */;
+        }
+
+        if (parent.kind === 32768 /* ConstructorMethod */) {
+            decl.setFlag(67108864 /* ConstructorParameter */);
+        }
+
+        var isPublicOrPrivate = TypeScript.hasModifier(argDecl.modifiers, 4 /* Public */ | 2 /* Private */);
+        var isInConstructor = parent.kind === 32768 /* ConstructorMethod */;
+        if (isPublicOrPrivate && isInConstructor) {
+            var parentsParent = context.parentChain[context.parentChain.length - 2];
+
+            var propDeclFlags = declFlags & ~128 /* Optional */;
+            var propDecl = new TypeScript.NormalPullDecl(argDecl.identifier.valueText(), argDecl.identifier.text(), 4096 /* Property */, propDeclFlags, parentsParent);
+            propDecl.setValueDecl(decl);
+            decl.setFlag(8388608 /* PropertyParameter */);
+            propDecl.setFlag(8388608 /* PropertyParameter */);
+
+            if (parent.kind === 32768 /* ConstructorMethod */) {
+                propDecl.setFlag(67108864 /* ConstructorParameter */);
+            }
+
+            context.semanticInfoChain.setASTForDecl(decl, argDecl);
+            context.semanticInfoChain.setASTForDecl(propDecl, argDecl);
+            context.semanticInfoChain.setDeclForAST(argDecl, propDecl);
+        } else {
+            context.semanticInfoChain.setASTForDecl(decl, argDecl);
+            context.semanticInfoChain.setDeclForAST(argDecl, decl);
+        }
+
+        parent.addVariableDeclToGroup(decl);
+    }
+
+    function preCollectTypeParameterDecl(typeParameterDecl, context) {
+        var declFlags = 0 /* None */;
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(typeParameterDecl.identifier.valueText(), typeParameterDecl.identifier.text(), 8192 /* TypeParameter */, declFlags, parent);
+        context.semanticInfoChain.setASTForDecl(decl, typeParameterDecl);
+        context.semanticInfoChain.setDeclForAST(typeParameterDecl, decl);
+    }
+
+    function createPropertySignature(propertyDecl, context) {
+        var declFlags = 4 /* Public */;
+        var parent = context.getParent();
+        var declType = 4096 /* Property */;
+
+        if (propertyDecl.questionToken !== null) {
+            declFlags |= 128 /* Optional */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(propertyDecl.propertyName.valueText(), propertyDecl.propertyName.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(propertyDecl, decl);
+        context.semanticInfoChain.setASTForDecl(decl, propertyDecl);
+    }
+
+    function createMemberVariableDeclaration(memberDecl, context) {
+        var declFlags = 0 /* None */;
+        var declType = 4096 /* Property */;
+
+        if (TypeScript.hasModifier(memberDecl.modifiers, 2 /* Private */)) {
+            declFlags |= 2 /* Private */;
+        } else {
+            declFlags |= 4 /* Public */;
+        }
+
+        if (TypeScript.hasModifier(memberDecl.modifiers, 16 /* Static */)) {
+            declFlags |= 16 /* Static */;
+        }
+
+        var parent = context.getParent();
+
+        var decl = new TypeScript.NormalPullDecl(memberDecl.variableDeclarator.propertyName.valueText(), memberDecl.variableDeclarator.propertyName.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(memberDecl, decl);
+        context.semanticInfoChain.setDeclForAST(memberDecl.variableDeclarator, decl);
+        context.semanticInfoChain.setASTForDecl(decl, memberDecl);
+    }
+
+    function createVariableDeclaration(varDecl, context) {
+        var declFlags = 0 /* None */;
+        var declType = 512 /* Variable */;
+
+        var modifiers = TypeScript.ASTHelpers.getVariableDeclaratorModifiers(varDecl);
+        if ((TypeScript.hasModifier(modifiers, 1 /* Exported */) || isParsingAmbientModule(varDecl, context)) && !containingModuleHasExportAssignment(varDecl)) {
+            declFlags |= 1 /* Exported */;
+        }
+
+        if (TypeScript.hasModifier(modifiers, 8 /* Ambient */) || isParsingAmbientModule(varDecl, context) || context.isDeclareFile) {
+            declFlags |= 8 /* Ambient */;
+        }
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(varDecl.propertyName.valueText(), varDecl.propertyName.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(varDecl, decl);
+        context.semanticInfoChain.setASTForDecl(decl, varDecl);
+
+        if (parent) {
+            parent.addVariableDeclToGroup(decl);
+        }
+    }
+
+    function preCollectVarDecls(ast, context) {
+        if (ast.parent.kind() === 136 /* MemberVariableDeclaration */) {
+            return;
+        }
+
+        var varDecl = ast;
+        createVariableDeclaration(varDecl, context);
+    }
+
+    function createFunctionTypeDeclaration(functionTypeDeclAST, context) {
+        var declFlags = 2048 /* Signature */;
+        var declType = 16777216 /* FunctionType */;
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(functionTypeDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, functionTypeDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function createConstructorTypeDeclaration(constructorTypeDeclAST, context) {
+        var declFlags = 0 /* None */;
+        var declType = 33554432 /* ConstructorType */;
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(constructorTypeDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, constructorTypeDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function createFunctionDeclaration(funcDeclAST, context) {
+        var declFlags = 0 /* None */;
+        var declType = 16384 /* Function */;
+
+        if ((TypeScript.hasModifier(funcDeclAST.modifiers, 1 /* Exported */) || isParsingAmbientModule(funcDeclAST, context)) && !containingModuleHasExportAssignment(funcDeclAST)) {
+            declFlags |= 1 /* Exported */;
+        }
+
+        if (TypeScript.hasModifier(funcDeclAST.modifiers, 8 /* Ambient */) || isParsingAmbientModule(funcDeclAST, context) || context.isDeclareFile) {
+            declFlags |= 8 /* Ambient */;
+        }
+
+        if (!funcDeclAST.block) {
+            declFlags |= 2048 /* Signature */;
+        }
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(funcDeclAST.identifier.valueText(), funcDeclAST.identifier.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(funcDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, funcDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function createAnyFunctionExpressionDeclaration(functionExpressionDeclAST, id, context, displayName) {
+        if (typeof displayName === "undefined") { displayName = null; }
+        var declFlags = 0 /* None */;
+
+        if (functionExpressionDeclAST.kind() === 219 /* SimpleArrowFunctionExpression */ || functionExpressionDeclAST.kind() === 218 /* ParenthesizedArrowFunctionExpression */) {
+            declFlags |= 8192 /* ArrowFunction */;
+        }
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var name = id ? id.text() : "";
+        var displayNameText = displayName ? displayName.text() : "";
+        var decl = new TypeScript.PullFunctionExpressionDecl(name, declFlags, parent, displayNameText);
+        context.semanticInfoChain.setDeclForAST(functionExpressionDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, functionExpressionDeclAST);
+
+        context.pushParent(decl);
+
+        if (functionExpressionDeclAST.kind() === 219 /* SimpleArrowFunctionExpression */) {
+            var simpleArrow = functionExpressionDeclAST;
+            var declFlags = 4 /* Public */;
+
+            var parent = context.getParent();
+
+            if (TypeScript.hasFlag(parent.flags, 2097152 /* DeclaredInAWithBlock */)) {
+                declFlags |= 2097152 /* DeclaredInAWithBlock */;
+            }
+
+            var decl = new TypeScript.NormalPullDecl(simpleArrow.identifier.valueText(), simpleArrow.identifier.text(), 2048 /* Parameter */, declFlags, parent);
+
+            context.semanticInfoChain.setASTForDecl(decl, simpleArrow.identifier);
+            context.semanticInfoChain.setDeclForAST(simpleArrow.identifier, decl);
+
+            parent.addVariableDeclToGroup(decl);
+        }
+    }
+
+    function createMemberFunctionDeclaration(funcDecl, context) {
+        var declFlags = 0 /* None */;
+        var declType = 65536 /* Method */;
+
+        if (TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */)) {
+            declFlags |= 16 /* Static */;
+        }
+
+        if (TypeScript.hasModifier(funcDecl.modifiers, 2 /* Private */)) {
+            declFlags |= 2 /* Private */;
+        } else {
+            declFlags |= 4 /* Public */;
+        }
+
+        if (!funcDecl.block) {
+            declFlags |= 2048 /* Signature */;
+        }
+
+        var parent = context.getParent();
+
+        var decl = new TypeScript.NormalPullDecl(funcDecl.propertyName.valueText(), funcDecl.propertyName.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(funcDecl, decl);
+        context.semanticInfoChain.setASTForDecl(decl, funcDecl);
+
+        context.pushParent(decl);
+    }
+
+    function createIndexSignatureDeclaration(indexSignatureDeclAST, context) {
+        var declFlags = 2048 /* Signature */;
+        var declType = 4194304 /* IndexSignature */;
+
+        var parent = context.getParent();
+
+        var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(indexSignatureDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, indexSignatureDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function createCallSignatureDeclaration(callSignature, context) {
+        var isChildOfObjectType = callSignature.parent && callSignature.parent.parent && callSignature.parent.kind() === 2 /* SeparatedList */ && callSignature.parent.parent.kind() === 122 /* ObjectType */;
+
+        if (!isChildOfObjectType) {
+            return;
+        }
+
+        var declFlags = 2048 /* Signature */;
+        var declType = 1048576 /* CallSignature */;
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(callSignature, decl);
+        context.semanticInfoChain.setASTForDecl(decl, callSignature);
+
+        context.pushParent(decl);
+    }
+
+    function createMethodSignatureDeclaration(method, context) {
+        var declFlags = 0 /* None */;
+        var declType = 65536 /* Method */;
+
+        declFlags |= 4 /* Public */;
+        declFlags |= 2048 /* Signature */;
+
+        if (method.questionToken !== null) {
+            declFlags |= 128 /* Optional */;
+        }
+
+        var parent = context.getParent();
+
+        var decl = new TypeScript.NormalPullDecl(method.propertyName.valueText(), method.propertyName.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(method, decl);
+        context.semanticInfoChain.setASTForDecl(decl, method);
+
+        context.pushParent(decl);
+    }
+
+    function createConstructSignatureDeclaration(constructSignatureDeclAST, context) {
+        var declFlags = 2048 /* Signature */;
+        var declType = 2097152 /* ConstructSignature */;
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(constructSignatureDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, constructSignatureDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function createClassConstructorDeclaration(constructorDeclAST, context) {
+        var declFlags = 0 /* None */;
+        var declType = 32768 /* ConstructorMethod */;
+
+        if (!constructorDeclAST.block) {
+            declFlags |= 2048 /* Signature */;
+        }
+
+        var parent = context.getParent();
+
+        if (parent) {
+            var parentFlags = parent.flags;
+
+            if (parentFlags & 1 /* Exported */) {
+                declFlags |= 1 /* Exported */;
+            }
+        }
+
+        var decl = new TypeScript.NormalPullDecl(parent.name, parent.getDisplayName(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(constructorDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, constructorDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function createGetAccessorDeclaration(getAccessorDeclAST, context) {
+        var declFlags = 4 /* Public */;
+        var declType = 262144 /* GetAccessor */;
+
+        if (TypeScript.hasModifier(getAccessorDeclAST.modifiers, 16 /* Static */)) {
+            declFlags |= 16 /* Static */;
+        }
+
+        if (TypeScript.hasModifier(getAccessorDeclAST.modifiers, 2 /* Private */)) {
+            declFlags |= 2 /* Private */;
+        } else {
+            declFlags |= 4 /* Public */;
+        }
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(getAccessorDeclAST.propertyName.valueText(), getAccessorDeclAST.propertyName.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(getAccessorDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, getAccessorDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function createFunctionExpressionDeclaration(expression, context) {
+        createAnyFunctionExpressionDeclaration(expression, expression.identifier, context);
+    }
+
+    function createSetAccessorDeclaration(setAccessorDeclAST, context) {
+        var declFlags = 4 /* Public */;
+        var declType = 524288 /* SetAccessor */;
+
+        if (TypeScript.hasModifier(setAccessorDeclAST.modifiers, 16 /* Static */)) {
+            declFlags |= 16 /* Static */;
+        }
+
+        if (TypeScript.hasModifier(setAccessorDeclAST.modifiers, 2 /* Private */)) {
+            declFlags |= 2 /* Private */;
+        } else {
+            declFlags |= 4 /* Public */;
+        }
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(setAccessorDeclAST.propertyName.valueText(), setAccessorDeclAST.propertyName.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(setAccessorDeclAST, decl);
+        context.semanticInfoChain.setASTForDecl(decl, setAccessorDeclAST);
+
+        context.pushParent(decl);
+    }
+
+    function preCollectCatchDecls(ast, context) {
+        var declFlags = 0 /* None */;
+        var declType = 268435456 /* CatchBlock */;
+
+        var parent = context.getParent();
+
+        if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(ast, decl);
+        context.semanticInfoChain.setASTForDecl(decl, ast);
+
+        context.pushParent(decl);
+
+        var declFlags = 0 /* None */;
+        var declType = 1024 /* CatchVariable */;
+
+        var parent = context.getParent();
+
+        if (TypeScript.hasFlag(parent.flags, 2097152 /* DeclaredInAWithBlock */)) {
+            declFlags |= 2097152 /* DeclaredInAWithBlock */;
+        }
+
+        var decl = new TypeScript.NormalPullDecl(ast.identifier.valueText(), ast.identifier.text(), declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(ast.identifier, decl);
+        context.semanticInfoChain.setASTForDecl(decl, ast.identifier);
+
+        if (parent) {
+            parent.addVariableDeclToGroup(decl);
+        }
+    }
+
+    function preCollectWithDecls(ast, context) {
+        var declFlags = 0 /* None */;
+        var declType = 134217728 /* WithBlock */;
+
+        var parent = context.getParent();
+
+        var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent);
+        context.semanticInfoChain.setDeclForAST(ast, decl);
+        context.semanticInfoChain.setASTForDecl(decl, ast);
+
+        context.pushParent(decl);
+    }
+
+    function preCollectObjectLiteralDecls(ast, context) {
+        var decl = new TypeScript.NormalPullDecl("", "", 256 /* ObjectLiteral */, 0 /* None */, context.getParent());
+
+        context.semanticInfoChain.setDeclForAST(ast, decl);
+        context.semanticInfoChain.setASTForDecl(decl, ast);
+
+        context.pushParent(decl);
+    }
+
+    function preCollectSimplePropertyAssignmentDecls(propertyAssignment, context) {
+        var assignmentText = TypeScript.getPropertyAssignmentNameTextFromIdentifier(propertyAssignment.propertyName);
+        var span = TypeScript.TextSpan.fromBounds(propertyAssignment.start(), propertyAssignment.end());
+
+        var decl = new TypeScript.NormalPullDecl(assignmentText.memberName, assignmentText.actualText, 4096 /* Property */, 4 /* Public */, context.getParent());
+
+        context.semanticInfoChain.setDeclForAST(propertyAssignment, decl);
+        context.semanticInfoChain.setASTForDecl(decl, propertyAssignment);
+    }
+
+    function preCollectFunctionPropertyAssignmentDecls(propertyAssignment, context) {
+        var assignmentText = TypeScript.getPropertyAssignmentNameTextFromIdentifier(propertyAssignment.propertyName);
+
+        var decl = new TypeScript.NormalPullDecl(assignmentText.memberName, assignmentText.actualText, 4096 /* Property */, 4 /* Public */, context.getParent());
+
+        context.semanticInfoChain.setDeclForAST(propertyAssignment, decl);
+        context.semanticInfoChain.setASTForDecl(decl, propertyAssignment);
+
+        createAnyFunctionExpressionDeclaration(propertyAssignment, propertyAssignment.propertyName, context, propertyAssignment.propertyName);
+    }
+
+    function preCollectDecls(ast, context) {
+        switch (ast.kind()) {
+            case 120 /* SourceUnit */:
+                preCollectScriptDecls(ast, context);
+                break;
+            case 132 /* EnumDeclaration */:
+                preCollectEnumDecls(ast, context);
+                break;
+            case 243 /* EnumElement */:
+                createEnumElementDecls(ast, context);
+                break;
+            case 130 /* ModuleDeclaration */:
+                preCollectModuleDecls(ast, context);
+                break;
+            case 131 /* ClassDeclaration */:
+                preCollectClassDecls(ast, context);
+                break;
+            case 128 /* InterfaceDeclaration */:
+                preCollectInterfaceDecls(ast, context);
+                break;
+            case 122 /* ObjectType */:
+                preCollectObjectTypeDecls(ast, context);
+                break;
+            case 242 /* Parameter */:
+                preCollectParameterDecl(ast, context);
+                break;
+            case 136 /* MemberVariableDeclaration */:
+                createMemberVariableDeclaration(ast, context);
+                break;
+            case 141 /* PropertySignature */:
+                createPropertySignature(ast, context);
+                break;
+            case 225 /* VariableDeclarator */:
+                preCollectVarDecls(ast, context);
+                break;
+            case 137 /* ConstructorDeclaration */:
+                createClassConstructorDeclaration(ast, context);
+                break;
+            case 139 /* GetAccessor */:
+                createGetAccessorDeclaration(ast, context);
+                break;
+            case 140 /* SetAccessor */:
+                createSetAccessorDeclaration(ast, context);
+                break;
+            case 222 /* FunctionExpression */:
+                createFunctionExpressionDeclaration(ast, context);
+                break;
+            case 135 /* MemberFunctionDeclaration */:
+                createMemberFunctionDeclaration(ast, context);
+                break;
+            case 144 /* IndexSignature */:
+                createIndexSignatureDeclaration(ast, context);
+                break;
+            case 123 /* FunctionType */:
+                createFunctionTypeDeclaration(ast, context);
+                break;
+            case 125 /* ConstructorType */:
+                createConstructorTypeDeclaration(ast, context);
+                break;
+            case 142 /* CallSignature */:
+                createCallSignatureDeclaration(ast, context);
+                break;
+            case 143 /* ConstructSignature */:
+                createConstructSignatureDeclaration(ast, context);
+                break;
+            case 145 /* MethodSignature */:
+                createMethodSignatureDeclaration(ast, context);
+                break;
+            case 129 /* FunctionDeclaration */:
+                createFunctionDeclaration(ast, context);
+                break;
+            case 219 /* SimpleArrowFunctionExpression */:
+            case 218 /* ParenthesizedArrowFunctionExpression */:
+                createAnyFunctionExpressionDeclaration(ast, null, context);
+                break;
+            case 133 /* ImportDeclaration */:
+                preCollectImportDecls(ast, context);
+                break;
+            case 238 /* TypeParameter */:
+                preCollectTypeParameterDecl(ast, context);
+                break;
+            case 236 /* CatchClause */:
+                preCollectCatchDecls(ast, context);
+                break;
+            case 163 /* WithStatement */:
+                preCollectWithDecls(ast, context);
+                break;
+            case 215 /* ObjectLiteralExpression */:
+                preCollectObjectLiteralDecls(ast, context);
+                break;
+            case 240 /* SimplePropertyAssignment */:
+                preCollectSimplePropertyAssignmentDecls(ast, context);
+                break;
+            case 241 /* FunctionPropertyAssignment */:
+                preCollectFunctionPropertyAssignmentDecls(ast, context);
+                break;
+        }
+    }
+
+    function isContainer(decl) {
+        return decl.kind === 4 /* Container */ || decl.kind === 32 /* DynamicModule */ || decl.kind === 64 /* Enum */;
+    }
+
+    function getInitializationFlag(decl) {
+        if (decl.kind & 4 /* Container */) {
+            return 32768 /* InitializedModule */;
+        } else if (decl.kind & 32 /* DynamicModule */) {
+            return 65536 /* InitializedDynamicModule */;
+        }
+
+        return 0 /* None */;
+    }
+
+    function hasInitializationFlag(decl) {
+        var kind = decl.kind;
+
+        if (kind & 4 /* Container */) {
+            return (decl.flags & 32768 /* InitializedModule */) !== 0;
+        } else if (kind & 32 /* DynamicModule */) {
+            return (decl.flags & 65536 /* InitializedDynamicModule */) !== 0;
+        }
+
+        return false;
+    }
+
+    function postCollectDecls(ast, context) {
+        var currentDecl = context.getParent();
+
+        if (ast.kind() === 11 /* IdentifierName */ || ast.kind() === 14 /* StringLiteral */) {
+            if (currentDecl.kind === 4 /* Container */ || currentDecl.kind === 32 /* DynamicModule */) {
+                return;
+            }
+        }
+
+        if (ast.kind() === 130 /* ModuleDeclaration */) {
+            var moduleDeclaration = ast;
+            if (moduleDeclaration.stringLiteral) {
+                TypeScript.Debug.assert(currentDecl.ast() === moduleDeclaration.stringLiteral);
+                context.popParent();
+            } else {
+                var moduleNames = TypeScript.ASTHelpers.getModuleNames(moduleDeclaration.name);
+                for (var i = moduleNames.length - 1; i >= 0; i--) {
+                    var moduleName = moduleNames[i];
+                    TypeScript.Debug.assert(currentDecl.ast() === moduleName);
+                    context.popParent();
+                    currentDecl = context.getParent();
+                }
+            }
+        }
+
+        if (ast.kind() === 132 /* EnumDeclaration */) {
+            computeEnumElementConstantValues(ast, currentDecl, context);
+        }
+
+        while (currentDecl.getParentDecl() && currentDecl.ast() === ast) {
+            context.popParent();
+            currentDecl = context.getParent();
+        }
+    }
+
+    function computeEnumElementConstantValues(ast, enumDecl, context) {
+        TypeScript.Debug.assert(enumDecl.kind === 64 /* Enum */);
+
+        var isAmbientEnum = TypeScript.hasFlag(enumDecl.flags, 8 /* Ambient */);
+        var inConstantSection = !isAmbientEnum;
+        var currentConstantValue = 0;
+        var enumMemberDecls = enumDecl.getChildDecls();
+
+        for (var i = 0, n = ast.enumElements.nonSeparatorCount(); i < n; i++) {
+            var enumElement = ast.enumElements.nonSeparatorAt(i);
+            var enumElementDecl = TypeScript.ArrayUtilities.first(enumMemberDecls, function (d) {
+                return context.semanticInfoChain.getASTForDecl(d) === enumElement;
+            });
+
+            TypeScript.Debug.assert(enumElementDecl.kind === 67108864 /* EnumMember */);
+
+            if (enumElement.equalsValueClause === null) {
+                if (inConstantSection) {
+                    enumElementDecl.constantValue = currentConstantValue;
+                    currentConstantValue++;
+                }
+            } else {
+                enumElementDecl.constantValue = computeEnumElementConstantValue(enumElement.equalsValueClause.value, enumMemberDecls, context);
+                if (enumElementDecl.constantValue !== null && !isAmbientEnum) {
+                    inConstantSection = true;
+                    currentConstantValue = enumElementDecl.constantValue + 1;
+                } else {
+                    inConstantSection = false;
+                }
+            }
+
+            TypeScript.Debug.assert(enumElementDecl.constantValue !== undefined);
+        }
+    }
+
+    function computeEnumElementConstantValue(expression, enumMemberDecls, context) {
+        TypeScript.Debug.assert(expression);
+
+        if (TypeScript.ASTHelpers.isIntegerLiteralAST(expression)) {
+            var token;
+            switch (expression.kind()) {
+                case 164 /* PlusExpression */:
+                case 165 /* NegateExpression */:
+                    token = expression.operand;
+                    break;
+                default:
+                    token = expression;
+            }
+
+            var value = token.value();
+            return value && expression.kind() === 165 /* NegateExpression */ ? -value : value;
+        } else if (context.propagateEnumConstants) {
+            switch (expression.kind()) {
+                case 11 /* IdentifierName */:
+                    var name = expression;
+                    var matchingEnumElement = TypeScript.ArrayUtilities.firstOrDefault(enumMemberDecls, function (d) {
+                        return d.name === name.valueText();
+                    });
+
+                    return matchingEnumElement ? matchingEnumElement.constantValue : null;
+
+                case 202 /* LeftShiftExpression */:
+                    var binaryExpression = expression;
+                    var left = computeEnumElementConstantValue(binaryExpression.left, enumMemberDecls, context);
+                    var right = computeEnumElementConstantValue(binaryExpression.right, enumMemberDecls, context);
+                    if (left === null || right === null) {
+                        return null;
+                    }
+
+                    return left << right;
+
+                case 189 /* BitwiseOrExpression */:
+                    var binaryExpression = expression;
+                    var left = computeEnumElementConstantValue(binaryExpression.left, enumMemberDecls, context);
+                    var right = computeEnumElementConstantValue(binaryExpression.right, enumMemberDecls, context);
+                    if (left === null || right === null) {
+                        return null;
+                    }
+
+                    return left | right;
+            }
+
+            return null;
+        } else {
+            return null;
+        }
+    }
+
+    (function (DeclarationCreator) {
+        function create(document, semanticInfoChain, compilationSettings) {
+            var declCollectionContext = new DeclCollectionContext(document, semanticInfoChain, compilationSettings.propagateEnumConstants());
+
+            TypeScript.getAstWalkerFactory().simpleWalk(document.sourceUnit(), preCollectDecls, postCollectDecls, declCollectionContext);
+
+            return declCollectionContext.getParent();
+        }
+        DeclarationCreator.create = create;
+    })(TypeScript.DeclarationCreator || (TypeScript.DeclarationCreator = {}));
+    var DeclarationCreator = TypeScript.DeclarationCreator;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var PullSymbolBinder = (function () {
+        function PullSymbolBinder(semanticInfoChain) {
+            this.semanticInfoChain = semanticInfoChain;
+            this.declsBeingBound = [];
+            this.inBindingOtherDeclsWalker = new TypeScript.PullHelpers.OtherPullDeclsWalker();
+        }
+        PullSymbolBinder.prototype.getParent = function (decl, returnInstanceType) {
+            if (typeof returnInstanceType === "undefined") { returnInstanceType = false; }
+            var parentDecl = decl.getParentDecl();
+
+            if (parentDecl.kind === 1 /* Script */) {
+                return null;
+            }
+
+            var parent = parentDecl.getSymbol();
+
+            if (!parent && parentDecl && !parentDecl.hasBeenBound()) {
+                this.bindDeclToPullSymbol(parentDecl);
+            }
+
+            parent = parentDecl.getSymbol();
+            if (parent) {
+                var parentDeclKind = parentDecl.kind;
+                if (parentDeclKind === 262144 /* GetAccessor */) {
+                    parent = parent.getGetter();
+                } else if (parentDeclKind === 524288 /* SetAccessor */) {
+                    parent = parent.getSetter();
+                }
+            }
+
+            if (parent) {
+                if (returnInstanceType && parent.isType() && parent.isContainer()) {
+                    var instanceSymbol = parent.getInstanceSymbol();
+
+                    if (instanceSymbol) {
+                        return instanceSymbol.type;
+                    }
+                }
+
+                return parent.type;
+            }
+
+            return null;
+        };
+
+        PullSymbolBinder.prototype.findDeclsInContext = function (startingDecl, declKind, searchGlobally) {
+            if (!searchGlobally) {
+                var parentDecl = startingDecl.getParentDecl();
+                return parentDecl.searchChildDecls(startingDecl.name, declKind);
+            }
+
+            var contextSymbolPath = startingDecl.getParentPath();
+
+            if (contextSymbolPath.length) {
+                var copyOfContextSymbolPath = [];
+
+                for (var i = 0; i < contextSymbolPath.length; i++) {
+                    if (contextSymbolPath[i].kind & 1 /* Script */) {
+                        continue;
+                    }
+                    copyOfContextSymbolPath[copyOfContextSymbolPath.length] = contextSymbolPath[i].name;
+                }
+
+                return this.semanticInfoChain.findDecls(copyOfContextSymbolPath, declKind);
+            }
+        };
+
+        PullSymbolBinder.prototype.getExistingSymbol = function (decl, searchKind, parent) {
+            var lookingForValue = (searchKind & 68147712 /* SomeValue */) !== 0;
+            var lookingForType = (searchKind & 58728795 /* SomeType */) !== 0;
+            var lookingForContainer = (searchKind & 164 /* SomeContainer */) !== 0;
+            var name = decl.name;
+            if (parent) {
+                var isExported = (decl.flags & 1 /* Exported */) !== 0;
+
+                var prevSymbol = null;
+                if (lookingForValue) {
+                    prevSymbol = parent.findContainedNonMember(name);
+                } else if (lookingForType) {
+                    prevSymbol = parent.findContainedNonMemberType(name, searchKind);
+                } else if (lookingForContainer) {
+                    prevSymbol = parent.findContainedNonMemberContainer(name, searchKind);
+                }
+                var prevIsExported = !prevSymbol;
+                if (!prevSymbol) {
+                    if (lookingForValue) {
+                        prevSymbol = parent.findMember(name, false);
+                    } else if (lookingForType) {
+                        prevSymbol = parent.findNestedType(name, searchKind);
+                    } else if (lookingForContainer) {
+                        prevSymbol = parent.findNestedContainer(name, searchKind);
+                    }
+                }
+
+                if (isExported && prevIsExported) {
+                    return prevSymbol;
+                }
+                if (prevSymbol) {
+                    var prevDecls = prevSymbol.getDeclarations();
+                    var lastPrevDecl = prevDecls[prevDecls.length - 1];
+                    var parentDecl = decl.getParentDecl();
+                    var prevParentDecl = lastPrevDecl && lastPrevDecl.getParentDecl();
+                    if (parentDecl !== prevParentDecl) {
+                        return null;
+                    }
+
+                    return prevSymbol;
+                }
+            } else {
+                var parentDecl = decl.getParentDecl();
+                if (parentDecl && parentDecl.kind === 1 /* Script */) {
+                    return this.semanticInfoChain.findTopLevelSymbol(name, searchKind, decl);
+                } else {
+                    var prevDecls = parentDecl && parentDecl.searchChildDecls(name, searchKind);
+                    return prevDecls[0] && prevDecls[0].getSymbol();
+                }
+            }
+
+            return null;
+        };
+
+        PullSymbolBinder.prototype.checkThatExportsMatch = function (decl, prevSymbol, reportError) {
+            if (typeof reportError === "undefined") { reportError = true; }
+            var isExported = (decl.flags & 1 /* Exported */) !== 0;
+            var prevDecls = prevSymbol.getDeclarations();
+            var prevIsExported = (prevDecls[prevDecls.length - 1].flags & 1 /* Exported */) !== 0;
+            if ((isExported !== prevIsExported) && !prevSymbol.isSignature() && (decl.kind & 7340032 /* SomeSignature */) === 0) {
+                if (reportError) {
+                    var ast = this.semanticInfoChain.getASTForDecl(decl);
+                    this.semanticInfoChain.addDiagnosticFromAST(ast, TypeScript.DiagnosticCode.All_declarations_of_merged_declaration_0_must_be_exported_or_not_exported, [decl.getDisplayName()]);
+                }
+                return false;
+            }
+
+            return true;
+        };
+
+        PullSymbolBinder.prototype.getIndexForInsertingSignatureAtEndOfEnclosingDeclInSignatureList = function (signature, currentSignatures) {
+            var signatureDecl = signature.getDeclarations()[0];
+            TypeScript.Debug.assert(signatureDecl);
+            var enclosingDecl = signatureDecl.getParentDecl();
+            var indexToInsert = TypeScript.ArrayUtilities.indexOf(currentSignatures, function (someSignature) {
+                return someSignature.getDeclarations()[0].getParentDecl() !== enclosingDecl;
+            });
+            return indexToInsert < 0 ? currentSignatures.length : indexToInsert;
+        };
+
+        PullSymbolBinder.prototype.bindEnumDeclarationToPullSymbol = function (enumContainerDecl) {
+            var enumName = enumContainerDecl.name;
+
+            var enumContainerSymbol = null;
+            var enumInstanceSymbol = null;
+            var moduleInstanceTypeSymbol = null;
+
+            var enumInstanceDecl = enumContainerDecl.getValueDecl();
+
+            var enumDeclKind = enumContainerDecl.kind;
+
+            var parent = this.getParent(enumContainerDecl);
+            var parentInstanceSymbol = this.getParent(enumContainerDecl, true);
+            var parentDecl = enumContainerDecl.getParentDecl();
+            var enumAST = this.semanticInfoChain.getASTForDecl(enumContainerDecl);
+
+            var isExported = enumContainerDecl.flags & 1 /* Exported */;
+
+            var createdNewSymbol = false;
+
+            enumContainerSymbol = this.getExistingSymbol(enumContainerDecl, 64 /* Enum */, parent);
+
+            if (enumContainerSymbol) {
+                if (enumContainerSymbol.kind !== enumDeclKind) {
+                    this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(enumAST.identifier, enumContainerDecl.getDisplayName(), enumContainerSymbol.getDeclarations()[0].ast());
+                    enumContainerSymbol = null;
+                } else if (!this.checkThatExportsMatch(enumContainerDecl, enumContainerSymbol)) {
+                    enumContainerSymbol = null;
+                }
+            }
+
+            if (enumContainerSymbol) {
+                enumInstanceSymbol = enumContainerSymbol.getInstanceSymbol();
+            } else {
+                enumContainerSymbol = new TypeScript.PullContainerSymbol(enumName, enumDeclKind);
+                createdNewSymbol = true;
+
+                if (!parent) {
+                    this.semanticInfoChain.cacheGlobalSymbol(enumContainerSymbol, 64 /* Enum */);
+                }
+            }
+
+            enumContainerSymbol.addDeclaration(enumContainerDecl);
+            enumContainerDecl.setSymbol(enumContainerSymbol);
+
+            this.semanticInfoChain.setSymbolForAST(enumAST.identifier, enumContainerSymbol);
+            this.semanticInfoChain.setSymbolForAST(enumAST, enumContainerSymbol);
+
+            if (!enumInstanceSymbol) {
+                var variableSymbol = null;
+                if (parentInstanceSymbol) {
+                    if (isExported) {
+                        variableSymbol = parentInstanceSymbol.findMember(enumName, false);
+
+                        if (!variableSymbol) {
+                            variableSymbol = parentInstanceSymbol.findContainedNonMember(enumName);
+                        }
+                    } else {
+                        variableSymbol = parentInstanceSymbol.findContainedNonMember(enumName);
+
+                        if (!variableSymbol) {
+                            variableSymbol = parentInstanceSymbol.findMember(enumName, false);
+                        }
+                    }
+
+                    if (variableSymbol) {
+                        var declarations = variableSymbol.getDeclarations();
+
+                        if (declarations.length) {
+                            var variableSymbolParentDecl = declarations[0].getParentDecl();
+
+                            if (parentDecl !== variableSymbolParentDecl) {
+                                variableSymbol = null;
+                            }
+                        }
+                    }
+                } else if (!(enumContainerDecl.flags & 1 /* Exported */)) {
+                    var siblingDecls = parentDecl.getChildDecls();
+                    var augmentedDecl = null;
+
+                    for (var i = 0; i < siblingDecls.length; i++) {
+                        if (siblingDecls[i] === enumContainerDecl) {
+                            break;
+                        }
+
+                        if ((siblingDecls[i].name === enumName) && (siblingDecls[i].kind & 68147712 /* SomeValue */)) {
+                            augmentedDecl = siblingDecls[i];
+                            break;
+                        }
+                    }
+
+                    if (augmentedDecl) {
+                        variableSymbol = augmentedDecl.getSymbol();
+
+                        if (variableSymbol) {
+                            if (variableSymbol.isContainer()) {
+                                variableSymbol = variableSymbol.getInstanceSymbol();
+                            } else if (variableSymbol && variableSymbol.isType()) {
+                                variableSymbol = variableSymbol.getConstructorMethod();
+                            }
+                        }
+                    }
+                }
+
+                if (variableSymbol) {
+                    enumInstanceSymbol = variableSymbol;
+                    moduleInstanceTypeSymbol = variableSymbol.type;
+                } else {
+                    enumInstanceSymbol = new TypeScript.PullSymbol(enumName, 512 /* Variable */);
+                }
+
+                enumContainerSymbol.setInstanceSymbol(enumInstanceSymbol);
+
+                if (!moduleInstanceTypeSymbol) {
+                    moduleInstanceTypeSymbol = new TypeScript.PullTypeSymbol("", 8388608 /* ObjectType */);
+                    enumInstanceSymbol.type = moduleInstanceTypeSymbol;
+                }
+
+                moduleInstanceTypeSymbol.addDeclaration(enumContainerDecl);
+
+                if (!moduleInstanceTypeSymbol.getAssociatedContainerType()) {
+                    moduleInstanceTypeSymbol.setAssociatedContainerType(enumContainerSymbol);
+                }
+            }
+
+            if (createdNewSymbol && parent) {
+                if (enumContainerDecl.flags & 1 /* Exported */) {
+                    parent.addEnclosedMemberType(enumContainerSymbol);
+                } else {
+                    parent.addEnclosedNonMemberType(enumContainerSymbol);
+                }
+            }
+
+            if (createdNewSymbol) {
+                this.bindEnumIndexerDeclsToPullSymbols(enumContainerSymbol);
+            }
+            var valueDecl = enumContainerDecl.getValueDecl();
+
+            if (valueDecl) {
+                valueDecl.ensureSymbolIsBound();
+            }
+        };
+
+        PullSymbolBinder.prototype.bindEnumIndexerDeclsToPullSymbols = function (enumContainerSymbol) {
+            var enumContainerInstanceTypeSymbol = enumContainerSymbol.getInstanceSymbol().type;
+
+            var syntheticIndexerParameterSymbol = new TypeScript.PullSymbol("x", 2048 /* Parameter */);
+            syntheticIndexerParameterSymbol.type = this.semanticInfoChain.numberTypeSymbol;
+            syntheticIndexerParameterSymbol.setResolved();
+            syntheticIndexerParameterSymbol.setIsSynthesized();
+
+            var syntheticIndexerSignatureSymbol = new TypeScript.PullSignatureSymbol(4194304 /* IndexSignature */);
+            syntheticIndexerSignatureSymbol.addParameter(syntheticIndexerParameterSymbol);
+            syntheticIndexerSignatureSymbol.returnType = this.semanticInfoChain.stringTypeSymbol;
+            syntheticIndexerSignatureSymbol.setResolved();
+            syntheticIndexerSignatureSymbol.setIsSynthesized();
+
+            enumContainerInstanceTypeSymbol.addIndexSignature(syntheticIndexerSignatureSymbol);
+        };
+
+        PullSymbolBinder.prototype.findExistingVariableSymbolForModuleValueDecl = function (decl) {
+            var isExported = TypeScript.hasFlag(decl.flags, 1 /* Exported */);
+            var modName = decl.name;
+            var parentInstanceSymbol = this.getParent(decl, true);
+            var parentDecl = decl.getParentDecl();
+
+            var variableSymbol = null;
+
+            if (parentInstanceSymbol) {
+                if (isExported) {
+                    variableSymbol = parentInstanceSymbol.findMember(modName, false);
+
+                    if (!variableSymbol) {
+                        variableSymbol = parentInstanceSymbol.findContainedNonMember(modName);
+                    }
+                } else {
+                    variableSymbol = parentInstanceSymbol.findContainedNonMember(modName);
+
+                    if (!variableSymbol) {
+                        variableSymbol = parentInstanceSymbol.findMember(modName, false);
+                    }
+                }
+
+                if (variableSymbol) {
+                    var declarations = variableSymbol.getDeclarations();
+
+                    if (declarations.length) {
+                        var variableSymbolParentDecl = declarations[0].getParentDecl();
+                        var isExportedOrHasTheSameParent = isExported || (parentDecl === variableSymbolParentDecl);
+
+                        var canReuseVariableSymbol = isExportedOrHasTheSameParent && this.checkThatExportsMatch(decl, variableSymbol, false);
+
+                        if (!canReuseVariableSymbol) {
+                            variableSymbol = null;
+                        }
+                    }
+                }
+            } else if (!isExported) {
+                var siblingDecls = parentDecl.getChildDecls();
+
+                for (var i = 0; i < siblingDecls.length; i++) {
+                    var sibling = siblingDecls[i];
+
+                    var siblingIsSomeValue = TypeScript.hasFlag(sibling.kind, 68147712 /* SomeValue */);
+                    var siblingIsFunctionOrHasImplictVarFlag = TypeScript.hasFlag(sibling.kind, 1032192 /* SomeFunction */) || TypeScript.hasFlag(sibling.flags, 118784 /* ImplicitVariable */);
+
+                    var isSiblingAnAugmentableVariable = sibling !== decl && sibling !== decl.getValueDecl() && sibling.name === modName && siblingIsSomeValue && siblingIsFunctionOrHasImplictVarFlag;
+
+                    if (isSiblingAnAugmentableVariable) {
+                        if (sibling.hasSymbol()) {
+                            variableSymbol = sibling.getSymbol();
+                            if (variableSymbol.isContainer()) {
+                                variableSymbol = variableSymbol.getInstanceSymbol();
+                            } else if (variableSymbol && variableSymbol.isType()) {
+                                variableSymbol = variableSymbol.getConstructorMethod();
+                            }
+
+                            break;
+                        }
+                    }
+                }
+            }
+            return variableSymbol;
+        };
+
+        PullSymbolBinder.prototype.bindModuleDeclarationToPullSymbol = function (moduleContainerDecl) {
+            var modName = moduleContainerDecl.name;
+
+            var moduleContainerTypeSymbol = null;
+            var moduleKind = moduleContainerDecl.kind;
+
+            var parent = this.getParent(moduleContainerDecl);
+            var parentInstanceSymbol = this.getParent(moduleContainerDecl, true);
+            var parentDecl = moduleContainerDecl.getParentDecl();
+            var moduleNameAST = this.semanticInfoChain.getASTForDecl(moduleContainerDecl);
+            var moduleDeclAST = TypeScript.ASTHelpers.getEnclosingModuleDeclaration(moduleNameAST);
+            if (!moduleDeclAST) {
+                TypeScript.Debug.assert(moduleKind === 32 /* DynamicModule */);
+                TypeScript.Debug.assert(moduleNameAST.kind() === 120 /* SourceUnit */);
+
+                moduleDeclAST = moduleNameAST;
+            }
+
+            var isExported = TypeScript.hasFlag(moduleContainerDecl.flags, 1 /* Exported */);
+            var searchKind = 164 /* SomeContainer */;
+            var isInitializedModule = (moduleContainerDecl.flags & 102400 /* SomeInitializedModule */) !== 0;
+
+            if (parent && moduleKind === 32 /* DynamicModule */) {
+                this.semanticInfoChain.addDiagnosticFromAST(moduleNameAST, TypeScript.DiagnosticCode.Ambient_external_module_declaration_must_be_defined_in_global_context, null);
+            }
+
+            var createdNewSymbol = false;
+
+            moduleContainerTypeSymbol = this.getExistingSymbol(moduleContainerDecl, searchKind, parent);
+
+            if (moduleContainerTypeSymbol) {
+                if (moduleContainerTypeSymbol.kind !== moduleKind) {
+                    if (isInitializedModule) {
+                        this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(moduleNameAST, moduleContainerDecl.getDisplayName(), moduleContainerTypeSymbol.getDeclarations()[0].ast());
+                    }
+
+                    moduleContainerTypeSymbol = null;
+                } else if (moduleKind === 32 /* DynamicModule */) {
+                    this.semanticInfoChain.addDiagnosticFromAST(moduleNameAST, TypeScript.DiagnosticCode.Ambient_external_module_declaration_cannot_be_reopened);
+                } else if (!this.checkThatExportsMatch(moduleContainerDecl, moduleContainerTypeSymbol)) {
+                    moduleContainerTypeSymbol = null;
+                }
+            }
+
+            if (!moduleContainerTypeSymbol) {
+                moduleContainerTypeSymbol = new TypeScript.PullContainerSymbol(modName, moduleKind);
+                createdNewSymbol = true;
+
+                if (!parent) {
+                    this.semanticInfoChain.cacheGlobalSymbol(moduleContainerTypeSymbol, searchKind);
+                }
+            }
+
+            moduleContainerTypeSymbol.addDeclaration(moduleContainerDecl);
+            moduleContainerDecl.setSymbol(moduleContainerTypeSymbol);
+
+            this.semanticInfoChain.setSymbolForAST(moduleNameAST, moduleContainerTypeSymbol);
+            this.semanticInfoChain.setSymbolForAST(moduleDeclAST, moduleContainerTypeSymbol);
+
+            var currentModuleValueDecl = moduleContainerDecl.getValueDecl();
+
+            var moduleDeclarations = moduleContainerTypeSymbol.getDeclarations();
+
+            if (createdNewSymbol) {
+                if (parent) {
+                    if (moduleContainerDecl.flags & 1 /* Exported */) {
+                        parent.addEnclosedMemberContainer(moduleContainerTypeSymbol);
+                    } else {
+                        parent.addEnclosedNonMemberContainer(moduleContainerTypeSymbol);
+                    }
+                }
+            }
+
+            if (currentModuleValueDecl) {
+                currentModuleValueDecl.ensureSymbolIsBound();
+
+                var instanceSymbol = null;
+                var instanceTypeSymbol = null;
+                if (currentModuleValueDecl.hasSymbol()) {
+                    instanceSymbol = currentModuleValueDecl.getSymbol();
+                } else {
+                    instanceSymbol = new TypeScript.PullSymbol(modName, 512 /* Variable */);
+                    currentModuleValueDecl.setSymbol(instanceSymbol);
+                    if (!instanceSymbol.hasDeclaration(currentModuleValueDecl)) {
+                        instanceSymbol.addDeclaration(currentModuleValueDecl);
+                    }
+                }
+
+                if (!instanceSymbol.type) {
+                    instanceSymbol.type = new TypeScript.PullTypeSymbol("", 8388608 /* ObjectType */);
+                }
+
+                moduleContainerTypeSymbol.setInstanceSymbol(instanceSymbol);
+
+                if (!instanceSymbol.type.getAssociatedContainerType()) {
+                    instanceSymbol.type.setAssociatedContainerType(moduleContainerTypeSymbol);
+                }
+            }
+        };
+
+        PullSymbolBinder.prototype.bindImportDeclaration = function (importDeclaration) {
+            var declFlags = importDeclaration.flags;
+            var declKind = importDeclaration.kind;
+            var importDeclAST = this.semanticInfoChain.getASTForDecl(importDeclaration);
+
+            var isExported = false;
+            var importSymbol = null;
+            var declName = importDeclaration.name;
+            var parentHadSymbol = false;
+            var parent = this.getParent(importDeclaration);
+
+            importSymbol = this.getExistingSymbol(importDeclaration, 164 /* SomeContainer */, parent);
+
+            if (importSymbol) {
+                parentHadSymbol = true;
+            }
+
+            if (importSymbol) {
+                this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(importDeclAST, importDeclaration.getDisplayName(), importSymbol.getDeclarations()[0].ast());
+                importSymbol = null;
+            }
+
+            if (!importSymbol) {
+                importSymbol = new TypeScript.PullTypeAliasSymbol(declName);
+
+                if (!parent) {
+                    this.semanticInfoChain.cacheGlobalSymbol(importSymbol, 164 /* SomeContainer */);
+                }
+            }
+
+            importSymbol.addDeclaration(importDeclaration);
+            importDeclaration.setSymbol(importSymbol);
+
+            this.semanticInfoChain.setSymbolForAST(importDeclAST, importSymbol);
+
+            if (parent && !parentHadSymbol) {
+                if (declFlags & 1 /* Exported */) {
+                    parent.addEnclosedMemberContainer(importSymbol);
+                } else {
+                    parent.addEnclosedNonMemberContainer(importSymbol);
+                }
+            }
+        };
+
+        PullSymbolBinder.prototype.ensurePriorDeclarationsAreBound = function (container, currentDecl) {
+            if (!container) {
+                return;
+            }
+
+            var parentDecls = container.getDeclarations();
+            for (var i = 0; i < parentDecls.length; ++i) {
+                var parentDecl = parentDecls[i];
+                var childDecls = parentDecl.getChildDecls();
+                for (var j = 0; j < childDecls.length; ++j) {
+                    var childDecl = childDecls[j];
+                    if (childDecl === currentDecl) {
+                        return;
+                    }
+
+                    if (childDecl.name === currentDecl.name) {
+                        childDecl.ensureSymbolIsBound();
+                    }
+                }
+            }
+        };
+
+        PullSymbolBinder.prototype.bindClassDeclarationToPullSymbol = function (classDecl) {
+            var className = classDecl.name;
+            var classSymbol = null;
+
+            var constructorSymbol = null;
+            var constructorTypeSymbol = null;
+
+            var classAST = this.semanticInfoChain.getASTForDecl(classDecl);
+
+            var parent = this.getParent(classDecl);
+
+            this.ensurePriorDeclarationsAreBound(parent, classDecl);
+
+            var parentDecl = classDecl.getParentDecl();
+            var isExported = classDecl.flags & 1 /* Exported */;
+            var isGeneric = false;
+
+            classSymbol = this.getExistingSymbol(classDecl, 58728795 /* SomeType */, parent);
+
+            if (classSymbol && classSymbol.kind === 16 /* Interface */) {
+                this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(classAST.identifier, classDecl.getDisplayName(), classSymbol.getDeclarations()[0].ast());
+                classSymbol = null;
+            }
+
+            classSymbol = new TypeScript.PullTypeSymbol(className, 8 /* Class */);
+
+            if (!parent) {
+                this.semanticInfoChain.cacheGlobalSymbol(classSymbol, 8 /* Class */);
+            }
+
+            classSymbol.addDeclaration(classDecl);
+
+            classDecl.setSymbol(classSymbol);
+
+            this.semanticInfoChain.setSymbolForAST(classAST.identifier, classSymbol);
+            this.semanticInfoChain.setSymbolForAST(classAST, classSymbol);
+
+            if (parent) {
+                if (classDecl.flags & 1 /* Exported */) {
+                    parent.addEnclosedMemberType(classSymbol);
+                } else {
+                    parent.addEnclosedNonMemberType(classSymbol);
+                }
+            }
+
+            var typeParameterDecls = classDecl.getTypeParameters();
+
+            for (var i = 0; i < typeParameterDecls.length; i++) {
+                var typeParameterSymbol = classSymbol.findTypeParameter(typeParameterDecls[i].name);
+
+                if (typeParameterSymbol) {
+                    var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameterSymbol.getDeclarations()[0]);
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameterSymbol.getName()]);
+                }
+
+                typeParameterSymbol = new TypeScript.PullTypeParameterSymbol(typeParameterDecls[i].name);
+
+                classSymbol.addTypeParameter(typeParameterSymbol);
+                typeParameterSymbol.addDeclaration(typeParameterDecls[i]);
+                typeParameterDecls[i].setSymbol(typeParameterSymbol);
+            }
+
+            constructorSymbol = classSymbol.getConstructorMethod();
+            constructorTypeSymbol = constructorSymbol ? constructorSymbol.type : null;
+
+            if (!constructorSymbol) {
+                var siblingValueDecls = null;
+                if (parentDecl) {
+                    siblingValueDecls = parentDecl.searchChildDecls(className, 68147712 /* SomeValue */);
+
+                    if (siblingValueDecls && siblingValueDecls[0] && siblingValueDecls[0].hasSymbol()) {
+                        constructorSymbol = siblingValueDecls[0].getSymbol();
+                    }
+                }
+
+                if (constructorSymbol) {
+                    constructorTypeSymbol = constructorSymbol.type;
+                } else {
+                    constructorSymbol = new TypeScript.PullSymbol(className, 32768 /* ConstructorMethod */);
+                    constructorTypeSymbol = new TypeScript.PullTypeSymbol("", 33554432 /* ConstructorType */);
+                    constructorSymbol.setIsSynthesized();
+                    constructorSymbol.type = constructorTypeSymbol;
+                }
+
+                classSymbol.setConstructorMethod(constructorSymbol);
+                classSymbol.setHasDefaultConstructor();
+            }
+
+            if (constructorSymbol.getIsSynthesized()) {
+                constructorSymbol.addDeclaration(classDecl.getValueDecl());
+                constructorTypeSymbol.addDeclaration(classDecl);
+            } else {
+                classSymbol.setHasDefaultConstructor(false);
+            }
+
+            constructorTypeSymbol.setAssociatedContainerType(classSymbol);
+
+            var valueDecl = classDecl.getValueDecl();
+
+            if (valueDecl) {
+                valueDecl.ensureSymbolIsBound();
+            }
+
+            this.bindStaticPrototypePropertyOfClass(classAST, classSymbol, constructorTypeSymbol);
+        };
+
+        PullSymbolBinder.prototype.bindInterfaceDeclarationToPullSymbol = function (interfaceDecl) {
+            var interfaceName = interfaceDecl.name;
+            var interfaceSymbol = null;
+
+            var interfaceAST = this.semanticInfoChain.getASTForDecl(interfaceDecl);
+            var createdNewSymbol = false;
+            var parent = this.getParent(interfaceDecl);
+
+            var acceptableSharedKind = 16 /* Interface */;
+
+            interfaceSymbol = this.getExistingSymbol(interfaceDecl, 58728795 /* SomeType */, parent);
+
+            if (interfaceSymbol) {
+                if (!(interfaceSymbol.kind & acceptableSharedKind)) {
+                    this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(interfaceAST.identifier, interfaceDecl.getDisplayName(), interfaceSymbol.getDeclarations()[0].ast());
+                    interfaceSymbol = null;
+                } else if (!this.checkThatExportsMatch(interfaceDecl, interfaceSymbol)) {
+                    interfaceSymbol = null;
+                }
+            }
+
+            if (!interfaceSymbol) {
+                interfaceSymbol = new TypeScript.PullTypeSymbol(interfaceName, 16 /* Interface */);
+                createdNewSymbol = true;
+
+                if (!parent) {
+                    this.semanticInfoChain.cacheGlobalSymbol(interfaceSymbol, acceptableSharedKind);
+                }
+            }
+
+            interfaceSymbol.addDeclaration(interfaceDecl);
+            interfaceDecl.setSymbol(interfaceSymbol);
+
+            if (createdNewSymbol) {
+                if (parent) {
+                    if (interfaceDecl.flags & 1 /* Exported */) {
+                        parent.addEnclosedMemberType(interfaceSymbol);
+                    } else {
+                        parent.addEnclosedNonMemberType(interfaceSymbol);
+                    }
+                }
+            }
+
+            var typeParameters = interfaceDecl.getTypeParameters();
+            var typeParameter;
+            var typeParameterDecls = null;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameter = interfaceSymbol.findTypeParameter(typeParameters[i].name);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name);
+
+                    interfaceSymbol.addTypeParameter(typeParameter);
+                } else {
+                    typeParameterDecls = typeParameter.getDeclarations();
+
+                    for (var j = 0; j < typeParameterDecls.length; j++) {
+                        var typeParameterDeclParent = typeParameterDecls[j].getParentDecl();
+
+                        if (typeParameterDeclParent && typeParameterDeclParent === interfaceDecl) {
+                            var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameterDecls[0]);
+                            this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]);
+
+                            break;
+                        }
+                    }
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+        };
+
+        PullSymbolBinder.prototype.bindObjectTypeDeclarationToPullSymbol = function (objectDecl) {
+            var objectSymbolAST = this.semanticInfoChain.getASTForDecl(objectDecl);
+
+            var objectSymbol = new TypeScript.PullTypeSymbol("", 8388608 /* ObjectType */);
+
+            objectSymbol.addDeclaration(objectDecl);
+            objectDecl.setSymbol(objectSymbol);
+
+            this.semanticInfoChain.setSymbolForAST(objectSymbolAST, objectSymbol);
+
+            var childDecls = objectDecl.getChildDecls();
+
+            for (var i = 0; i < childDecls.length; i++) {
+                this.bindDeclToPullSymbol(childDecls[i]);
+            }
+        };
+
+        PullSymbolBinder.prototype.bindConstructorTypeDeclarationToPullSymbol = function (constructorTypeDeclaration) {
+            var declKind = constructorTypeDeclaration.kind;
+            var declFlags = constructorTypeDeclaration.flags;
+            var constructorTypeAST = this.semanticInfoChain.getASTForDecl(constructorTypeDeclaration);
+
+            var constructorTypeSymbol = new TypeScript.PullTypeSymbol("", 33554432 /* ConstructorType */);
+
+            constructorTypeDeclaration.setSymbol(constructorTypeSymbol);
+            constructorTypeSymbol.addDeclaration(constructorTypeDeclaration);
+            this.semanticInfoChain.setSymbolForAST(constructorTypeAST, constructorTypeSymbol);
+
+            var signature = new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */);
+
+            var funcDecl = this.semanticInfoChain.getASTForDecl(constructorTypeDeclaration);
+            if (TypeScript.lastParameterIsRest(funcDecl.parameterList)) {
+                signature.hasVarArgs = true;
+            }
+
+            signature.addDeclaration(constructorTypeDeclaration);
+            constructorTypeDeclaration.setSignatureSymbol(signature);
+
+            this.bindParameterSymbols(funcDecl, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.parameterList), constructorTypeSymbol, signature);
+
+            var typeParameters = constructorTypeDeclaration.getTypeParameters();
+            var typeParameter;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameter = constructorTypeSymbol.findTypeParameter(typeParameters[i].name);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name);
+
+                    signature.addTypeParameter(typeParameter);
+                } else {
+                    var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]);
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.name]);
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+
+            constructorTypeSymbol.appendConstructSignature(signature);
+        };
+
+        PullSymbolBinder.prototype.bindVariableDeclarationToPullSymbol = function (variableDeclaration) {
+            var declFlags = variableDeclaration.flags;
+            var declKind = variableDeclaration.kind;
+            var varDeclAST = this.semanticInfoChain.getASTForDecl(variableDeclaration);
+            var nameAST = varDeclAST.kind() === 131 /* ClassDeclaration */ ? varDeclAST.identifier : varDeclAST.kind() === 225 /* VariableDeclarator */ ? varDeclAST.propertyName : varDeclAST.kind() === 132 /* EnumDeclaration */ ? varDeclAST.identifier : varDeclAST;
+
+            var isExported = (declFlags & 1 /* Exported */) !== 0;
+
+            var variableSymbol = null;
+
+            var declName = variableDeclaration.name;
+
+            var parentHadSymbol = false;
+
+            var parent = this.getParent(variableDeclaration, true);
+
+            var parentDecl = variableDeclaration.getParentDecl();
+
+            var isImplicit = (declFlags & 118784 /* ImplicitVariable */) !== 0;
+            var isModuleValue = (declFlags & (32768 /* InitializedModule */)) !== 0;
+            var isEnumValue = (declFlags & 4096 /* Enum */) !== 0;
+            var isClassConstructorVariable = (declFlags & 16384 /* ClassConstructorVariable */) !== 0;
+            variableSymbol = this.getExistingSymbol(variableDeclaration, 68147712 /* SomeValue */, parent);
+
+            if (!variableSymbol && isModuleValue) {
+                variableSymbol = this.findExistingVariableSymbolForModuleValueDecl(variableDeclaration.getContainerDecl());
+            }
+
+            if (variableSymbol && !variableSymbol.isType()) {
+                parentHadSymbol = true;
+            }
+
+            var decl;
+            var decls;
+            var ast;
+            var members;
+
+            if (variableSymbol) {
+                var prevKind = variableSymbol.kind;
+                var prevIsEnum = variableSymbol.anyDeclHasFlag(4096 /* Enum */);
+                var prevIsClassConstructorVariable = variableSymbol.anyDeclHasFlag(16384 /* ClassConstructorVariable */);
+                var prevIsModuleValue = variableSymbol.allDeclsHaveFlag(32768 /* InitializedModule */);
+                var prevIsImplicit = variableSymbol.anyDeclHasFlag(118784 /* ImplicitVariable */);
+                var prevIsFunction = TypeScript.ArrayUtilities.any(variableSymbol.getDeclarations(), function (decl) {
+                    return decl.kind === 16384 /* Function */;
+                });
+                var prevIsAmbient = variableSymbol.allDeclsHaveFlag(8 /* Ambient */);
+                var isAmbientOrPrevIsAmbient = prevIsAmbient || (variableDeclaration.flags & 8 /* Ambient */) !== 0;
+                var prevDecl = variableSymbol.getDeclarations()[0];
+                var prevParentDecl = prevDecl.getParentDecl();
+                var bothAreGlobal = parentDecl && (parentDecl.kind === 1 /* Script */) && (prevParentDecl.kind === 1 /* Script */);
+                var shareParent = bothAreGlobal || prevDecl.getParentDecl() === variableDeclaration.getParentDecl();
+                var prevIsParam = shareParent && prevKind === 2048 /* Parameter */ && declKind == 512 /* Variable */;
+
+                var acceptableRedeclaration = prevIsParam || (isImplicit && ((!isEnumValue && !isClassConstructorVariable && prevIsFunction) || ((isModuleValue || isEnumValue) && (prevIsModuleValue || prevIsEnum)) || (isClassConstructorVariable && prevIsModuleValue && isAmbientOrPrevIsAmbient) || (isModuleValue && prevIsClassConstructorVariable)));
+
+                if (acceptableRedeclaration && (prevIsClassConstructorVariable || prevIsFunction) && !isAmbientOrPrevIsAmbient) {
+                    if (prevDecl.fileName() !== variableDeclaration.fileName()) {
+                        this.semanticInfoChain.addDiagnostic(TypeScript.PullHelpers.diagnosticFromDecl(variableDeclaration, TypeScript.DiagnosticCode.Module_0_cannot_merge_with_previous_declaration_of_1_in_a_different_file_2, [declName, declName, prevDecl.fileName()]));
+                        variableSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(declName);
+                    }
+                }
+
+                if (!acceptableRedeclaration || prevIsParam) {
+                    if (!prevIsParam && (isImplicit || prevIsImplicit || TypeScript.hasFlag(prevKind, 1032192 /* SomeFunction */)) || !shareParent) {
+                        this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(nameAST, variableDeclaration.getDisplayName(), variableSymbol.getDeclarations()[0].ast());
+                        variableSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(declName);
+                    } else {
+                        this.checkThatExportsMatch(variableDeclaration, variableSymbol);
+                        variableSymbol = null;
+                        parentHadSymbol = false;
+                    }
+                }
+
+                if (variableSymbol && !(variableSymbol.type && variableSymbol.type.isError()) && !this.checkThatExportsMatch(variableDeclaration, variableSymbol, !(isModuleValue && prevIsModuleValue))) {
+                    variableSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(declName);
+                }
+            }
+
+            if ((declFlags & 118784 /* ImplicitVariable */) === 0) {
+                if (!variableSymbol) {
+                    variableSymbol = new TypeScript.PullSymbol(declName, declKind);
+                    if (!parent && parentDecl.kind === 1 /* Script */) {
+                        this.semanticInfoChain.cacheGlobalSymbol(variableSymbol, declKind);
+                    }
+                }
+
+                variableSymbol.addDeclaration(variableDeclaration);
+                variableDeclaration.setSymbol(variableSymbol);
+
+                this.semanticInfoChain.setSymbolForAST(nameAST, variableSymbol);
+                this.semanticInfoChain.setSymbolForAST(varDeclAST, variableSymbol);
+            } else if (!parentHadSymbol) {
+                if (isClassConstructorVariable) {
+                    var classTypeSymbol = variableSymbol;
+
+                    if (parent) {
+                        members = parent.getMembers();
+
+                        for (var i = 0; i < members.length; i++) {
+                            if ((members[i].name === declName) && (members[i].kind === 8 /* Class */)) {
+                                classTypeSymbol = members[i];
+                                break;
+                            }
+                        }
+                    }
+
+                    if (!classTypeSymbol) {
+                        var containerDecl = variableDeclaration.getContainerDecl();
+                        classTypeSymbol = containerDecl.getSymbol();
+                        if (!classTypeSymbol) {
+                            classTypeSymbol = this.semanticInfoChain.findTopLevelSymbol(declName, 58728795 /* SomeType */, variableDeclaration);
+                        }
+                    }
+
+                    if (classTypeSymbol && (classTypeSymbol.kind !== 8 /* Class */)) {
+                        classTypeSymbol = null;
+                    }
+
+                    if (classTypeSymbol && classTypeSymbol.isClass()) {
+                        variableSymbol = classTypeSymbol.getConstructorMethod();
+                        variableDeclaration.setSymbol(variableSymbol);
+
+                        decls = classTypeSymbol.getDeclarations();
+
+                        if (decls.length) {
+                            decl = decls[decls.length - 1];
+                            ast = this.semanticInfoChain.getASTForDecl(decl);
+                        }
+                    } else {
+                        if (!variableSymbol) {
+                            variableSymbol = new TypeScript.PullSymbol(declName, declKind);
+                        }
+
+                        variableSymbol.addDeclaration(variableDeclaration);
+                        variableDeclaration.setSymbol(variableSymbol);
+
+                        variableSymbol.type = this.semanticInfoChain.anyTypeSymbol;
+                    }
+                } else if (declFlags & 102400 /* SomeInitializedModule */) {
+                    var moduleContainerTypeSymbol = null;
+                    var moduleParent = this.getParent(variableDeclaration);
+
+                    if (moduleParent) {
+                        members = moduleParent.getMembers();
+
+                        for (var i = 0; i < members.length; i++) {
+                            if ((members[i].name === declName) && (members[i].isContainer())) {
+                                moduleContainerTypeSymbol = members[i];
+                                break;
+                            }
+                        }
+                    }
+
+                    if (!moduleContainerTypeSymbol) {
+                        var containerDecl = variableDeclaration.getContainerDecl();
+                        moduleContainerTypeSymbol = containerDecl.getSymbol();
+                        if (!moduleContainerTypeSymbol) {
+                            moduleContainerTypeSymbol = this.semanticInfoChain.findTopLevelSymbol(declName, 164 /* SomeContainer */, variableDeclaration);
+
+                            if (!moduleContainerTypeSymbol) {
+                                moduleContainerTypeSymbol = this.semanticInfoChain.findTopLevelSymbol(declName, 64 /* Enum */, variableDeclaration);
+                            }
+                        }
+                    }
+
+                    if (moduleContainerTypeSymbol && (!moduleContainerTypeSymbol.isContainer())) {
+                        moduleContainerTypeSymbol = null;
+                    }
+
+                    if (moduleContainerTypeSymbol) {
+                        variableSymbol = moduleContainerTypeSymbol.getInstanceSymbol();
+                        if (!variableSymbol) {
+                            variableSymbol = new TypeScript.PullSymbol(declName, declKind);
+                            variableSymbol.type = new TypeScript.PullTypeSymbol("", 8388608 /* ObjectType */);
+                        }
+
+                        if (!variableSymbol.hasDeclaration(variableDeclaration)) {
+                            variableSymbol.addDeclaration(variableDeclaration);
+                        }
+                        variableDeclaration.setSymbol(variableSymbol);
+                    } else {
+                        TypeScript.Debug.assert(false, "Attempted to bind invalid implicit variable symbol");
+                    }
+                }
+            } else {
+                if (!variableSymbol.hasDeclaration(variableDeclaration)) {
+                    variableSymbol.addDeclaration(variableDeclaration);
+                }
+                variableDeclaration.setSymbol(variableSymbol);
+            }
+
+            var containerDecl = variableDeclaration.getContainerDecl();
+            if (variableSymbol && variableSymbol.type && containerDecl && !variableSymbol.type.hasDeclaration(containerDecl)) {
+                variableSymbol.type.addDeclaration(containerDecl);
+            }
+
+            if (parent && !parentHadSymbol) {
+                if (declFlags & 1 /* Exported */) {
+                    parent.addMember(variableSymbol);
+                } else {
+                    parent.addEnclosedNonMember(variableSymbol);
+                }
+            }
+        };
+
+        PullSymbolBinder.prototype.bindCatchVariableToPullSymbol = function (variableDeclaration) {
+            var declFlags = variableDeclaration.flags;
+            var declKind = variableDeclaration.kind;
+            var identifier = this.semanticInfoChain.getASTForDecl(variableDeclaration);
+
+            var declName = variableDeclaration.name;
+
+            var variableSymbol = new TypeScript.PullSymbol(declName, declKind);
+
+            variableSymbol.addDeclaration(variableDeclaration);
+            variableDeclaration.setSymbol(variableSymbol);
+
+            variableSymbol.type = this.semanticInfoChain.anyTypeSymbol;
+
+            this.semanticInfoChain.setSymbolForAST(identifier, variableSymbol);
+        };
+
+        PullSymbolBinder.prototype.bindEnumMemberDeclarationToPullSymbol = function (propertyDeclaration) {
+            var declFlags = propertyDeclaration.flags;
+            var declKind = propertyDeclaration.kind;
+            var propDeclAST = this.semanticInfoChain.getASTForDecl(propertyDeclaration);
+
+            var declName = propertyDeclaration.name;
+
+            var parentHadSymbol = false;
+
+            var parent = this.getParent(propertyDeclaration, true);
+
+            var propertySymbol = parent.findMember(declName, false);
+
+            if (propertySymbol) {
+                this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(propDeclAST.propertyName, propertyDeclaration.getDisplayName(), propertySymbol.getDeclarations()[0].ast());
+            }
+
+            if (propertySymbol) {
+                parentHadSymbol = true;
+            }
+
+            if (!parentHadSymbol) {
+                propertySymbol = new TypeScript.PullSymbol(declName, declKind);
+            }
+
+            propertySymbol.addDeclaration(propertyDeclaration);
+            propertyDeclaration.setSymbol(propertySymbol);
+
+            this.semanticInfoChain.setSymbolForAST(propDeclAST.propertyName, propertySymbol);
+            this.semanticInfoChain.setSymbolForAST(propDeclAST, propertySymbol);
+
+            if (parent && !parentHadSymbol) {
+                parent.addMember(propertySymbol);
+            }
+        };
+
+        PullSymbolBinder.prototype.bindPropertyDeclarationToPullSymbol = function (propertyDeclaration) {
+            var declFlags = propertyDeclaration.flags;
+            var declKind = propertyDeclaration.kind;
+
+            var ast = this.semanticInfoChain.getASTForDecl(propertyDeclaration);
+            var astName = ast.kind() === 136 /* MemberVariableDeclaration */ ? ast.variableDeclarator.propertyName : ast.kind() === 141 /* PropertySignature */ ? ast.propertyName : ast.kind() === 242 /* Parameter */ ? ast.identifier : ast.propertyName;
+
+            var isStatic = false;
+            var isOptional = false;
+
+            var propertySymbol = null;
+
+            if (TypeScript.hasFlag(declFlags, 16 /* Static */)) {
+                isStatic = true;
+            }
+
+            if (TypeScript.hasFlag(declFlags, 128 /* Optional */)) {
+                isOptional = true;
+            }
+
+            var declName = propertyDeclaration.name;
+
+            var parentHadSymbol = false;
+
+            var parent = this.getParent(propertyDeclaration, true);
+
+            if (parent.isClass() && isStatic) {
+                parent = parent.getConstructorMethod().type;
+            }
+
+            propertySymbol = parent.findMember(declName, false);
+
+            if (propertySymbol) {
+                this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(astName, propertyDeclaration.getDisplayName(), propertySymbol.getDeclarations()[0].ast());
+            }
+
+            if (propertySymbol) {
+                parentHadSymbol = true;
+            }
+
+            var classTypeSymbol;
+
+            if (!parentHadSymbol) {
+                propertySymbol = new TypeScript.PullSymbol(declName, declKind);
+            }
+
+            propertySymbol.addDeclaration(propertyDeclaration);
+            propertyDeclaration.setSymbol(propertySymbol);
+
+            this.semanticInfoChain.setSymbolForAST(astName, propertySymbol);
+            this.semanticInfoChain.setSymbolForAST(ast, propertySymbol);
+
+            if (isOptional) {
+                propertySymbol.isOptional = true;
+            }
+
+            if (parent && !parentHadSymbol) {
+                parent.addMember(propertySymbol);
+            }
+        };
+
+        PullSymbolBinder.prototype.bindParameterSymbols = function (functionDeclaration, parameterList, funcType, signatureSymbol) {
+            var parameters = [];
+            var params = TypeScript.createIntrinsicsObject();
+            var funcDecl = this.semanticInfoChain.getDeclForAST(functionDeclaration);
+
+            if (parameterList) {
+                for (var i = 0, n = parameterList.length; i < n; i++) {
+                    var argDecl = parameterList.astAt(i);
+                    var id = parameterList.identifierAt(i);
+                    var decl = this.semanticInfoChain.getDeclForAST(argDecl);
+                    var isProperty = TypeScript.hasFlag(decl.flags, 8388608 /* PropertyParameter */);
+                    var parameterSymbol = new TypeScript.PullSymbol(id.valueText(), 2048 /* Parameter */);
+
+                    if ((i === (n - 1)) && parameterList.lastParameterIsRest()) {
+                        parameterSymbol.isVarArg = true;
+                    }
+
+                    if (params[id.valueText()]) {
+                        this.semanticInfoChain.addDiagnosticFromAST(argDecl, TypeScript.DiagnosticCode.Duplicate_identifier_0, [id.text()]);
+                    } else {
+                        params[id.valueText()] = true;
+                    }
+
+                    if (decl) {
+                        var isParameterOptional = false;
+
+                        if (isProperty) {
+                            decl.ensureSymbolIsBound();
+                            var valDecl = decl.getValueDecl();
+
+                            if (valDecl) {
+                                isParameterOptional = TypeScript.hasFlag(valDecl.flags, 128 /* Optional */);
+
+                                valDecl.setSymbol(parameterSymbol);
+                                parameterSymbol.addDeclaration(valDecl);
+                            }
+                        } else {
+                            isParameterOptional = TypeScript.hasFlag(decl.flags, 128 /* Optional */);
+
+                            parameterSymbol.addDeclaration(decl);
+                            decl.setSymbol(parameterSymbol);
+                        }
+
+                        parameterSymbol.isOptional = isParameterOptional;
+                    }
+
+                    signatureSymbol.addParameter(parameterSymbol, parameterSymbol.isOptional);
+
+                    if (signatureSymbol.isDefinition()) {
+                        funcType.addEnclosedNonMember(parameterSymbol);
+                    }
+                }
+            }
+        };
+
+        PullSymbolBinder.prototype.bindFunctionDeclarationToPullSymbol = function (functionDeclaration) {
+            var declKind = functionDeclaration.kind;
+            var declFlags = functionDeclaration.flags;
+            var funcDeclAST = this.semanticInfoChain.getASTForDecl(functionDeclaration);
+
+            var isExported = (declFlags & 1 /* Exported */) !== 0;
+
+            var funcName = functionDeclaration.name;
+
+            var isSignature = (declFlags & 2048 /* Signature */) !== 0;
+
+            var parent = this.getParent(functionDeclaration, true);
+
+            var parentDecl = functionDeclaration.getParentDecl();
+            var parentHadSymbol = false;
+
+            var functionSymbol = null;
+            var functionTypeSymbol = null;
+
+            functionSymbol = this.getExistingSymbol(functionDeclaration, 68147712 /* SomeValue */, parent);
+
+            if (functionSymbol) {
+                var acceptableRedeclaration;
+
+                if (functionSymbol.kind === 16384 /* Function */) {
+                    acceptableRedeclaration = isSignature || functionSymbol.allDeclsHaveFlag(2048 /* Signature */);
+                } else {
+                    var isCurrentDeclAmbient = TypeScript.hasFlag(functionDeclaration.flags, 8 /* Ambient */);
+                    acceptableRedeclaration = TypeScript.ArrayUtilities.all(functionSymbol.getDeclarations(), function (decl) {
+                        var isInitializedModuleOrAmbientDecl = TypeScript.hasFlag(decl.flags, 32768 /* InitializedModule */) && (isCurrentDeclAmbient || TypeScript.hasFlag(decl.flags, 8 /* Ambient */));
+                        var isSignature = TypeScript.hasFlag(decl.flags, 2048 /* Signature */);
+                        return isInitializedModuleOrAmbientDecl || isSignature;
+                    });
+                }
+
+                if (!acceptableRedeclaration) {
+                    this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(funcDeclAST.identifier, functionDeclaration.getDisplayName(), functionSymbol.getDeclarations()[0].ast());
+                    functionSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(funcName);
+                }
+            }
+
+            if (functionSymbol) {
+                functionTypeSymbol = functionSymbol.type;
+                parentHadSymbol = true;
+            }
+
+            if (!functionSymbol) {
+                functionSymbol = new TypeScript.PullSymbol(funcName, 16384 /* Function */);
+            }
+
+            if (!functionTypeSymbol) {
+                functionTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */);
+                functionSymbol.type = functionTypeSymbol;
+                functionTypeSymbol.setFunctionSymbol(functionSymbol);
+            }
+
+            functionDeclaration.setSymbol(functionSymbol);
+            functionSymbol.addDeclaration(functionDeclaration);
+            functionTypeSymbol.addDeclaration(functionDeclaration);
+
+            this.semanticInfoChain.setSymbolForAST(funcDeclAST.identifier, functionSymbol);
+            this.semanticInfoChain.setSymbolForAST(funcDeclAST, functionSymbol);
+
+            if (parent && !parentHadSymbol) {
+                if (isExported) {
+                    parent.addMember(functionSymbol);
+                } else {
+                    parent.addEnclosedNonMember(functionSymbol);
+                }
+            }
+
+            var signature = new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */, !isSignature);
+
+            signature.addDeclaration(functionDeclaration);
+            functionDeclaration.setSignatureSymbol(signature);
+
+            if (TypeScript.lastParameterIsRest(funcDeclAST.callSignature.parameterList)) {
+                signature.hasVarArgs = true;
+            }
+
+            var funcDecl = this.semanticInfoChain.getASTForDecl(functionDeclaration);
+            this.bindParameterSymbols(funcDecl, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.callSignature.parameterList), functionTypeSymbol, signature);
+
+            var typeParameters = functionDeclaration.getTypeParameters();
+            var typeParameter;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameter = signature.findTypeParameter(typeParameters[i].name);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name);
+
+                    signature.addTypeParameter(typeParameter);
+                } else {
+                    var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]);
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.name]);
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+
+            functionTypeSymbol.appendCallSignature(signature);
+        };
+
+        PullSymbolBinder.prototype.bindFunctionExpressionToPullSymbol = function (functionExpressionDeclaration) {
+            var declKind = functionExpressionDeclaration.kind;
+            var declFlags = functionExpressionDeclaration.flags;
+            var ast = this.semanticInfoChain.getASTForDecl(functionExpressionDeclaration);
+
+            var parameters = ast.kind() === 219 /* SimpleArrowFunctionExpression */ ? TypeScript.ASTHelpers.parametersFromIdentifier(ast.identifier) : TypeScript.ASTHelpers.parametersFromParameterList(TypeScript.ASTHelpers.getParameterList(ast));
+            var funcExpAST = ast;
+
+            var functionName = declKind === 131072 /* FunctionExpression */ ? functionExpressionDeclaration.getFunctionExpressionName() : functionExpressionDeclaration.name;
+            var functionSymbol = new TypeScript.PullSymbol(functionName, declKind);
+            var functionTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */);
+            functionTypeSymbol.setFunctionSymbol(functionSymbol);
+
+            functionSymbol.type = functionTypeSymbol;
+
+            functionExpressionDeclaration.setSymbol(functionSymbol);
+            functionSymbol.addDeclaration(functionExpressionDeclaration);
+            functionTypeSymbol.addDeclaration(functionExpressionDeclaration);
+
+            var name = funcExpAST.kind() === 222 /* FunctionExpression */ ? funcExpAST.identifier : funcExpAST.kind() === 241 /* FunctionPropertyAssignment */ ? funcExpAST.propertyName : null;
+            if (name) {
+                this.semanticInfoChain.setSymbolForAST(name, functionSymbol);
+            }
+
+            this.semanticInfoChain.setSymbolForAST(funcExpAST, functionSymbol);
+
+            var signature = new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */, true);
+
+            if (parameters.lastParameterIsRest()) {
+                signature.hasVarArgs = true;
+            }
+
+            var typeParameters = functionExpressionDeclaration.getTypeParameters();
+            var typeParameter;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameter = signature.findTypeParameter(typeParameters[i].name);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name);
+
+                    signature.addTypeParameter(typeParameter);
+                } else {
+                    var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]);
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]);
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+
+            signature.addDeclaration(functionExpressionDeclaration);
+            functionExpressionDeclaration.setSignatureSymbol(signature);
+
+            this.bindParameterSymbols(funcExpAST, parameters, functionTypeSymbol, signature);
+
+            functionTypeSymbol.appendCallSignature(signature);
+        };
+
+        PullSymbolBinder.prototype.bindFunctionTypeDeclarationToPullSymbol = function (functionTypeDeclaration) {
+            var declKind = functionTypeDeclaration.kind;
+            var declFlags = functionTypeDeclaration.flags;
+            var funcTypeAST = this.semanticInfoChain.getASTForDecl(functionTypeDeclaration);
+
+            var functionTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */);
+
+            functionTypeDeclaration.setSymbol(functionTypeSymbol);
+            functionTypeSymbol.addDeclaration(functionTypeDeclaration);
+            this.semanticInfoChain.setSymbolForAST(funcTypeAST, functionTypeSymbol);
+
+            var isSignature = (declFlags & 2048 /* Signature */) !== 0;
+            var signature = new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */, !isSignature);
+
+            if (TypeScript.lastParameterIsRest(funcTypeAST.parameterList)) {
+                signature.hasVarArgs = true;
+            }
+
+            var typeParameters = functionTypeDeclaration.getTypeParameters();
+            var typeParameter;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameter = signature.findTypeParameter(typeParameters[i].name);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name);
+
+                    signature.addTypeParameter(typeParameter);
+                } else {
+                    var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]);
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.name]);
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+
+            signature.addDeclaration(functionTypeDeclaration);
+            functionTypeDeclaration.setSignatureSymbol(signature);
+
+            this.bindParameterSymbols(funcTypeAST, TypeScript.ASTHelpers.parametersFromParameterList(funcTypeAST.parameterList), functionTypeSymbol, signature);
+
+            functionTypeSymbol.appendCallSignature(signature);
+        };
+
+        PullSymbolBinder.prototype.bindMethodDeclarationToPullSymbol = function (methodDeclaration) {
+            var declKind = methodDeclaration.kind;
+            var declFlags = methodDeclaration.flags;
+            var methodAST = this.semanticInfoChain.getASTForDecl(methodDeclaration);
+
+            var isPrivate = (declFlags & 2 /* Private */) !== 0;
+            var isStatic = (declFlags & 16 /* Static */) !== 0;
+            var isOptional = (declFlags & 128 /* Optional */) !== 0;
+
+            var methodName = methodDeclaration.name;
+
+            var isSignature = (declFlags & 2048 /* Signature */) !== 0;
+
+            var parent = this.getParent(methodDeclaration, true);
+            var parentHadSymbol = false;
+
+            var methodSymbol = null;
+            var methodTypeSymbol = null;
+
+            if (parent.isClass() && isStatic) {
+                parent = parent.getConstructorMethod().type;
+            }
+
+            methodSymbol = parent.findMember(methodName, false);
+
+            if (methodSymbol && (methodSymbol.kind !== 65536 /* Method */ || (!isSignature && !methodSymbol.allDeclsHaveFlag(2048 /* Signature */)))) {
+                this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(methodAST, methodDeclaration.getDisplayName(), methodSymbol.getDeclarations()[0].ast());
+                methodSymbol = null;
+            }
+
+            if (methodSymbol) {
+                methodTypeSymbol = methodSymbol.type;
+                parentHadSymbol = true;
+            }
+
+            if (!methodSymbol) {
+                methodSymbol = new TypeScript.PullSymbol(methodName, 65536 /* Method */);
+            }
+
+            if (!methodTypeSymbol) {
+                methodTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */);
+                methodSymbol.type = methodTypeSymbol;
+                methodTypeSymbol.setFunctionSymbol(methodSymbol);
+            }
+
+            methodDeclaration.setSymbol(methodSymbol);
+            methodSymbol.addDeclaration(methodDeclaration);
+            methodTypeSymbol.addDeclaration(methodDeclaration);
+
+            var nameAST = methodAST.kind() === 135 /* MemberFunctionDeclaration */ ? methodAST.propertyName : methodAST.propertyName;
+
+            TypeScript.Debug.assert(nameAST);
+
+            this.semanticInfoChain.setSymbolForAST(nameAST, methodSymbol);
+            this.semanticInfoChain.setSymbolForAST(methodAST, methodSymbol);
+
+            if (isOptional) {
+                methodSymbol.isOptional = true;
+            }
+
+            if (!parentHadSymbol) {
+                parent.addMember(methodSymbol);
+            }
+
+            var sigKind = 1048576 /* CallSignature */;
+
+            var signature = new TypeScript.PullSignatureSymbol(sigKind, !isSignature);
+
+            var parameterList = TypeScript.ASTHelpers.getParameterList(methodAST);
+            if (TypeScript.lastParameterIsRest(parameterList)) {
+                signature.hasVarArgs = true;
+            }
+
+            var typeParameters = methodDeclaration.getTypeParameters();
+            var typeParameter;
+            var typeParameterName;
+            var typeParameterAST;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameterName = typeParameters[i].name;
+                typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameters[i]);
+
+                typeParameter = signature.findTypeParameter(typeParameterName);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameterName);
+                    signature.addTypeParameter(typeParameter);
+                } else {
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]);
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+
+            signature.addDeclaration(methodDeclaration);
+            methodDeclaration.setSignatureSymbol(signature);
+
+            var funcDecl = this.semanticInfoChain.getASTForDecl(methodDeclaration);
+            this.bindParameterSymbols(funcDecl, TypeScript.ASTHelpers.parametersFromParameterList(TypeScript.ASTHelpers.getParameterList(funcDecl)), methodTypeSymbol, signature);
+
+            var signatureIndex = this.getIndexForInsertingSignatureAtEndOfEnclosingDeclInSignatureList(signature, methodTypeSymbol.getOwnCallSignatures());
+            methodTypeSymbol.insertCallSignatureAtIndex(signature, signatureIndex);
+        };
+
+        PullSymbolBinder.prototype.bindStaticPrototypePropertyOfClass = function (classAST, classTypeSymbol, constructorTypeSymbol) {
+            var prototypeStr = "prototype";
+
+            var prototypeSymbol = constructorTypeSymbol.findMember(prototypeStr, false);
+            if (prototypeSymbol && !prototypeSymbol.getIsSynthesized()) {
+                this.semanticInfoChain.addDiagnostic(TypeScript.PullHelpers.diagnosticFromDecl(prototypeSymbol.getDeclarations()[0], TypeScript.DiagnosticCode.Duplicate_identifier_0, [prototypeSymbol.getDisplayName()]));
+            }
+
+            if (!prototypeSymbol || !prototypeSymbol.getIsSynthesized()) {
+                var prototypeDecl = new TypeScript.PullSynthesizedDecl(prototypeStr, prototypeStr, 4096 /* Property */, 4 /* Public */ | 16 /* Static */, constructorTypeSymbol.getDeclarations()[0], this.semanticInfoChain);
+
+                prototypeSymbol = new TypeScript.PullSymbol(prototypeStr, 4096 /* Property */);
+                prototypeSymbol.setIsSynthesized();
+                prototypeSymbol.addDeclaration(prototypeDecl);
+                prototypeSymbol.type = classTypeSymbol;
+                constructorTypeSymbol.addMember(prototypeSymbol);
+
+                if (prototypeSymbol.type && prototypeSymbol.type.isGeneric()) {
+                    var resolver = this.semanticInfoChain.getResolver();
+                    prototypeSymbol.type = resolver.instantiateTypeToAny(prototypeSymbol.type, new TypeScript.PullTypeResolutionContext(resolver));
+                }
+                prototypeSymbol.setResolved();
+            }
+        };
+
+        PullSymbolBinder.prototype.bindConstructorDeclarationToPullSymbol = function (constructorDeclaration) {
+            var declKind = constructorDeclaration.kind;
+            var declFlags = constructorDeclaration.flags;
+            var constructorAST = this.semanticInfoChain.getASTForDecl(constructorDeclaration);
+
+            var constructorName = constructorDeclaration.name;
+
+            var isSignature = (declFlags & 2048 /* Signature */) !== 0;
+
+            var parent = this.getParent(constructorDeclaration, true);
+
+            var parentHadSymbol = false;
+
+            var constructorSymbol = parent.getConstructorMethod();
+            var constructorTypeSymbol = null;
+
+            if (constructorSymbol && (constructorSymbol.kind !== 32768 /* ConstructorMethod */ || (!isSignature && constructorSymbol.type && constructorSymbol.type.hasOwnConstructSignatures()))) {
+                var hasDefinitionSignature = false;
+                var constructorSigs = constructorSymbol.type.getOwnDeclaredConstructSignatures();
+
+                for (var i = 0; i < constructorSigs.length; i++) {
+                    if (!constructorSigs[i].anyDeclHasFlag(2048 /* Signature */)) {
+                        hasDefinitionSignature = true;
+                        break;
+                    }
+                }
+
+                if (hasDefinitionSignature) {
+                    this.semanticInfoChain.addDiagnosticFromAST(constructorAST, TypeScript.DiagnosticCode.Multiple_constructor_implementations_are_not_allowed);
+
+                    constructorSymbol = null;
+                }
+            }
+
+            if (constructorSymbol) {
+                constructorTypeSymbol = constructorSymbol.type;
+            } else {
+                constructorSymbol = new TypeScript.PullSymbol(constructorName, 32768 /* ConstructorMethod */);
+                constructorTypeSymbol = new TypeScript.PullTypeSymbol("", 33554432 /* ConstructorType */);
+            }
+
+            parent.setConstructorMethod(constructorSymbol);
+            constructorSymbol.type = constructorTypeSymbol;
+
+            constructorDeclaration.setSymbol(constructorSymbol);
+            constructorSymbol.addDeclaration(constructorDeclaration);
+            constructorTypeSymbol.addDeclaration(constructorDeclaration);
+            constructorSymbol.setIsSynthesized(false);
+            this.semanticInfoChain.setSymbolForAST(constructorAST, constructorSymbol);
+
+            var constructSignature = new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */, !isSignature);
+            constructSignature.returnType = parent;
+            constructSignature.addTypeParametersFromReturnType();
+
+            constructSignature.addDeclaration(constructorDeclaration);
+            constructorDeclaration.setSignatureSymbol(constructSignature);
+
+            this.bindParameterSymbols(constructorAST, TypeScript.ASTHelpers.parametersFromParameterList(constructorAST.callSignature.parameterList), constructorTypeSymbol, constructSignature);
+
+            if (TypeScript.lastParameterIsRest(constructorAST.callSignature.parameterList)) {
+                constructSignature.hasVarArgs = true;
+            }
+
+            constructorTypeSymbol.appendConstructSignature(constructSignature);
+        };
+
+        PullSymbolBinder.prototype.bindConstructSignatureDeclarationToPullSymbol = function (constructSignatureDeclaration) {
+            var parent = this.getParent(constructSignatureDeclaration, true);
+            var constructorAST = this.semanticInfoChain.getASTForDecl(constructSignatureDeclaration);
+
+            var constructSignature = new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */);
+
+            if (TypeScript.lastParameterIsRest(constructorAST.callSignature.parameterList)) {
+                constructSignature.hasVarArgs = true;
+            }
+
+            var typeParameters = constructSignatureDeclaration.getTypeParameters();
+            var typeParameter;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameter = constructSignature.findTypeParameter(typeParameters[i].name);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name);
+
+                    constructSignature.addTypeParameter(typeParameter);
+                } else {
+                    var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]);
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]);
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+
+            constructSignature.addDeclaration(constructSignatureDeclaration);
+            constructSignatureDeclaration.setSignatureSymbol(constructSignature);
+
+            var funcDecl = this.semanticInfoChain.getASTForDecl(constructSignatureDeclaration);
+            this.bindParameterSymbols(funcDecl, TypeScript.ASTHelpers.parametersFromParameterList(TypeScript.ASTHelpers.getParameterList(funcDecl)), null, constructSignature);
+
+            this.semanticInfoChain.setSymbolForAST(this.semanticInfoChain.getASTForDecl(constructSignatureDeclaration), constructSignature);
+
+            var signatureIndex = this.getIndexForInsertingSignatureAtEndOfEnclosingDeclInSignatureList(constructSignature, parent.getOwnDeclaredConstructSignatures());
+            parent.insertConstructSignatureAtIndex(constructSignature, signatureIndex);
+        };
+
+        PullSymbolBinder.prototype.bindCallSignatureDeclarationToPullSymbol = function (callSignatureDeclaration) {
+            var parent = this.getParent(callSignatureDeclaration, true);
+            var callSignatureAST = this.semanticInfoChain.getASTForDecl(callSignatureDeclaration);
+
+            var callSignature = new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */);
+
+            if (TypeScript.lastParameterIsRest(callSignatureAST.parameterList)) {
+                callSignature.hasVarArgs = true;
+            }
+
+            var typeParameters = callSignatureDeclaration.getTypeParameters();
+            var typeParameter;
+
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameter = callSignature.findTypeParameter(typeParameters[i].name);
+
+                if (!typeParameter) {
+                    typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name);
+
+                    callSignature.addTypeParameter(typeParameter);
+                } else {
+                    var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]);
+                    this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]);
+                }
+
+                typeParameter.addDeclaration(typeParameters[i]);
+                typeParameters[i].setSymbol(typeParameter);
+            }
+
+            callSignature.addDeclaration(callSignatureDeclaration);
+            callSignatureDeclaration.setSignatureSymbol(callSignature);
+
+            var funcDecl = this.semanticInfoChain.getASTForDecl(callSignatureDeclaration);
+            this.bindParameterSymbols(funcDecl, TypeScript.ASTHelpers.parametersFromParameterList(funcDecl.parameterList), null, callSignature);
+
+            this.semanticInfoChain.setSymbolForAST(this.semanticInfoChain.getASTForDecl(callSignatureDeclaration), callSignature);
+
+            var signatureIndex = this.getIndexForInsertingSignatureAtEndOfEnclosingDeclInSignatureList(callSignature, parent.getOwnCallSignatures());
+            parent.insertCallSignatureAtIndex(callSignature, signatureIndex);
+        };
+
+        PullSymbolBinder.prototype.bindIndexSignatureDeclarationToPullSymbol = function (indexSignatureDeclaration) {
+            var indexSignature = new TypeScript.PullSignatureSymbol(4194304 /* IndexSignature */);
+
+            indexSignature.addDeclaration(indexSignatureDeclaration);
+            indexSignatureDeclaration.setSignatureSymbol(indexSignature);
+
+            var funcDecl = this.semanticInfoChain.getASTForDecl(indexSignatureDeclaration);
+            this.bindParameterSymbols(funcDecl, TypeScript.ASTHelpers.parametersFromParameter(funcDecl.parameter), null, indexSignature);
+
+            this.semanticInfoChain.setSymbolForAST(this.semanticInfoChain.getASTForDecl(indexSignatureDeclaration), indexSignature);
+
+            var parent = this.getParent(indexSignatureDeclaration);
+            parent.addIndexSignature(indexSignature);
+            indexSignature.setContainer(parent);
+        };
+
+        PullSymbolBinder.prototype.bindGetAccessorDeclarationToPullSymbol = function (getAccessorDeclaration) {
+            var declKind = getAccessorDeclaration.kind;
+            var declFlags = getAccessorDeclaration.flags;
+            var funcDeclAST = this.semanticInfoChain.getASTForDecl(getAccessorDeclaration);
+
+            var isExported = (declFlags & 1 /* Exported */) !== 0;
+
+            var funcName = getAccessorDeclaration.name;
+
+            var isSignature = (declFlags & 2048 /* Signature */) !== 0;
+            var isStatic = false;
+
+            if (TypeScript.hasFlag(declFlags, 16 /* Static */)) {
+                isStatic = true;
+            }
+
+            var parent = this.getParent(getAccessorDeclaration, true);
+            var parentHadSymbol = false;
+
+            var accessorSymbol = null;
+            var getterSymbol = null;
+            var getterTypeSymbol = null;
+
+            if (isStatic) {
+                parent = parent.getConstructorMethod().type;
+            }
+
+            accessorSymbol = parent.findMember(funcName, false);
+
+            if (accessorSymbol) {
+                if (!accessorSymbol.isAccessor()) {
+                    this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(funcDeclAST.propertyName, getAccessorDeclaration.getDisplayName(), accessorSymbol.getDeclarations()[0].ast());
+                    accessorSymbol = null;
+                } else {
+                    getterSymbol = accessorSymbol.getGetter();
+
+                    if (getterSymbol) {
+                        this.semanticInfoChain.addDiagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Getter_0_already_declared, [getAccessorDeclaration.getDisplayName()]);
+                        accessorSymbol = null;
+                        getterSymbol = null;
+                    }
+                }
+            }
+
+            if (accessorSymbol) {
+                parentHadSymbol = true;
+            }
+
+            if (accessorSymbol && getterSymbol) {
+                getterTypeSymbol = getterSymbol.type;
+            }
+
+            if (!accessorSymbol) {
+                accessorSymbol = new TypeScript.PullAccessorSymbol(funcName);
+            }
+
+            if (!getterSymbol) {
+                getterSymbol = new TypeScript.PullSymbol(funcName, 16384 /* Function */);
+                getterTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */);
+                getterTypeSymbol.setFunctionSymbol(getterSymbol);
+
+                getterSymbol.type = getterTypeSymbol;
+
+                accessorSymbol.setGetter(getterSymbol);
+            }
+
+            getAccessorDeclaration.setSymbol(accessorSymbol);
+            accessorSymbol.addDeclaration(getAccessorDeclaration);
+            getterSymbol.addDeclaration(getAccessorDeclaration);
+
+            var nameAST = funcDeclAST.propertyName;
+            this.semanticInfoChain.setSymbolForAST(nameAST, accessorSymbol);
+            this.semanticInfoChain.setSymbolForAST(funcDeclAST, getterSymbol);
+
+            if (!parentHadSymbol) {
+                parent.addMember(accessorSymbol);
+            }
+
+            var signature = new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */, !isSignature);
+
+            signature.addDeclaration(getAccessorDeclaration);
+            getAccessorDeclaration.setSignatureSymbol(signature);
+
+            this.bindParameterSymbols(funcDeclAST, TypeScript.ASTHelpers.parametersFromParameterList(funcDeclAST.parameterList), getterTypeSymbol, signature);
+
+            getterTypeSymbol.appendCallSignature(signature);
+        };
+
+        PullSymbolBinder.prototype.bindSetAccessorDeclarationToPullSymbol = function (setAccessorDeclaration) {
+            var declKind = setAccessorDeclaration.kind;
+            var declFlags = setAccessorDeclaration.flags;
+            var funcDeclAST = this.semanticInfoChain.getASTForDecl(setAccessorDeclaration);
+
+            var isExported = (declFlags & 1 /* Exported */) !== 0;
+
+            var funcName = setAccessorDeclaration.name;
+
+            var isSignature = (declFlags & 2048 /* Signature */) !== 0;
+            var isStatic = false;
+
+            if (TypeScript.hasFlag(declFlags, 16 /* Static */)) {
+                isStatic = true;
+            }
+
+            var parent = this.getParent(setAccessorDeclaration, true);
+            var parentHadSymbol = false;
+
+            var accessorSymbol = null;
+            var setterSymbol = null;
+            var setterTypeSymbol = null;
+
+            if (isStatic) {
+                parent = parent.getConstructorMethod().type;
+            }
+
+            accessorSymbol = parent.findMember(funcName, false);
+
+            if (accessorSymbol) {
+                if (!accessorSymbol.isAccessor()) {
+                    this.semanticInfoChain.addDuplicateIdentifierDiagnosticFromAST(funcDeclAST.propertyName, setAccessorDeclaration.getDisplayName(), accessorSymbol.getDeclarations()[0].ast());
+                    accessorSymbol = null;
+                } else {
+                    setterSymbol = accessorSymbol.getSetter();
+
+                    if (setterSymbol) {
+                        this.semanticInfoChain.addDiagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Setter_0_already_declared, [setAccessorDeclaration.getDisplayName()]);
+                        accessorSymbol = null;
+                        setterSymbol = null;
+                    }
+                }
+            }
+
+            if (accessorSymbol) {
+                parentHadSymbol = true;
+
+                if (setterSymbol) {
+                    setterTypeSymbol = setterSymbol.type;
+                }
+            }
+
+            if (!accessorSymbol) {
+                accessorSymbol = new TypeScript.PullAccessorSymbol(funcName);
+            }
+
+            if (!setterSymbol) {
+                setterSymbol = new TypeScript.PullSymbol(funcName, 16384 /* Function */);
+                setterTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */);
+                setterTypeSymbol.setFunctionSymbol(setterSymbol);
+
+                setterSymbol.type = setterTypeSymbol;
+
+                accessorSymbol.setSetter(setterSymbol);
+            }
+
+            setAccessorDeclaration.setSymbol(accessorSymbol);
+            accessorSymbol.addDeclaration(setAccessorDeclaration);
+            setterSymbol.addDeclaration(setAccessorDeclaration);
+
+            var nameAST = funcDeclAST.propertyName;
+            this.semanticInfoChain.setSymbolForAST(nameAST, accessorSymbol);
+            this.semanticInfoChain.setSymbolForAST(funcDeclAST, setterSymbol);
+
+            if (!parentHadSymbol) {
+                parent.addMember(accessorSymbol);
+            }
+
+            var signature = new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */, !isSignature);
+
+            signature.addDeclaration(setAccessorDeclaration);
+            setAccessorDeclaration.setSignatureSymbol(signature);
+
+            this.bindParameterSymbols(funcDeclAST, TypeScript.ASTHelpers.parametersFromParameterList(funcDeclAST.parameterList), setterTypeSymbol, signature);
+
+            setterTypeSymbol.appendCallSignature(signature);
+        };
+
+        PullSymbolBinder.prototype.getDeclsToBind = function (decl) {
+            var decls;
+            switch (decl.kind) {
+                case 64 /* Enum */:
+                case 32 /* DynamicModule */:
+                case 4 /* Container */:
+                case 16 /* Interface */:
+                    decls = this.findDeclsInContext(decl, decl.kind, true);
+                    break;
+
+                case 512 /* Variable */:
+                case 16384 /* Function */:
+                case 65536 /* Method */:
+                case 32768 /* ConstructorMethod */:
+                    decls = this.findDeclsInContext(decl, decl.kind, false);
+                    break;
+
+                default:
+                    decls = [decl];
+            }
+            TypeScript.Debug.assert(decls && decls.length > 0);
+            TypeScript.Debug.assert(TypeScript.ArrayUtilities.contains(decls, decl));
+            return decls;
+        };
+
+        PullSymbolBinder.prototype.shouldBindDeclaration = function (decl) {
+            return !decl.hasBeenBound() && this.declsBeingBound.indexOf(decl.declID) < 0;
+        };
+
+        PullSymbolBinder.prototype.bindDeclToPullSymbol = function (decl) {
+            if (this.shouldBindDeclaration(decl)) {
+                this.bindAllDeclsToPullSymbol(decl);
+            }
+        };
+
+        PullSymbolBinder.prototype.bindAllDeclsToPullSymbol = function (askedDecl) {
+            var allDecls = this.getDeclsToBind(askedDecl);
+            for (var i = 0; i < allDecls.length; i++) {
+                var decl = allDecls[i];
+
+                if (this.shouldBindDeclaration(decl)) {
+                    this.bindSingleDeclToPullSymbol(decl);
+                }
+            }
+        };
+
+        PullSymbolBinder.prototype.bindSingleDeclToPullSymbol = function (decl) {
+            this.declsBeingBound.push(decl.declID);
+
+            switch (decl.kind) {
+                case 1 /* Script */:
+                    var childDecls = decl.getChildDecls();
+                    for (var i = 0; i < childDecls.length; i++) {
+                        this.bindDeclToPullSymbol(childDecls[i]);
+                    }
+                    break;
+
+                case 64 /* Enum */:
+                    this.bindEnumDeclarationToPullSymbol(decl);
+                    break;
+
+                case 32 /* DynamicModule */:
+                case 4 /* Container */:
+                    this.bindModuleDeclarationToPullSymbol(decl);
+                    break;
+
+                case 16 /* Interface */:
+                    this.bindInterfaceDeclarationToPullSymbol(decl);
+                    break;
+
+                case 8 /* Class */:
+                    this.bindClassDeclarationToPullSymbol(decl);
+                    break;
+
+                case 16384 /* Function */:
+                    this.bindFunctionDeclarationToPullSymbol(decl);
+                    break;
+
+                case 512 /* Variable */:
+                    this.bindVariableDeclarationToPullSymbol(decl);
+                    break;
+
+                case 1024 /* CatchVariable */:
+                    this.bindCatchVariableToPullSymbol(decl);
+                    break;
+
+                case 67108864 /* EnumMember */:
+                    this.bindEnumMemberDeclarationToPullSymbol(decl);
+                    break;
+
+                case 4096 /* Property */:
+                    this.bindPropertyDeclarationToPullSymbol(decl);
+                    break;
+
+                case 65536 /* Method */:
+                    this.bindMethodDeclarationToPullSymbol(decl);
+                    break;
+
+                case 32768 /* ConstructorMethod */:
+                    this.bindConstructorDeclarationToPullSymbol(decl);
+                    break;
+
+                case 1048576 /* CallSignature */:
+                    this.bindCallSignatureDeclarationToPullSymbol(decl);
+                    break;
+
+                case 2097152 /* ConstructSignature */:
+                    this.bindConstructSignatureDeclarationToPullSymbol(decl);
+                    break;
+
+                case 4194304 /* IndexSignature */:
+                    this.bindIndexSignatureDeclarationToPullSymbol(decl);
+                    break;
+
+                case 262144 /* GetAccessor */:
+                    this.bindGetAccessorDeclarationToPullSymbol(decl);
+                    break;
+
+                case 524288 /* SetAccessor */:
+                    this.bindSetAccessorDeclarationToPullSymbol(decl);
+                    break;
+
+                case 8388608 /* ObjectType */:
+                    this.bindObjectTypeDeclarationToPullSymbol(decl);
+                    break;
+
+                case 16777216 /* FunctionType */:
+                    this.bindFunctionTypeDeclarationToPullSymbol(decl);
+                    break;
+
+                case 33554432 /* ConstructorType */:
+                    this.bindConstructorTypeDeclarationToPullSymbol(decl);
+                    break;
+
+                case 131072 /* FunctionExpression */:
+                    this.bindFunctionExpressionToPullSymbol(decl);
+                    break;
+
+                case 128 /* TypeAlias */:
+                    this.bindImportDeclaration(decl);
+                    break;
+
+                case 2048 /* Parameter */:
+                case 8192 /* TypeParameter */:
+                    decl.getParentDecl().getSymbol();
+                    break;
+
+                case 268435456 /* CatchBlock */:
+                case 134217728 /* WithBlock */:
+                    break;
+
+                default:
+                    TypeScript.CompilerDiagnostics.assert(false, "Unrecognized type declaration");
+            }
+
+            TypeScript.Debug.assert(TypeScript.ArrayUtilities.last(this.declsBeingBound) === decl.declID);
+            this.declsBeingBound.pop();
+        };
+        return PullSymbolBinder;
+    })();
+    TypeScript.PullSymbolBinder = PullSymbolBinder;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (PullHelpers) {
+        function diagnosticFromDecl(decl, diagnosticKey, _arguments, additionalLocations) {
+            if (typeof _arguments === "undefined") { _arguments = null; }
+            if (typeof additionalLocations === "undefined") { additionalLocations = null; }
+            var ast = decl.ast();
+            return decl.semanticInfoChain.diagnosticFromAST(ast, diagnosticKey, _arguments, additionalLocations);
+        }
+        PullHelpers.diagnosticFromDecl = diagnosticFromDecl;
+
+        function resolveDeclaredSymbolToUseType(symbol) {
+            if (symbol.isSignature()) {
+                if (!symbol.returnType) {
+                    symbol._resolveDeclaredSymbol();
+                }
+            } else if (!symbol.type) {
+                symbol._resolveDeclaredSymbol();
+            }
+        }
+        PullHelpers.resolveDeclaredSymbolToUseType = resolveDeclaredSymbolToUseType;
+
+        function getSignatureForFuncDecl(functionDecl) {
+            var funcDecl = functionDecl.ast();
+            var funcSymbol = functionDecl.getSymbol();
+
+            if (!funcSymbol) {
+                funcSymbol = functionDecl.getSignatureSymbol();
+            }
+
+            var functionSignature = null;
+            var typeSymbolWithAllSignatures = null;
+            if (funcSymbol.isSignature()) {
+                functionSignature = funcSymbol;
+                var parent = functionDecl.getParentDecl();
+                typeSymbolWithAllSignatures = parent.getSymbol().type;
+            } else {
+                functionSignature = functionDecl.getSignatureSymbol();
+                typeSymbolWithAllSignatures = funcSymbol.type;
+            }
+            var signatures;
+
+            if (funcDecl.kind() === 137 /* ConstructorDeclaration */ || functionDecl.kind === 2097152 /* ConstructSignature */) {
+                signatures = typeSymbolWithAllSignatures.getConstructSignatures();
+            } else if (functionDecl.kind === 4194304 /* IndexSignature */) {
+                signatures = typeSymbolWithAllSignatures.getIndexSignatures();
+            } else {
+                signatures = typeSymbolWithAllSignatures.getCallSignatures();
+            }
+
+            return {
+                signature: functionSignature,
+                allSignatures: signatures
+            };
+        }
+        PullHelpers.getSignatureForFuncDecl = getSignatureForFuncDecl;
+
+        function getAccessorSymbol(getterOrSetter, semanticInfoChain) {
+            var functionDecl = semanticInfoChain.getDeclForAST(getterOrSetter);
+            var getterOrSetterSymbol = functionDecl.getSymbol();
+
+            return getterOrSetterSymbol;
+        }
+        PullHelpers.getAccessorSymbol = getAccessorSymbol;
+
+        function getGetterAndSetterFunction(funcDecl, semanticInfoChain) {
+            var accessorSymbol = PullHelpers.getAccessorSymbol(funcDecl, semanticInfoChain);
+            var result = {
+                getter: null,
+                setter: null
+            };
+            var getter = accessorSymbol.getGetter();
+            if (getter) {
+                var getterDecl = getter.getDeclarations()[0];
+                result.getter = semanticInfoChain.getASTForDecl(getterDecl);
+            }
+            var setter = accessorSymbol.getSetter();
+            if (setter) {
+                var setterDecl = setter.getDeclarations()[0];
+                result.setter = semanticInfoChain.getASTForDecl(setterDecl);
+            }
+
+            return result;
+        }
+        PullHelpers.getGetterAndSetterFunction = getGetterAndSetterFunction;
+
+        function symbolIsEnum(source) {
+            return source && (source.kind & (64 /* Enum */ | 67108864 /* EnumMember */)) !== 0;
+        }
+        PullHelpers.symbolIsEnum = symbolIsEnum;
+
+        function symbolIsModule(symbol) {
+            return symbol && (symbol.kind === 4 /* Container */ || isOneDeclarationOfKind(symbol, 4 /* Container */));
+        }
+        PullHelpers.symbolIsModule = symbolIsModule;
+
+        function isOneDeclarationOfKind(symbol, kind) {
+            var decls = symbol.getDeclarations();
+            for (var i = 0; i < decls.length; i++) {
+                if (decls[i].kind === kind) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        function isNameNumeric(name) {
+            return isFinite(+name);
+        }
+        PullHelpers.isNameNumeric = isNameNumeric;
+
+        function typeSymbolsAreIdentical(a, b) {
+            if (a.isTypeReference() && !a.getIsSpecialized()) {
+                a = a.referencedTypeSymbol;
+            }
+
+            if (b.isTypeReference() && !b.getIsSpecialized()) {
+                b = b.referencedTypeSymbol;
+            }
+
+            return a === b;
+        }
+        PullHelpers.typeSymbolsAreIdentical = typeSymbolsAreIdentical;
+
+        function getRootType(type) {
+            var rootType = type.getRootSymbol();
+
+            while (true) {
+                if (type === rootType) {
+                    return type;
+                }
+
+                type = rootType;
+                rootType = type.getRootSymbol();
+            }
+        }
+        PullHelpers.getRootType = getRootType;
+
+        function isSymbolLocal(symbol) {
+            var container = symbol.getContainer();
+            if (container) {
+                var containerKind = container.kind;
+                if (containerKind & (1032192 /* SomeFunction */ | 16777216 /* FunctionType */)) {
+                    return true;
+                }
+
+                if (containerKind === 33554432 /* ConstructorType */ && !symbol.anyDeclHasFlag(16 /* Static */ | 1 /* Exported */)) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+        PullHelpers.isSymbolLocal = isSymbolLocal;
+
+        function isExportedSymbolInClodule(symbol) {
+            var container = symbol.getContainer();
+            return container && container.kind === 33554432 /* ConstructorType */ && symbolIsModule(container) && symbol.anyDeclHasFlag(1 /* Exported */);
+        }
+        PullHelpers.isExportedSymbolInClodule = isExportedSymbolInClodule;
+
+        function isSymbolDeclaredInScopeChain(symbol, scopeSymbol) {
+            TypeScript.Debug.assert(symbol);
+            var symbolDeclarationScope = symbol.getContainer();
+
+            while (scopeSymbol) {
+                if (scopeSymbol === symbolDeclarationScope) {
+                    return true;
+                }
+
+                scopeSymbol = scopeSymbol.getContainer();
+            }
+
+            if (scopeSymbol === null && symbolDeclarationScope === null) {
+                return true;
+            }
+
+            return false;
+        }
+        PullHelpers.isSymbolDeclaredInScopeChain = isSymbolDeclaredInScopeChain;
+
+        
+
+        function walkSignatureSymbol(signatureSymbol, walker) {
+            var continueWalk = true;
+            var parameters = signatureSymbol.parameters;
+            if (parameters) {
+                for (var i = 0; continueWalk && i < parameters.length; i++) {
+                    continueWalk = walker.signatureParameterWalk(parameters[i]);
+                }
+            }
+
+            if (continueWalk) {
+                continueWalk = walker.signatureReturnTypeWalk(signatureSymbol.returnType);
+            }
+
+            return continueWalk;
+        }
+
+        function walkPullTypeSymbolStructure(typeSymbol, walker) {
+            var continueWalk = true;
+
+            var members = typeSymbol.getMembers();
+            for (var i = 0; continueWalk && i < members.length; i++) {
+                continueWalk = walker.memberSymbolWalk(members[i]);
+            }
+
+            if (continueWalk) {
+                var callSigantures = typeSymbol.getCallSignatures();
+                for (var i = 0; continueWalk && i < callSigantures.length; i++) {
+                    continueWalk = walker.callSignatureWalk(callSigantures[i]);
+                    if (continueWalk) {
+                        continueWalk = walkSignatureSymbol(callSigantures[i], walker);
+                    }
+                }
+            }
+
+            if (continueWalk) {
+                var constructSignatures = typeSymbol.getConstructSignatures();
+                for (var i = 0; continueWalk && i < constructSignatures.length; i++) {
+                    continueWalk = walker.constructSignatureWalk(constructSignatures[i]);
+                    if (continueWalk) {
+                        continueWalk = walkSignatureSymbol(constructSignatures[i], walker);
+                    }
+                }
+            }
+
+            if (continueWalk) {
+                var indexSignatures = typeSymbol.getIndexSignatures();
+                for (var i = 0; continueWalk && i < indexSignatures.length; i++) {
+                    continueWalk = walker.indexSignatureWalk(indexSignatures[i]);
+                    if (continueWalk) {
+                        continueWalk = walkSignatureSymbol(indexSignatures[i], walker);
+                    }
+                }
+            }
+        }
+        PullHelpers.walkPullTypeSymbolStructure = walkPullTypeSymbolStructure;
+
+        var OtherPullDeclsWalker = (function () {
+            function OtherPullDeclsWalker() {
+                this.currentlyWalkingOtherDecls = [];
+            }
+            OtherPullDeclsWalker.prototype.walkOtherPullDecls = function (currentDecl, otherDecls, callBack) {
+                if (otherDecls) {
+                    var isAlreadyWalkingOtherDecl = TypeScript.ArrayUtilities.any(this.currentlyWalkingOtherDecls, function (inWalkingOtherDecl) {
+                        return TypeScript.ArrayUtilities.contains(otherDecls, inWalkingOtherDecl);
+                    });
+
+                    if (!isAlreadyWalkingOtherDecl) {
+                        this.currentlyWalkingOtherDecls.push(currentDecl);
+                        for (var i = 0; i < otherDecls.length; i++) {
+                            if (otherDecls[i] !== currentDecl) {
+                                callBack(otherDecls[i]);
+                            }
+                        }
+                        var currentlyWalkingOtherDeclsDecl = this.currentlyWalkingOtherDecls.pop();
+                        TypeScript.Debug.assert(currentlyWalkingOtherDeclsDecl == currentDecl);
+                    }
+                }
+            };
+            return OtherPullDeclsWalker;
+        })();
+        PullHelpers.OtherPullDeclsWalker = OtherPullDeclsWalker;
+    })(TypeScript.PullHelpers || (TypeScript.PullHelpers = {}));
+    var PullHelpers = TypeScript.PullHelpers;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var WrapsTypeParameterCache = (function () {
+        function WrapsTypeParameterCache() {
+            this._wrapsTypeParameterCache = TypeScript.BitVector.getBitVector(true);
+        }
+        WrapsTypeParameterCache.prototype.getWrapsTypeParameter = function (typeParameterArgumentMap) {
+            var mapHasTypeParameterNotCached = false;
+            for (var typeParameterID in typeParameterArgumentMap) {
+                if (typeParameterArgumentMap.hasOwnProperty(typeParameterID)) {
+                    var cachedValue = this._wrapsTypeParameterCache.valueAt(typeParameterID);
+                    if (cachedValue) {
+                        return typeParameterID;
+                    }
+                    mapHasTypeParameterNotCached = mapHasTypeParameterNotCached || cachedValue === undefined;
+                }
+            }
+
+            if (!mapHasTypeParameterNotCached) {
+                return 0;
+            }
+
+            return undefined;
+        };
+
+        WrapsTypeParameterCache.prototype.setWrapsTypeParameter = function (typeParameterArgumentMap, wrappingTypeParameterID) {
+            if (wrappingTypeParameterID) {
+                this._wrapsTypeParameterCache.setValueAt(wrappingTypeParameterID, true);
+            } else {
+                for (var typeParameterID in typeParameterArgumentMap) {
+                    if (typeParameterArgumentMap.hasOwnProperty(typeParameterID)) {
+                        this._wrapsTypeParameterCache.setValueAt(typeParameterID, false);
+                    }
+                }
+            }
+        };
+        return WrapsTypeParameterCache;
+    })();
+    TypeScript.WrapsTypeParameterCache = WrapsTypeParameterCache;
+
+    (function (PullInstantiationHelpers) {
+        var MutableTypeArgumentMap = (function () {
+            function MutableTypeArgumentMap(typeParameterArgumentMap) {
+                this.typeParameterArgumentMap = typeParameterArgumentMap;
+                this.createdDuplicateTypeArgumentMap = false;
+            }
+            MutableTypeArgumentMap.prototype.ensureTypeArgumentCopy = function () {
+                if (!this.createdDuplicateTypeArgumentMap) {
+                    var passedInTypeArgumentMap = this.typeParameterArgumentMap;
+                    this.typeParameterArgumentMap = [];
+                    for (var typeParameterID in passedInTypeArgumentMap) {
+                        if (passedInTypeArgumentMap.hasOwnProperty(typeParameterID)) {
+                            this.typeParameterArgumentMap[typeParameterID] = passedInTypeArgumentMap[typeParameterID];
+                        }
+                    }
+                    this.createdDuplicateTypeArgumentMap = true;
+                }
+            };
+            return MutableTypeArgumentMap;
+        })();
+        PullInstantiationHelpers.MutableTypeArgumentMap = MutableTypeArgumentMap;
+
+        function instantiateTypeArgument(resolver, symbol, mutableTypeParameterMap) {
+            if (symbol.getIsSpecialized()) {
+                var rootTypeArgumentMap = symbol.getTypeParameterArgumentMap();
+                var newTypeArgumentMap = [];
+                var allowedTypeParameters = symbol.getAllowedToReferenceTypeParameters();
+                for (var i = 0; i < allowedTypeParameters.length; i++) {
+                    var typeParameterID = allowedTypeParameters[i].pullSymbolID;
+                    var typeArg = rootTypeArgumentMap[typeParameterID];
+                    if (typeArg) {
+                        newTypeArgumentMap[typeParameterID] = resolver.instantiateType(typeArg, mutableTypeParameterMap.typeParameterArgumentMap);
+                    }
+                }
+
+                for (var i = 0; i < allowedTypeParameters.length; i++) {
+                    var typeParameterID = allowedTypeParameters[i].pullSymbolID;
+                    if (newTypeArgumentMap[typeParameterID] && mutableTypeParameterMap.typeParameterArgumentMap[typeParameterID] != newTypeArgumentMap[typeParameterID]) {
+                        mutableTypeParameterMap.ensureTypeArgumentCopy();
+                        mutableTypeParameterMap.typeParameterArgumentMap[typeParameterID] = newTypeArgumentMap[typeParameterID];
+                    }
+                }
+            }
+        }
+        PullInstantiationHelpers.instantiateTypeArgument = instantiateTypeArgument;
+
+        function cleanUpTypeArgumentMap(symbol, mutableTypeArgumentMap) {
+            var allowedToReferenceTypeParameters = symbol.getAllowedToReferenceTypeParameters();
+            for (var typeParameterID in mutableTypeArgumentMap.typeParameterArgumentMap) {
+                if (mutableTypeArgumentMap.typeParameterArgumentMap.hasOwnProperty(typeParameterID)) {
+                    if (!TypeScript.ArrayUtilities.any(allowedToReferenceTypeParameters, function (typeParameter) {
+                        return typeParameter.pullSymbolID == typeParameterID;
+                    })) {
+                        mutableTypeArgumentMap.ensureTypeArgumentCopy();
+                        delete mutableTypeArgumentMap.typeParameterArgumentMap[typeParameterID];
+                    }
+                }
+            }
+        }
+        PullInstantiationHelpers.cleanUpTypeArgumentMap = cleanUpTypeArgumentMap;
+
+        function getAllowedToReferenceTypeParametersFromDecl(decl) {
+            var allowedToReferenceTypeParameters = [];
+
+            var allowedToUseDeclTypeParameters = false;
+            var getTypeParametersFromParentDecl = false;
+
+            switch (decl.kind) {
+                case 65536 /* Method */:
+                    if (TypeScript.hasFlag(decl.flags, 16 /* Static */)) {
+                        allowedToUseDeclTypeParameters = true;
+                        break;
+                    }
+
+                case 16777216 /* FunctionType */:
+                case 33554432 /* ConstructorType */:
+                case 2097152 /* ConstructSignature */:
+                case 1048576 /* CallSignature */:
+                case 131072 /* FunctionExpression */:
+                case 16384 /* Function */:
+                    allowedToUseDeclTypeParameters = true;
+                    getTypeParametersFromParentDecl = true;
+                    break;
+
+                case 4096 /* Property */:
+                    if (TypeScript.hasFlag(decl.flags, 16 /* Static */)) {
+                        break;
+                    }
+
+                case 2048 /* Parameter */:
+                case 262144 /* GetAccessor */:
+                case 524288 /* SetAccessor */:
+                case 32768 /* ConstructorMethod */:
+                case 4194304 /* IndexSignature */:
+                case 8388608 /* ObjectType */:
+                case 256 /* ObjectLiteral */:
+                case 8192 /* TypeParameter */:
+                    getTypeParametersFromParentDecl = true;
+                    break;
+
+                case 8 /* Class */:
+                case 16 /* Interface */:
+                    allowedToUseDeclTypeParameters = true;
+                    break;
+            }
+
+            if (getTypeParametersFromParentDecl) {
+                allowedToReferenceTypeParameters = allowedToReferenceTypeParameters.concat(getAllowedToReferenceTypeParametersFromDecl(decl.getParentDecl()));
+            }
+
+            if (allowedToUseDeclTypeParameters) {
+                var typeParameterDecls = decl.getTypeParameters();
+                for (var i = 0; i < typeParameterDecls.length; i++) {
+                    allowedToReferenceTypeParameters.push(typeParameterDecls[i].getSymbol());
+                }
+            }
+
+            return allowedToReferenceTypeParameters;
+        }
+        PullInstantiationHelpers.getAllowedToReferenceTypeParametersFromDecl = getAllowedToReferenceTypeParametersFromDecl;
+
+        function createTypeParameterArgumentMap(typeParameters, typeArguments) {
+            return updateTypeParameterArgumentMap(typeParameters, typeArguments, {});
+        }
+        PullInstantiationHelpers.createTypeParameterArgumentMap = createTypeParameterArgumentMap;
+
+        function updateTypeParameterArgumentMap(typeParameters, typeArguments, typeParameterArgumentMap) {
+            for (var i = 0; i < typeParameters.length; i++) {
+                typeParameterArgumentMap[typeParameters[i].getRootSymbol().pullSymbolID] = typeArguments[i];
+            }
+            return typeParameterArgumentMap;
+        }
+        PullInstantiationHelpers.updateTypeParameterArgumentMap = updateTypeParameterArgumentMap;
+
+        function updateMutableTypeParameterArgumentMap(typeParameters, typeArguments, mutableMap) {
+            for (var i = 0; i < typeParameters.length; i++) {
+                var typeParameterId = typeParameters[i].getRootSymbol().pullSymbolID;
+                if (mutableMap.typeParameterArgumentMap[typeParameterId] !== typeArguments[i]) {
+                    mutableMap.ensureTypeArgumentCopy();
+                    mutableMap.typeParameterArgumentMap[typeParameterId] = typeArguments[i];
+                }
+            }
+        }
+        PullInstantiationHelpers.updateMutableTypeParameterArgumentMap = updateMutableTypeParameterArgumentMap;
+
+        function twoTypesAreInstantiationsOfSameNamedGenericType(type1, type2) {
+            var type1IsGeneric = type1.isGeneric() && type1.getTypeArguments() !== null;
+            var type2IsGeneric = type2.isGeneric() && type2.getTypeArguments() !== null;
+
+            if (type1IsGeneric && type2IsGeneric) {
+                var type1Root = TypeScript.PullHelpers.getRootType(type1);
+                var type2Root = TypeScript.PullHelpers.getRootType(type2);
+                return type1Root === type2Root;
+            }
+
+            return false;
+        }
+        PullInstantiationHelpers.twoTypesAreInstantiationsOfSameNamedGenericType = twoTypesAreInstantiationsOfSameNamedGenericType;
+    })(TypeScript.PullInstantiationHelpers || (TypeScript.PullInstantiationHelpers = {}));
+    var PullInstantiationHelpers = TypeScript.PullInstantiationHelpers;
+})(TypeScript || (TypeScript = {}));
+if (Error)
+    Error.stackTraceLimit = 1000;
+
+var TypeScript;
+(function (TypeScript) {
+    TypeScript.fileResolutionTime = 0;
+    TypeScript.fileResolutionIOTime = 0;
+    TypeScript.fileResolutionScanImportsTime = 0;
+    TypeScript.fileResolutionImportFileSearchTime = 0;
+    TypeScript.fileResolutionGetDefaultLibraryTime = 0;
+    TypeScript.sourceCharactersCompiled = 0;
+    TypeScript.syntaxTreeParseTime = 0;
+    TypeScript.syntaxDiagnosticsTime = 0;
+    TypeScript.astTranslationTime = 0;
+    TypeScript.typeCheckTime = 0;
+
+    TypeScript.compilerResolvePathTime = 0;
+    TypeScript.compilerDirectoryNameTime = 0;
+    TypeScript.compilerDirectoryExistsTime = 0;
+    TypeScript.compilerFileExistsTime = 0;
+
+    TypeScript.emitTime = 0;
+    TypeScript.emitWriteFileTime = 0;
+
+    TypeScript.declarationEmitTime = 0;
+    TypeScript.declarationEmitIsExternallyVisibleTime = 0;
+    TypeScript.declarationEmitTypeSignatureTime = 0;
+    TypeScript.declarationEmitGetBoundDeclTypeTime = 0;
+    TypeScript.declarationEmitIsOverloadedCallSignatureTime = 0;
+    TypeScript.declarationEmitFunctionDeclarationGetSymbolTime = 0;
+    TypeScript.declarationEmitGetBaseTypeTime = 0;
+    TypeScript.declarationEmitGetAccessorFunctionTime = 0;
+    TypeScript.declarationEmitGetTypeParameterSymbolTime = 0;
+    TypeScript.declarationEmitGetImportDeclarationSymbolTime = 0;
+
+    TypeScript.ioHostResolvePathTime = 0;
+    TypeScript.ioHostDirectoryNameTime = 0;
+    TypeScript.ioHostCreateDirectoryStructureTime = 0;
+    TypeScript.ioHostWriteFileTime = 0;
+
+    (function (EmitOutputResult) {
+        EmitOutputResult[EmitOutputResult["Succeeded"] = 0] = "Succeeded";
+        EmitOutputResult[EmitOutputResult["FailedBecauseOfSyntaxErrors"] = 1] = "FailedBecauseOfSyntaxErrors";
+        EmitOutputResult[EmitOutputResult["FailedBecauseOfCompilerOptionsErrors"] = 2] = "FailedBecauseOfCompilerOptionsErrors";
+        EmitOutputResult[EmitOutputResult["FailedToGenerateDeclarationsBecauseOfSemanticErrors"] = 3] = "FailedToGenerateDeclarationsBecauseOfSemanticErrors";
+    })(TypeScript.EmitOutputResult || (TypeScript.EmitOutputResult = {}));
+    var EmitOutputResult = TypeScript.EmitOutputResult;
+
+    var EmitOutput = (function () {
+        function EmitOutput(emitOutputResult) {
+            if (typeof emitOutputResult === "undefined") { emitOutputResult = 0 /* Succeeded */; }
+            this.outputFiles = [];
+            this.emitOutputResult = emitOutputResult;
+        }
+        return EmitOutput;
+    })();
+    TypeScript.EmitOutput = EmitOutput;
+
+    (function (OutputFileType) {
+        OutputFileType[OutputFileType["JavaScript"] = 0] = "JavaScript";
+        OutputFileType[OutputFileType["SourceMap"] = 1] = "SourceMap";
+        OutputFileType[OutputFileType["Declaration"] = 2] = "Declaration";
+    })(TypeScript.OutputFileType || (TypeScript.OutputFileType = {}));
+    var OutputFileType = TypeScript.OutputFileType;
+
+    var OutputFile = (function () {
+        function OutputFile(name, writeByteOrderMark, text, fileType, sourceMapEntries) {
+            if (typeof sourceMapEntries === "undefined") { sourceMapEntries = []; }
+            this.name = name;
+            this.writeByteOrderMark = writeByteOrderMark;
+            this.text = text;
+            this.fileType = fileType;
+            this.sourceMapEntries = sourceMapEntries;
+        }
+        return OutputFile;
+    })();
+    TypeScript.OutputFile = OutputFile;
+
+    var CompileResult = (function () {
+        function CompileResult() {
+            this.diagnostics = [];
+            this.outputFiles = [];
+        }
+        CompileResult.fromDiagnostics = function (diagnostics) {
+            var result = new CompileResult();
+            result.diagnostics = diagnostics;
+            return result;
+        };
+
+        CompileResult.fromOutputFiles = function (outputFiles) {
+            var result = new CompileResult();
+            result.outputFiles = outputFiles;
+            return result;
+        };
+        return CompileResult;
+    })();
+    TypeScript.CompileResult = CompileResult;
+
+    var TypeScriptCompiler = (function () {
+        function TypeScriptCompiler(logger, _settings) {
+            if (typeof logger === "undefined") { logger = new TypeScript.NullLogger(); }
+            if (typeof _settings === "undefined") { _settings = TypeScript.ImmutableCompilationSettings.defaultSettings(); }
+            this.logger = logger;
+            this._settings = _settings;
+            this.semanticInfoChain = null;
+            this.semanticInfoChain = new TypeScript.SemanticInfoChain(this, logger);
+        }
+        TypeScriptCompiler.prototype.compilationSettings = function () {
+            return this._settings;
+        };
+
+        TypeScriptCompiler.prototype.setCompilationSettings = function (newSettings) {
+            var oldSettings = this._settings;
+            this._settings = newSettings;
+
+            if (!compareDataObjects(oldSettings, newSettings)) {
+                this.semanticInfoChain.invalidate(oldSettings, newSettings);
+            }
+        };
+
+        TypeScriptCompiler.prototype.getDocument = function (fileName) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+            return this.semanticInfoChain.getDocument(fileName);
+        };
+
+        TypeScriptCompiler.prototype.cleanupSemanticCache = function () {
+            this.semanticInfoChain.invalidate();
+        };
+
+        TypeScriptCompiler.prototype.addFile = function (fileName, scriptSnapshot, byteOrderMark, version, isOpen, referencedFiles) {
+            if (typeof referencedFiles === "undefined") { referencedFiles = []; }
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+
+            TypeScript.sourceCharactersCompiled += scriptSnapshot.getLength();
+
+            var document = TypeScript.Document.create(this, this.semanticInfoChain, fileName, scriptSnapshot, byteOrderMark, version, isOpen, referencedFiles);
+
+            this.semanticInfoChain.addDocument(document);
+        };
+
+        TypeScriptCompiler.prototype.updateFile = function (fileName, scriptSnapshot, version, isOpen, textChangeRange) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+
+            var document = this.getDocument(fileName);
+            var updatedDocument = document.update(scriptSnapshot, version, isOpen, textChangeRange);
+
+            this.semanticInfoChain.addDocument(updatedDocument);
+        };
+
+        TypeScriptCompiler.prototype.removeFile = function (fileName) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+            this.semanticInfoChain.removeDocument(fileName);
+        };
+
+        TypeScriptCompiler.prototype.mapOutputFileName = function (document, emitOptions, extensionChanger) {
+            if (document.emitToOwnOutputFile()) {
+                var updatedFileName = document.fileName;
+                if (emitOptions.outputDirectory() !== "") {
+                    updatedFileName = document.fileName.replace(emitOptions.commonDirectoryPath(), "");
+                    updatedFileName = emitOptions.outputDirectory() + updatedFileName;
+                }
+                return extensionChanger(updatedFileName, false);
+            } else {
+                return extensionChanger(emitOptions.sharedOutputFile(), true);
+            }
+        };
+
+        TypeScriptCompiler.prototype.writeByteOrderMarkForDocument = function (document) {
+            var printReason = false;
+
+            if (document.emitToOwnOutputFile()) {
+                var result = document.byteOrderMark !== 0 /* None */;
+                if (printReason) {
+                    TypeScript.Environment.standardOut.WriteLine("Emitting byte order mark because of: " + document.fileName);
+                }
+                return result;
+            } else {
+                var fileNames = this.fileNames();
+
+                var result = false;
+                for (var i = 0, n = fileNames.length; i < n; i++) {
+                    var document = this.getDocument(fileNames[i]);
+
+                    if (document.isExternalModule()) {
+                        continue;
+                    }
+
+                    if (document.byteOrderMark !== 0 /* None */) {
+                        if (printReason) {
+                            TypeScript.Environment.standardOut.WriteLine("Emitting byte order mark because of: " + document.fileName);
+                            result = true;
+                        } else {
+                            return true;
+                        }
+                    }
+                }
+
+                return result;
+            }
+        };
+
+        TypeScriptCompiler.mapToDTSFileName = function (fileName, wholeFileNameReplaced) {
+            return TypeScript.getDeclareFilePath(fileName);
+        };
+
+        TypeScriptCompiler.prototype._shouldEmit = function (document) {
+            return !document.isDeclareFile();
+        };
+
+        TypeScriptCompiler.prototype._shouldEmitDeclarations = function (document) {
+            if (!this.compilationSettings().generateDeclarationFiles()) {
+                return false;
+            }
+
+            return this._shouldEmit(document);
+        };
+
+        TypeScriptCompiler.prototype.emitDocumentDeclarationsWorker = function (document, emitOptions, declarationEmitter) {
+            var sourceUnit = document.sourceUnit();
+            TypeScript.Debug.assert(this._shouldEmitDeclarations(document));
+
+            if (declarationEmitter) {
+                declarationEmitter.document = document;
+            } else {
+                var declareFileName = this.mapOutputFileName(document, emitOptions, TypeScriptCompiler.mapToDTSFileName);
+                declarationEmitter = new TypeScript.DeclarationEmitter(declareFileName, document, this, emitOptions, this.semanticInfoChain);
+            }
+
+            declarationEmitter.emitDeclarations(sourceUnit);
+            return declarationEmitter;
+        };
+
+        TypeScriptCompiler.prototype._emitDocumentDeclarations = function (document, emitOptions, onSingleFileEmitComplete, sharedEmitter) {
+            if (this._shouldEmitDeclarations(document)) {
+                if (document.emitToOwnOutputFile()) {
+                    var singleEmitter = this.emitDocumentDeclarationsWorker(document, emitOptions);
+                    if (singleEmitter) {
+                        onSingleFileEmitComplete(singleEmitter.getOutputFile());
+                    }
+                } else {
+                    sharedEmitter = this.emitDocumentDeclarationsWorker(document, emitOptions, sharedEmitter);
+                }
+            }
+
+            return sharedEmitter;
+        };
+
+        TypeScriptCompiler.prototype.emitAllDeclarations = function (resolvePath) {
+            var start = new Date().getTime();
+            var emitOutput = new EmitOutput();
+
+            var emitOptions = new TypeScript.EmitOptions(this, resolvePath);
+            if (emitOptions.diagnostic()) {
+                emitOutput.emitOutputResult = 2 /* FailedBecauseOfCompilerOptionsErrors */;
+                return emitOutput;
+            }
+
+            var sharedEmitter = null;
+            var fileNames = this.fileNames();
+
+            for (var i = 0, n = fileNames.length; i < n; i++) {
+                var fileName = fileNames[i];
+
+                var document = this.getDocument(fileNames[i]);
+
+                sharedEmitter = this._emitDocumentDeclarations(document, emitOptions, function (file) {
+                    return emitOutput.outputFiles.push(file);
+                }, sharedEmitter);
+            }
+
+            if (sharedEmitter) {
+                emitOutput.outputFiles.push(sharedEmitter.getOutputFile());
+            }
+
+            TypeScript.declarationEmitTime += new Date().getTime() - start;
+
+            return emitOutput;
+        };
+
+        TypeScriptCompiler.prototype.emitDeclarations = function (fileName, resolvePath) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+            var emitOutput = new EmitOutput();
+
+            var emitOptions = new TypeScript.EmitOptions(this, resolvePath);
+            if (emitOptions.diagnostic()) {
+                emitOutput.emitOutputResult = 2 /* FailedBecauseOfCompilerOptionsErrors */;
+                return emitOutput;
+            }
+
+            var document = this.getDocument(fileName);
+
+            if (document.emitToOwnOutputFile()) {
+                this._emitDocumentDeclarations(document, emitOptions, function (file) {
+                    return emitOutput.outputFiles.push(file);
+                }, null);
+                return emitOutput;
+            } else {
+                return this.emitAllDeclarations(resolvePath);
+            }
+        };
+
+        TypeScriptCompiler.prototype.canEmitDeclarations = function (fileName) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+            var document = this.getDocument(fileName);
+            return this._shouldEmitDeclarations(document);
+        };
+
+        TypeScriptCompiler.mapToFileNameExtension = function (extension, fileName, wholeFileNameReplaced) {
+            if (wholeFileNameReplaced) {
+                return fileName;
+            } else {
+                var splitFname = fileName.split(".");
+                splitFname.pop();
+                return splitFname.join(".") + extension;
+            }
+        };
+
+        TypeScriptCompiler.mapToJSFileName = function (fileName, wholeFileNameReplaced) {
+            return TypeScriptCompiler.mapToFileNameExtension(".js", fileName, wholeFileNameReplaced);
+        };
+
+        TypeScriptCompiler.prototype.emitDocumentWorker = function (document, emitOptions, emitter) {
+            var sourceUnit = document.sourceUnit();
+            TypeScript.Debug.assert(this._shouldEmit(document));
+
+            var typeScriptFileName = document.fileName;
+            if (!emitter) {
+                var javaScriptFileName = this.mapOutputFileName(document, emitOptions, TypeScriptCompiler.mapToJSFileName);
+                var outFile = new TypeScript.TextWriter(javaScriptFileName, this.writeByteOrderMarkForDocument(document), 0 /* JavaScript */);
+
+                emitter = new TypeScript.Emitter(javaScriptFileName, outFile, emitOptions, this.semanticInfoChain);
+
+                if (this.compilationSettings().mapSourceFiles()) {
+                    var sourceMapFile = new TypeScript.TextWriter(javaScriptFileName + TypeScript.SourceMapper.MapFileExtension, false, 1 /* SourceMap */);
+                    emitter.createSourceMapper(document, javaScriptFileName, outFile, sourceMapFile, emitOptions.resolvePath);
+                }
+            } else if (this.compilationSettings().mapSourceFiles()) {
+                emitter.setSourceMapperNewSourceFile(document);
+            }
+
+            emitter.setDocument(document);
+            emitter.emitJavascript(sourceUnit, false);
+
+            return emitter;
+        };
+
+        TypeScriptCompiler.prototype._emitDocument = function (document, emitOptions, onSingleFileEmitComplete, sharedEmitter) {
+            if (this._shouldEmit(document)) {
+                if (document.emitToOwnOutputFile()) {
+                    var singleEmitter = this.emitDocumentWorker(document, emitOptions);
+                    if (singleEmitter) {
+                        onSingleFileEmitComplete(singleEmitter.getOutputFiles());
+                    }
+                } else {
+                    sharedEmitter = this.emitDocumentWorker(document, emitOptions, sharedEmitter);
+                }
+            }
+
+            return sharedEmitter;
+        };
+
+        TypeScriptCompiler.prototype.emitAll = function (resolvePath) {
+            var start = new Date().getTime();
+            var emitOutput = new EmitOutput();
+
+            var emitOptions = new TypeScript.EmitOptions(this, resolvePath);
+            if (emitOptions.diagnostic()) {
+                emitOutput.emitOutputResult = 2 /* FailedBecauseOfCompilerOptionsErrors */;
+                return emitOutput;
+            }
+
+            var fileNames = this.fileNames();
+            var sharedEmitter = null;
+
+            for (var i = 0, n = fileNames.length; i < n; i++) {
+                var fileName = fileNames[i];
+
+                var document = this.getDocument(fileName);
+
+                sharedEmitter = this._emitDocument(document, emitOptions, function (files) {
+                    return emitOutput.outputFiles.push.apply(emitOutput.outputFiles, files);
+                }, sharedEmitter);
+            }
+
+            if (sharedEmitter) {
+                emitOutput.outputFiles.push.apply(emitOutput.outputFiles, sharedEmitter.getOutputFiles());
+            }
+
+            TypeScript.emitTime += new Date().getTime() - start;
+            return emitOutput;
+        };
+
+        TypeScriptCompiler.prototype.emit = function (fileName, resolvePath) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+            var emitOutput = new EmitOutput();
+
+            var emitOptions = new TypeScript.EmitOptions(this, resolvePath);
+            if (emitOptions.diagnostic()) {
+                emitOutput.emitOutputResult = 2 /* FailedBecauseOfCompilerOptionsErrors */;
+                return emitOutput;
+            }
+
+            var document = this.getDocument(fileName);
+
+            if (document.emitToOwnOutputFile()) {
+                this._emitDocument(document, emitOptions, function (files) {
+                    return emitOutput.outputFiles.push.apply(emitOutput.outputFiles, files);
+                }, null);
+                return emitOutput;
+            } else {
+                return this.emitAll(resolvePath);
+            }
+        };
+
+        TypeScriptCompiler.prototype.compile = function (resolvePath, continueOnDiagnostics) {
+            if (typeof continueOnDiagnostics === "undefined") { continueOnDiagnostics = false; }
+            return new CompilerIterator(this, resolvePath, continueOnDiagnostics);
+        };
+
+        TypeScriptCompiler.prototype.getSyntacticDiagnostics = function (fileName) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+            return this.getDocument(fileName).diagnostics();
+        };
+
+        TypeScriptCompiler.prototype.getSyntaxTree = function (fileName) {
+            return this.getDocument(fileName).syntaxTree();
+        };
+
+        TypeScriptCompiler.prototype.getSourceUnit = function (fileName) {
+            return this.getDocument(fileName).sourceUnit();
+        };
+
+        TypeScriptCompiler.prototype.getSemanticDiagnostics = function (fileName) {
+            fileName = TypeScript.switchToForwardSlashes(fileName);
+
+            var document = this.getDocument(fileName);
+
+            var startTime = (new Date()).getTime();
+            TypeScript.PullTypeResolver.typeCheck(this.compilationSettings(), this.semanticInfoChain, document);
+            var endTime = (new Date()).getTime();
+
+            TypeScript.typeCheckTime += endTime - startTime;
+
+            var errors = this.semanticInfoChain.getDiagnostics(fileName);
+
+            errors = TypeScript.ArrayUtilities.distinct(errors, TypeScript.Diagnostic.equals);
+            errors.sort(function (d1, d2) {
+                if (d1.fileName() < d2.fileName()) {
+                    return -1;
+                } else if (d1.fileName() > d2.fileName()) {
+                    return 1;
+                }
+
+                if (d1.start() < d2.start()) {
+                    return -1;
+                } else if (d1.start() > d2.start()) {
+                    return 1;
+                }
+
+                var code1 = TypeScript.diagnosticInformationMap[d1.diagnosticKey()].code;
+                var code2 = TypeScript.diagnosticInformationMap[d2.diagnosticKey()].code;
+                if (code1 < code2) {
+                    return -1;
+                } else if (code1 > code2) {
+                    return 1;
+                }
+
+                return 0;
+            });
+
+            return errors;
+        };
+
+        TypeScriptCompiler.prototype.getCompilerOptionsDiagnostics = function (resolvePath) {
+            var emitOptions = new TypeScript.EmitOptions(this, resolvePath);
+            var emitDiagnostic = emitOptions.diagnostic();
+            if (emitDiagnostic) {
+                return [emitDiagnostic];
+            }
+            return TypeScript.sentinelEmptyArray;
+        };
+
+        TypeScriptCompiler.prototype.resolveAllFiles = function () {
+            var fileNames = this.fileNames();
+            for (var i = 0, n = fileNames.length; i < n; i++) {
+                this.getSemanticDiagnostics(fileNames[i]);
+            }
+        };
+
+        TypeScriptCompiler.prototype.getSymbolOfDeclaration = function (decl) {
+            if (!decl) {
+                return null;
+            }
+
+            var resolver = this.semanticInfoChain.getResolver();
+            var ast = this.semanticInfoChain.getASTForDecl(decl);
+            if (!ast) {
+                return null;
+            }
+
+            var enclosingDecl = resolver.getEnclosingDecl(decl);
+            if (ast.kind() === 139 /* GetAccessor */ || ast.kind() === 140 /* SetAccessor */) {
+                return this.getSymbolOfDeclaration(enclosingDecl);
+            }
+
+            return resolver.resolveAST(ast, false, new TypeScript.PullTypeResolutionContext(resolver));
+        };
+
+        TypeScriptCompiler.prototype.extractResolutionContextFromAST = function (resolver, ast, document, propagateContextualTypes) {
+            var scriptName = document.fileName;
+
+            var enclosingDecl = null;
+            var enclosingDeclAST = null;
+            var inContextuallyTypedAssignment = false;
+            var inWithBlock = false;
+
+            var resolutionContext = new TypeScript.PullTypeResolutionContext(resolver);
+
+            if (!ast) {
+                return null;
+            }
+
+            var path = this.getASTPath(ast);
+
+            for (var i = 0, n = path.length; i < n; i++) {
+                var current = path[i];
+
+                switch (current.kind()) {
+                    case 222 /* FunctionExpression */:
+                    case 219 /* SimpleArrowFunctionExpression */:
+                    case 218 /* ParenthesizedArrowFunctionExpression */:
+                        if (propagateContextualTypes) {
+                            resolver.resolveAST(current, true, resolutionContext);
+                        }
+                        break;
+
+                    case 136 /* MemberVariableDeclaration */:
+                        var memberVariable = current;
+                        inContextuallyTypedAssignment = memberVariable.variableDeclarator.typeAnnotation !== null;
+
+                        this.extractResolutionContextForVariable(inContextuallyTypedAssignment, propagateContextualTypes, resolver, resolutionContext, enclosingDecl, memberVariable, memberVariable.variableDeclarator.equalsValueClause);
+                        break;
+
+                    case 225 /* VariableDeclarator */:
+                        var variableDeclarator = current;
+                        inContextuallyTypedAssignment = variableDeclarator.typeAnnotation !== null;
+
+                        this.extractResolutionContextForVariable(inContextuallyTypedAssignment, propagateContextualTypes, resolver, resolutionContext, enclosingDecl, variableDeclarator, variableDeclarator.equalsValueClause);
+                        break;
+
+                    case 213 /* InvocationExpression */:
+                    case 216 /* ObjectCreationExpression */:
+                        if (propagateContextualTypes) {
+                            var isNew = current.kind() === 216 /* ObjectCreationExpression */;
+                            var callExpression = current;
+                            var contextualType = null;
+
+                            if ((i + 2 < n) && callExpression.argumentList === path[i + 1] && callExpression.argumentList.arguments === path[i + 2]) {
+                                var callResolutionResults = new TypeScript.PullAdditionalCallResolutionData();
+                                if (isNew) {
+                                    resolver.resolveObjectCreationExpression(callExpression, resolutionContext, callResolutionResults);
+                                } else {
+                                    resolver.resolveInvocationExpression(callExpression, resolutionContext, callResolutionResults);
+                                }
+
+                                if (callResolutionResults.actualParametersContextTypeSymbols) {
+                                    var argExpression = path[i + 3];
+                                    if (argExpression) {
+                                        for (var j = 0, m = callExpression.argumentList.arguments.nonSeparatorCount(); j < m; j++) {
+                                            if (callExpression.argumentList.arguments.nonSeparatorAt(j) === argExpression) {
+                                                var callContextualType = callResolutionResults.actualParametersContextTypeSymbols[j];
+                                                if (callContextualType) {
+                                                    contextualType = callContextualType;
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            } else {
+                                if (isNew) {
+                                    resolver.resolveObjectCreationExpression(callExpression, resolutionContext);
+                                } else {
+                                    resolver.resolveInvocationExpression(callExpression, resolutionContext);
+                                }
+                            }
+
+                            resolutionContext.pushNewContextualType(contextualType);
+                        }
+
+                        break;
+
+                    case 214 /* ArrayLiteralExpression */:
+                        if (propagateContextualTypes) {
+                            var contextualType = null;
+                            var currentContextualType = resolutionContext.getContextualType();
+                            if (currentContextualType && currentContextualType.isArrayNamedTypeReference()) {
+                                contextualType = currentContextualType.getElementType();
+                            }
+
+                            resolutionContext.pushNewContextualType(contextualType);
+                        }
+
+                        break;
+
+                    case 215 /* ObjectLiteralExpression */:
+                        if (propagateContextualTypes) {
+                            var objectLiteralExpression = current;
+                            var objectLiteralResolutionContext = new TypeScript.PullAdditionalObjectLiteralResolutionData();
+                            resolver.resolveObjectLiteralExpression(objectLiteralExpression, inContextuallyTypedAssignment, resolutionContext, objectLiteralResolutionContext);
+
+                            var memeberAST = (path[i + 1] && path[i + 1].kind() === 2 /* SeparatedList */) ? path[i + 2] : path[i + 1];
+                            if (memeberAST) {
+                                var contextualType = null;
+                                var memberDecls = objectLiteralExpression.propertyAssignments;
+                                if (memberDecls && objectLiteralResolutionContext.membersContextTypeSymbols) {
+                                    for (var j = 0, m = memberDecls.nonSeparatorCount(); j < m; j++) {
+                                        if (memberDecls.nonSeparatorAt(j) === memeberAST) {
+                                            var memberContextualType = objectLiteralResolutionContext.membersContextTypeSymbols[j];
+                                            if (memberContextualType) {
+                                                contextualType = memberContextualType;
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+
+                                resolutionContext.pushNewContextualType(contextualType);
+                            }
+                        }
+
+                        break;
+
+                    case 174 /* AssignmentExpression */:
+                        if (propagateContextualTypes) {
+                            var assignmentExpression = current;
+                            var contextualType = null;
+
+                            if (path[i + 1] && path[i + 1] === assignmentExpression.right) {
+                                var leftType = resolver.resolveAST(assignmentExpression.left, inContextuallyTypedAssignment, resolutionContext).type;
+                                if (leftType) {
+                                    inContextuallyTypedAssignment = true;
+                                    contextualType = leftType;
+                                }
+                            }
+
+                            resolutionContext.pushNewContextualType(contextualType);
+                        }
+
+                        break;
+
+                    case 220 /* CastExpression */:
+                        var castExpression = current;
+                        if (!(i + 1 < n && path[i + 1] === castExpression.type)) {
+                            if (propagateContextualTypes) {
+                                var contextualType = null;
+                                var typeSymbol = resolver.resolveAST(castExpression, inContextuallyTypedAssignment, resolutionContext).type;
+
+                                if (typeSymbol) {
+                                    inContextuallyTypedAssignment = true;
+                                    contextualType = typeSymbol;
+                                }
+
+                                resolutionContext.pushNewContextualType(contextualType);
+                            }
+                        }
+
+                        break;
+
+                    case 150 /* ReturnStatement */:
+                        if (propagateContextualTypes) {
+                            var returnStatement = current;
+                            var contextualType = null;
+
+                            if (enclosingDecl && (enclosingDecl.kind & 1032192 /* SomeFunction */)) {
+                                var typeAnnotation = TypeScript.ASTHelpers.getType(enclosingDeclAST);
+                                if (typeAnnotation) {
+                                    var returnTypeSymbol = resolver.resolveTypeReference(typeAnnotation, resolutionContext);
+                                    if (returnTypeSymbol) {
+                                        inContextuallyTypedAssignment = true;
+                                        contextualType = returnTypeSymbol;
+                                    }
+                                } else {
+                                    var currentContextualType = resolutionContext.getContextualType();
+                                    if (currentContextualType && currentContextualType.isFunction()) {
+                                        var contextualSignatures = currentContextualType.kind == 33554432 /* ConstructorType */ ? currentContextualType.getConstructSignatures() : currentContextualType.getCallSignatures();
+                                        var currentContextualTypeSignatureSymbol = contextualSignatures[0];
+                                        var currentContextualTypeReturnTypeSymbol = currentContextualTypeSignatureSymbol.returnType;
+                                        if (currentContextualTypeReturnTypeSymbol) {
+                                            inContextuallyTypedAssignment = true;
+                                            contextualType = currentContextualTypeReturnTypeSymbol;
+                                        }
+                                    }
+                                }
+                            }
+
+                            resolutionContext.pushNewContextualType(contextualType);
+                        }
+
+                        break;
+
+                    case 122 /* ObjectType */:
+                        if (propagateContextualTypes && TypeScript.isTypesOnlyLocation(current)) {
+                            resolver.resolveAST(current, false, resolutionContext);
+                        }
+
+                        break;
+
+                    case 163 /* WithStatement */:
+                        inWithBlock = true;
+                        break;
+
+                    case 146 /* Block */:
+                        inContextuallyTypedAssignment = false;
+                        break;
+                }
+
+                var decl = this.semanticInfoChain.getDeclForAST(current);
+                if (decl) {
+                    enclosingDecl = decl;
+                    enclosingDeclAST = current;
+                }
+            }
+
+            if (ast && ast.parent && ast.kind() === 11 /* IdentifierName */) {
+                if (ast.parent.kind() === 212 /* MemberAccessExpression */) {
+                    if (ast.parent.name === ast) {
+                        ast = ast.parent;
+                    }
+                } else if (ast.parent.kind() === 121 /* QualifiedName */) {
+                    if (ast.parent.right === ast) {
+                        ast = ast.parent;
+                    }
+                }
+            }
+
+            return {
+                ast: ast,
+                enclosingDecl: enclosingDecl,
+                resolutionContext: resolutionContext,
+                inContextuallyTypedAssignment: inContextuallyTypedAssignment,
+                inWithBlock: inWithBlock
+            };
+        };
+
+        TypeScriptCompiler.prototype.extractResolutionContextForVariable = function (inContextuallyTypedAssignment, propagateContextualTypes, resolver, resolutionContext, enclosingDecl, assigningAST, init) {
+            if (inContextuallyTypedAssignment) {
+                if (propagateContextualTypes) {
+                    resolver.resolveAST(assigningAST, false, resolutionContext);
+                    var varSymbol = this.semanticInfoChain.getSymbolForAST(assigningAST);
+
+                    var contextualType = null;
+                    if (varSymbol && inContextuallyTypedAssignment) {
+                        contextualType = varSymbol.type;
+                    }
+
+                    resolutionContext.pushNewContextualType(contextualType);
+
+                    if (init) {
+                        resolver.resolveAST(init, inContextuallyTypedAssignment, resolutionContext);
+                    }
+                }
+            }
+        };
+
+        TypeScriptCompiler.prototype.getASTPath = function (ast) {
+            var result = [];
+
+            while (ast) {
+                result.unshift(ast);
+                ast = ast.parent;
+            }
+
+            return result;
+        };
+
+        TypeScriptCompiler.prototype.pullGetSymbolInformationFromAST = function (ast, document) {
+            var resolver = this.semanticInfoChain.getResolver();
+            var context = this.extractResolutionContextFromAST(resolver, ast, document, true);
+            if (!context || context.inWithBlock) {
+                return null;
+            }
+
+            ast = context.ast;
+            var symbol = resolver.resolveAST(ast, context.inContextuallyTypedAssignment, context.resolutionContext);
+
+            if (!symbol) {
+                TypeScript.Debug.assert(ast.kind() === 120 /* SourceUnit */, "No symbol was found for ast and ast was not source unit. Ast Kind: " + TypeScript.SyntaxKind[ast.kind()]);
+                return null;
+            }
+
+            if (symbol.isTypeReference()) {
+                symbol = symbol.getReferencedTypeSymbol();
+            }
+
+            var aliasSymbol = this.semanticInfoChain.getAliasSymbolForAST(ast);
+
+            return {
+                symbol: symbol,
+                aliasSymbol: aliasSymbol,
+                ast: ast,
+                enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl)
+            };
+        };
+
+        TypeScriptCompiler.prototype.pullGetCallInformationFromAST = function (ast, document) {
+            if (ast.kind() !== 213 /* InvocationExpression */ && ast.kind() !== 216 /* ObjectCreationExpression */) {
+                return null;
+            }
+
+            var isNew = ast.kind() === 216 /* ObjectCreationExpression */;
+
+            var resolver = this.semanticInfoChain.getResolver();
+            var context = this.extractResolutionContextFromAST(resolver, ast, document, true);
+            if (!context || context.inWithBlock) {
+                return null;
+            }
+
+            var callResolutionResults = new TypeScript.PullAdditionalCallResolutionData();
+
+            if (isNew) {
+                resolver.resolveObjectCreationExpression(ast, context.resolutionContext, callResolutionResults);
+            } else {
+                resolver.resolveInvocationExpression(ast, context.resolutionContext, callResolutionResults);
+            }
+
+            return {
+                targetSymbol: callResolutionResults.targetSymbol,
+                resolvedSignatures: callResolutionResults.resolvedSignatures,
+                candidateSignature: callResolutionResults.candidateSignature,
+                ast: ast,
+                enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl),
+                isConstructorCall: isNew
+            };
+        };
+
+        TypeScriptCompiler.prototype.pullGetVisibleMemberSymbolsFromAST = function (ast, document) {
+            var resolver = this.semanticInfoChain.getResolver();
+            var context = this.extractResolutionContextFromAST(resolver, ast, document, true);
+            if (!context || context.inWithBlock) {
+                return null;
+            }
+
+            var symbols = resolver.getVisibleMembersFromExpression(ast, context.enclosingDecl, context.resolutionContext);
+            if (!symbols) {
+                return null;
+            }
+
+            return {
+                symbols: symbols,
+                enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl)
+            };
+        };
+
+        TypeScriptCompiler.prototype.pullGetVisibleDeclsFromAST = function (ast, document) {
+            var resolver = this.semanticInfoChain.getResolver();
+            var context = this.extractResolutionContextFromAST(resolver, ast, document, false);
+            if (!context || context.inWithBlock) {
+                return null;
+            }
+
+            return resolver.getVisibleDecls(context.enclosingDecl);
+        };
+
+        TypeScriptCompiler.prototype.pullGetContextualMembersFromAST = function (ast, document) {
+            if (ast.kind() !== 215 /* ObjectLiteralExpression */) {
+                return null;
+            }
+
+            var resolver = this.semanticInfoChain.getResolver();
+            var context = this.extractResolutionContextFromAST(resolver, ast, document, true);
+            if (!context || context.inWithBlock) {
+                return null;
+            }
+
+            var members = resolver.getVisibleContextSymbols(context.enclosingDecl, context.resolutionContext);
+
+            return {
+                symbols: members,
+                enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl)
+            };
+        };
+
+        TypeScriptCompiler.prototype.pullGetDeclInformation = function (decl, ast, document) {
+            var resolver = this.semanticInfoChain.getResolver();
+
+            var context = this.extractResolutionContextFromAST(resolver, ast, document, true);
+            if (!context || context.inWithBlock) {
+                return null;
+            }
+
+            var astForDecl = decl.ast();
+            if (!astForDecl) {
+                return null;
+            }
+
+            var astForDeclContext = this.extractResolutionContextFromAST(resolver, astForDecl, this.getDocument(astForDecl.fileName()), true);
+            if (!astForDeclContext) {
+                return null;
+            }
+
+            var symbol = decl.getSymbol();
+            resolver.resolveDeclaredSymbol(symbol, context.resolutionContext);
+            symbol.setUnresolved();
+
+            return {
+                symbol: symbol,
+                aliasSymbol: null,
+                ast: ast,
+                enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl)
+            };
+        };
+
+        TypeScriptCompiler.prototype.topLevelDeclaration = function (fileName) {
+            return this.semanticInfoChain.topLevelDecl(fileName);
+        };
+
+        TypeScriptCompiler.prototype.getDeclForAST = function (ast) {
+            return this.semanticInfoChain.getDeclForAST(ast);
+        };
+
+        TypeScriptCompiler.prototype.fileNames = function () {
+            return this.semanticInfoChain.fileNames();
+        };
+
+        TypeScriptCompiler.prototype.topLevelDecl = function (fileName) {
+            return this.semanticInfoChain.topLevelDecl(fileName);
+        };
+
+        TypeScriptCompiler.getLocationText = function (location) {
+            return location.fileName() + "(" + (location.line() + 1) + "," + (location.character() + 1) + ")";
+        };
+
+        TypeScriptCompiler.getFullDiagnosticText = function (diagnostic) {
+            var result = "";
+            if (diagnostic.fileName()) {
+                result += this.getLocationText(diagnostic) + ": ";
+            }
+
+            result += diagnostic.message();
+
+            var additionalLocations = diagnostic.additionalLocations();
+            if (additionalLocations.length > 0) {
+                result += " " + TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Additional_locations, null) + TypeScript.Environment.newLine;
+
+                for (var i = 0, n = additionalLocations.length; i < n; i++) {
+                    result += "\t" + this.getLocationText(additionalLocations[i]) + TypeScript.Environment.newLine;
+                }
+            } else {
+                result += TypeScript.Environment.newLine;
+            }
+
+            return result;
+        };
+        return TypeScriptCompiler;
+    })();
+    TypeScript.TypeScriptCompiler = TypeScriptCompiler;
+
+    var CompilerPhase;
+    (function (CompilerPhase) {
+        CompilerPhase[CompilerPhase["Syntax"] = 0] = "Syntax";
+        CompilerPhase[CompilerPhase["Semantics"] = 1] = "Semantics";
+        CompilerPhase[CompilerPhase["EmitOptionsValidation"] = 2] = "EmitOptionsValidation";
+        CompilerPhase[CompilerPhase["Emit"] = 3] = "Emit";
+        CompilerPhase[CompilerPhase["DeclarationEmit"] = 4] = "DeclarationEmit";
+    })(CompilerPhase || (CompilerPhase = {}));
+
+    var CompilerIterator = (function () {
+        function CompilerIterator(compiler, resolvePath, continueOnDiagnostics, startingPhase) {
+            if (typeof startingPhase === "undefined") { startingPhase = 0 /* Syntax */; }
+            this.compiler = compiler;
+            this.resolvePath = resolvePath;
+            this.continueOnDiagnostics = continueOnDiagnostics;
+            this.index = -1;
+            this.fileNames = null;
+            this._current = null;
+            this._emitOptions = null;
+            this._sharedEmitter = null;
+            this._sharedDeclarationEmitter = null;
+            this.hadSyntacticDiagnostics = false;
+            this.hadSemanticDiagnostics = false;
+            this.hadEmitDiagnostics = false;
+            this.fileNames = compiler.fileNames();
+            this.compilerPhase = startingPhase;
+        }
+        CompilerIterator.prototype.current = function () {
+            return this._current;
+        };
+
+        CompilerIterator.prototype.moveNext = function () {
+            this._current = null;
+
+            while (this.moveNextInternal()) {
+                if (this._current) {
+                    return true;
+                }
+            }
+
+            return false;
+        };
+
+        CompilerIterator.prototype.moveNextInternal = function () {
+            this.index++;
+
+            while (this.shouldMoveToNextPhase()) {
+                this.index = 0;
+                this.compilerPhase++;
+            }
+
+            if (this.compilerPhase > 4 /* DeclarationEmit */) {
+                return false;
+            }
+
+            switch (this.compilerPhase) {
+                case 0 /* Syntax */:
+                    return this.moveNextSyntaxPhase();
+                case 1 /* Semantics */:
+                    return this.moveNextSemanticsPhase();
+                case 2 /* EmitOptionsValidation */:
+                    return this.moveNextEmitOptionsValidationPhase();
+                case 3 /* Emit */:
+                    return this.moveNextEmitPhase();
+                case 4 /* DeclarationEmit */:
+                    return this.moveNextDeclarationEmitPhase();
+            }
+        };
+
+        CompilerIterator.prototype.shouldMoveToNextPhase = function () {
+            switch (this.compilerPhase) {
+                case 2 /* EmitOptionsValidation */:
+                    return this.index === 1;
+
+                case 0 /* Syntax */:
+                case 1 /* Semantics */:
+                    return this.index === this.fileNames.length;
+
+                case 3 /* Emit */:
+                case 4 /* DeclarationEmit */:
+                    return this.index === (this.fileNames.length + 1);
+            }
+
+            return false;
+        };
+
+        CompilerIterator.prototype.moveNextSyntaxPhase = function () {
+            TypeScript.Debug.assert(this.index >= 0 && this.index < this.fileNames.length);
+            var fileName = this.fileNames[this.index];
+
+            var diagnostics = this.compiler.getSyntacticDiagnostics(fileName);
+            if (diagnostics.length) {
+                if (!this.continueOnDiagnostics) {
+                    this.hadSyntacticDiagnostics = true;
+                }
+
+                this._current = CompileResult.fromDiagnostics(diagnostics);
+            }
+
+            return true;
+        };
+
+        CompilerIterator.prototype.moveNextSemanticsPhase = function () {
+            if (this.hadSyntacticDiagnostics) {
+                return false;
+            }
+
+            TypeScript.Debug.assert(this.index >= 0 && this.index < this.fileNames.length);
+            var fileName = this.fileNames[this.index];
+            var diagnostics = this.compiler.getSemanticDiagnostics(fileName);
+            if (diagnostics.length) {
+                if (!this.continueOnDiagnostics) {
+                    this.hadSemanticDiagnostics = true;
+                }
+
+                this._current = CompileResult.fromDiagnostics(diagnostics);
+            }
+
+            return true;
+        };
+
+        CompilerIterator.prototype.moveNextEmitOptionsValidationPhase = function () {
+            TypeScript.Debug.assert(!this.hadSyntacticDiagnostics);
+
+            if (!this._emitOptions) {
+                this._emitOptions = new TypeScript.EmitOptions(this.compiler, this.resolvePath);
+            }
+
+            if (this._emitOptions.diagnostic()) {
+                if (!this.continueOnDiagnostics) {
+                    this.hadEmitDiagnostics = true;
+                }
+
+                this._current = CompileResult.fromDiagnostics([this._emitOptions.diagnostic()]);
+            }
+
+            return true;
+        };
+
+        CompilerIterator.prototype.moveNextEmitPhase = function () {
+            var _this = this;
+            TypeScript.Debug.assert(!this.hadSyntacticDiagnostics);
+            TypeScript.Debug.assert(this._emitOptions);
+
+            if (this.hadEmitDiagnostics) {
+                return false;
+            }
+
+            TypeScript.Debug.assert(this.index >= 0 && this.index <= this.fileNames.length);
+            if (this.index < this.fileNames.length) {
+                var fileName = this.fileNames[this.index];
+                var document = this.compiler.getDocument(fileName);
+
+                this._sharedEmitter = this.compiler._emitDocument(document, this._emitOptions, function (outputFiles) {
+                    _this._current = CompileResult.fromOutputFiles(outputFiles);
+                }, this._sharedEmitter);
+                return true;
+            }
+
+            if (this.index === this.fileNames.length && this._sharedEmitter) {
+                this._current = CompileResult.fromOutputFiles(this._sharedEmitter.getOutputFiles());
+            }
+
+            return true;
+        };
+
+        CompilerIterator.prototype.moveNextDeclarationEmitPhase = function () {
+            var _this = this;
+            TypeScript.Debug.assert(!this.hadSyntacticDiagnostics);
+            TypeScript.Debug.assert(!this.hadEmitDiagnostics);
+            if (this.hadSemanticDiagnostics) {
+                return false;
+            }
+
+            if (!this.compiler.compilationSettings().generateDeclarationFiles()) {
+                return false;
+            }
+
+            TypeScript.Debug.assert(this.index >= 0 && this.index <= this.fileNames.length);
+            if (this.index < this.fileNames.length) {
+                var fileName = this.fileNames[this.index];
+                var document = this.compiler.getDocument(fileName);
+
+                this._sharedDeclarationEmitter = this.compiler._emitDocumentDeclarations(document, this._emitOptions, function (file) {
+                    _this._current = CompileResult.fromOutputFiles([file]);
+                }, this._sharedDeclarationEmitter);
+                return true;
+            }
+
+            if (this.index === this.fileNames.length && this._sharedDeclarationEmitter) {
+                this._current = CompileResult.fromOutputFiles([this._sharedDeclarationEmitter.getOutputFile()]);
+            }
+
+            return true;
+        };
+        return CompilerIterator;
+    })();
+
+    function compareDataObjects(dst, src) {
+        for (var e in dst) {
+            if (typeof dst[e] === "object") {
+                if (!compareDataObjects(dst[e], src[e]))
+                    return false;
+            } else if (typeof dst[e] !== "function") {
+                if (dst[e] !== src[e])
+                    return false;
+            }
+        }
+        return true;
+    }
+    TypeScript.compareDataObjects = compareDataObjects;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    (function (GenerativeTypeClassification) {
+        GenerativeTypeClassification[GenerativeTypeClassification["Unknown"] = 0] = "Unknown";
+        GenerativeTypeClassification[GenerativeTypeClassification["Open"] = 1] = "Open";
+        GenerativeTypeClassification[GenerativeTypeClassification["Closed"] = 2] = "Closed";
+        GenerativeTypeClassification[GenerativeTypeClassification["InfinitelyExpanding"] = 3] = "InfinitelyExpanding";
+    })(TypeScript.GenerativeTypeClassification || (TypeScript.GenerativeTypeClassification = {}));
+    var GenerativeTypeClassification = TypeScript.GenerativeTypeClassification;
+
+    var PullTypeReferenceSymbol = (function (_super) {
+        __extends(PullTypeReferenceSymbol, _super);
+        function PullTypeReferenceSymbol(referencedTypeSymbol) {
+            _super.call(this, referencedTypeSymbol.name, referencedTypeSymbol.kind);
+            this.referencedTypeSymbol = referencedTypeSymbol;
+            this.isResolved = true;
+
+            TypeScript.Debug.assert(referencedTypeSymbol !== null, "Type root symbol may not be null");
+
+            this.setRootSymbol(referencedTypeSymbol);
+
+            this.typeReference = this;
+        }
+        PullTypeReferenceSymbol.createTypeReference = function (type) {
+            if (type.isTypeReference()) {
+                return type;
+            }
+
+            var typeReference = type.typeReference;
+
+            if (!typeReference) {
+                typeReference = new PullTypeReferenceSymbol(type);
+                type.typeReference = typeReference;
+            }
+
+            return typeReference;
+        };
+
+        PullTypeReferenceSymbol.prototype.isTypeReference = function () {
+            return true;
+        };
+
+        PullTypeReferenceSymbol.prototype.setResolved = function () {
+        };
+
+        PullTypeReferenceSymbol.prototype.setUnresolved = function () {
+        };
+        PullTypeReferenceSymbol.prototype.invalidate = function () {
+        };
+
+        PullTypeReferenceSymbol.prototype.ensureReferencedTypeIsResolved = function () {
+            this._getResolver().resolveDeclaredSymbol(this.referencedTypeSymbol);
+        };
+
+        PullTypeReferenceSymbol.prototype.getReferencedTypeSymbol = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol;
+        };
+
+        PullTypeReferenceSymbol.prototype._getResolver = function () {
+            return this.referencedTypeSymbol._getResolver();
+        };
+
+        PullTypeReferenceSymbol.prototype.hasMembers = function () {
+            return this.referencedTypeSymbol.hasMembers();
+        };
+
+        PullTypeReferenceSymbol.prototype.setAssociatedContainerType = function (type) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": setAssociatedContainerType");
+        };
+
+        PullTypeReferenceSymbol.prototype.getAssociatedContainerType = function () {
+            return this.referencedTypeSymbol.getAssociatedContainerType();
+        };
+
+        PullTypeReferenceSymbol.prototype.getFunctionSymbol = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.getFunctionSymbol();
+        };
+        PullTypeReferenceSymbol.prototype.setFunctionSymbol = function (symbol) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": setFunctionSymbol");
+        };
+
+        PullTypeReferenceSymbol.prototype.addContainedNonMember = function (nonMember) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addContainedNonMember");
+        };
+        PullTypeReferenceSymbol.prototype.findContainedNonMemberContainer = function (containerName, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.findContainedNonMemberContainer(containerName, kind);
+        };
+
+        PullTypeReferenceSymbol.prototype.addMember = function (memberSymbol) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addMember");
+        };
+        PullTypeReferenceSymbol.prototype.addEnclosedMemberType = function (enclosedType) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedMemberType");
+        };
+        PullTypeReferenceSymbol.prototype.addEnclosedMemberContainer = function (enclosedContainer) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedMemberContainer");
+        };
+        PullTypeReferenceSymbol.prototype.addEnclosedNonMember = function (enclosedNonMember) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedNonMember");
+        };
+        PullTypeReferenceSymbol.prototype.addEnclosedNonMemberType = function (enclosedNonMemberType) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedNonMemberType");
+        };
+        PullTypeReferenceSymbol.prototype.addEnclosedNonMemberContainer = function (enclosedNonMemberContainer) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedNonMemberContainer");
+        };
+        PullTypeReferenceSymbol.prototype.addTypeParameter = function (typeParameter) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addTypeParameter");
+        };
+        PullTypeReferenceSymbol.prototype.addConstructorTypeParameter = function (typeParameter) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addConstructorTypeParameter");
+        };
+
+        PullTypeReferenceSymbol.prototype.findContainedNonMember = function (name) {
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.findContainedNonMember(name);
+        };
+
+        PullTypeReferenceSymbol.prototype.findContainedNonMemberType = function (typeName, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.findContainedNonMemberType(typeName, kind);
+        };
+
+        PullTypeReferenceSymbol.prototype.getMembers = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.getMembers();
+        };
+
+        PullTypeReferenceSymbol.prototype.setHasDefaultConstructor = function (hasOne) {
+            if (typeof hasOne === "undefined") { hasOne = true; }
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ":setHasDefaultConstructor");
+        };
+        PullTypeReferenceSymbol.prototype.getHasDefaultConstructor = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getHasDefaultConstructor();
+        };
+        PullTypeReferenceSymbol.prototype.getConstructorMethod = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getConstructorMethod();
+        };
+        PullTypeReferenceSymbol.prototype.setConstructorMethod = function (constructorMethod) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": setConstructorMethod");
+        };
+        PullTypeReferenceSymbol.prototype.getTypeParameters = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getTypeParameters();
+        };
+
+        PullTypeReferenceSymbol.prototype.isGeneric = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.isGeneric();
+        };
+
+        PullTypeReferenceSymbol.prototype.addSpecialization = function (specializedVersionOfThisType, substitutingTypes) {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.addSpecialization(specializedVersionOfThisType, substitutingTypes);
+        };
+        PullTypeReferenceSymbol.prototype.getSpecialization = function (substitutingTypes) {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getSpecialization(substitutingTypes);
+        };
+        PullTypeReferenceSymbol.prototype.getKnownSpecializations = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getKnownSpecializations();
+        };
+        PullTypeReferenceSymbol.prototype.getTypeArguments = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getTypeArguments();
+        };
+        PullTypeReferenceSymbol.prototype.getTypeArgumentsOrTypeParameters = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getTypeArgumentsOrTypeParameters();
+        };
+
+        PullTypeReferenceSymbol.prototype.appendCallSignature = function (callSignature) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": appendCallSignature");
+        };
+        PullTypeReferenceSymbol.prototype.insertCallSignatureAtIndex = function (callSignature, index) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": insertCallSignatureAtIndex");
+        };
+        PullTypeReferenceSymbol.prototype.appendConstructSignature = function (callSignature) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": appendConstructSignature");
+        };
+        PullTypeReferenceSymbol.prototype.insertConstructSignatureAtIndex = function (callSignature, index) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": insertConstructSignatureAtIndex");
+        };
+        PullTypeReferenceSymbol.prototype.addIndexSignature = function (indexSignature) {
+            TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addIndexSignature");
+        };
+
+        PullTypeReferenceSymbol.prototype.hasOwnCallSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.hasOwnCallSignatures();
+        };
+        PullTypeReferenceSymbol.prototype.getCallSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getCallSignatures();
+        };
+        PullTypeReferenceSymbol.prototype.hasOwnConstructSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.hasOwnConstructSignatures();
+        };
+        PullTypeReferenceSymbol.prototype.getConstructSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getConstructSignatures();
+        };
+        PullTypeReferenceSymbol.prototype.hasOwnIndexSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.hasOwnIndexSignatures();
+        };
+        PullTypeReferenceSymbol.prototype.getIndexSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getIndexSignatures();
+        };
+
+        PullTypeReferenceSymbol.prototype.addImplementedType = function (implementedType) {
+            this.referencedTypeSymbol.addImplementedType(implementedType);
+        };
+        PullTypeReferenceSymbol.prototype.getImplementedTypes = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getImplementedTypes();
+        };
+        PullTypeReferenceSymbol.prototype.addExtendedType = function (extendedType) {
+            this.referencedTypeSymbol.addExtendedType(extendedType);
+        };
+        PullTypeReferenceSymbol.prototype.getExtendedTypes = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getExtendedTypes();
+        };
+        PullTypeReferenceSymbol.prototype.addTypeThatExtendsThisType = function (type) {
+            this.referencedTypeSymbol.addTypeThatExtendsThisType(type);
+        };
+        PullTypeReferenceSymbol.prototype.getTypesThatExtendThisType = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getTypesThatExtendThisType();
+        };
+        PullTypeReferenceSymbol.prototype.addTypeThatExplicitlyImplementsThisType = function (type) {
+            this.referencedTypeSymbol.addTypeThatExplicitlyImplementsThisType(type);
+        };
+        PullTypeReferenceSymbol.prototype.getTypesThatExplicitlyImplementThisType = function () {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.getTypesThatExplicitlyImplementThisType();
+        };
+
+        PullTypeReferenceSymbol.prototype.isValidBaseKind = function (baseType, isExtendedType) {
+            this.ensureReferencedTypeIsResolved();
+            return this.referencedTypeSymbol.isValidBaseKind(baseType, isExtendedType);
+        };
+
+        PullTypeReferenceSymbol.prototype.findMember = function (name, lookInParent) {
+            if (typeof lookInParent === "undefined") { lookInParent = true; }
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.findMember(name, lookInParent);
+        };
+        PullTypeReferenceSymbol.prototype.findNestedType = function (name, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.findNestedType(name, kind);
+        };
+        PullTypeReferenceSymbol.prototype.findNestedContainer = function (name, kind) {
+            if (typeof kind === "undefined") { kind = 0 /* None */; }
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.findNestedContainer(name, kind);
+        };
+        PullTypeReferenceSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisiblity) {
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.getAllMembers(searchDeclKind, memberVisiblity);
+        };
+
+        PullTypeReferenceSymbol.prototype.findTypeParameter = function (name) {
+            this.ensureReferencedTypeIsResolved();
+
+            return this.referencedTypeSymbol.findTypeParameter(name);
+        };
+
+        PullTypeReferenceSymbol.prototype.hasOnlyOverloadCallSignatures = function () {
+            return this.referencedTypeSymbol.hasOnlyOverloadCallSignatures();
+        };
+        return PullTypeReferenceSymbol;
+    })(TypeScript.PullTypeSymbol);
+    TypeScript.PullTypeReferenceSymbol = PullTypeReferenceSymbol;
+
+    TypeScript.nSpecializationsCreated = 0;
+    TypeScript.nSpecializedSignaturesCreated = 0;
+    TypeScript.nSpecializedTypeParameterCreated = 0;
+
+    var PullInstantiatedTypeReferenceSymbol = (function (_super) {
+        __extends(PullInstantiatedTypeReferenceSymbol, _super);
+        function PullInstantiatedTypeReferenceSymbol(referencedTypeSymbol, _typeParameterArgumentMap, isInstanceReferenceType) {
+            _super.call(this, referencedTypeSymbol);
+            this.referencedTypeSymbol = referencedTypeSymbol;
+            this._typeParameterArgumentMap = _typeParameterArgumentMap;
+            this.isInstanceReferenceType = isInstanceReferenceType;
+            this._instantiatedMembers = null;
+            this._allInstantiatedMemberNameCache = null;
+            this._instantiatedMemberNameCache = TypeScript.createIntrinsicsObject();
+            this._instantiatedCallSignatures = null;
+            this._instantiatedConstructSignatures = null;
+            this._instantiatedIndexSignatures = null;
+            this._typeArgumentReferences = undefined;
+            this._instantiatedConstructorMethod = null;
+            this._instantiatedAssociatedContainerType = null;
+            this._isArray = undefined;
+            this._generativeTypeClassification = [];
+
+            TypeScript.nSpecializationsCreated++;
+        }
+        PullInstantiatedTypeReferenceSymbol.prototype.getIsSpecialized = function () {
+            return !this.isInstanceReferenceType;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getGenerativeTypeClassification = function (enclosingType) {
+            if (!this.isNamedTypeSymbol()) {
+                return 0 /* Unknown */;
+            }
+
+            var generativeTypeClassification = this._generativeTypeClassification[enclosingType.pullSymbolID] || 0 /* Unknown */;
+            if (generativeTypeClassification === 0 /* Unknown */) {
+                var typeParameters = enclosingType.getTypeParameters();
+                var enclosingTypeParameterMap = [];
+                for (var i = 0; i < typeParameters.length; i++) {
+                    enclosingTypeParameterMap[typeParameters[i].pullSymbolID] = typeParameters[i];
+                }
+
+                var typeArguments = this.getTypeArguments();
+                for (var i = 0; i < typeArguments.length; i++) {
+                    if (typeArguments[i].wrapsSomeTypeParameter(enclosingTypeParameterMap, true)) {
+                        generativeTypeClassification = 1 /* Open */;
+                        break;
+                    }
+                }
+
+                if (generativeTypeClassification === 1 /* Open */) {
+                    if (this.wrapsSomeTypeParameterIntoInfinitelyExpandingTypeReference(enclosingType)) {
+                        generativeTypeClassification = 3 /* InfinitelyExpanding */;
+                    }
+                } else {
+                    generativeTypeClassification = 2 /* Closed */;
+                }
+
+                this._generativeTypeClassification[enclosingType.pullSymbolID] = generativeTypeClassification;
+            }
+
+            return generativeTypeClassification;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.isArrayNamedTypeReference = function () {
+            if (this._isArray === undefined) {
+                this._isArray = this.getRootSymbol().isArrayNamedTypeReference() || (this.getRootSymbol() === this._getResolver().getArrayNamedType());
+            }
+            return this._isArray;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getElementType = function () {
+            if (!this.isArrayNamedTypeReference()) {
+                return null;
+            }
+
+            var typeArguments = this.getTypeArguments();
+            return typeArguments ? typeArguments[0] : null;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getReferencedTypeSymbol = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            if (this.getIsSpecialized()) {
+                return this;
+            }
+
+            return this.referencedTypeSymbol;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.create = function (resolver, type, typeParameterArgumentMap) {
+            TypeScript.Debug.assert(resolver);
+
+            var mutableTypeParameterMap = new TypeScript.PullInstantiationHelpers.MutableTypeArgumentMap(typeParameterArgumentMap);
+
+            TypeScript.PullInstantiationHelpers.instantiateTypeArgument(resolver, type, mutableTypeParameterMap);
+
+            var rootType = type.getRootSymbol();
+            var instantiation = rootType.getSpecialization(mutableTypeParameterMap.typeParameterArgumentMap);
+            if (instantiation) {
+                return instantiation;
+            }
+
+            TypeScript.PullInstantiationHelpers.cleanUpTypeArgumentMap(type, mutableTypeParameterMap);
+            typeParameterArgumentMap = mutableTypeParameterMap.typeParameterArgumentMap;
+
+            var isInstanceReferenceType = (type.kind & 8216 /* SomeInstantiatableType */) != 0;
+            var resolvedTypeParameterArgumentMap = typeParameterArgumentMap;
+            if (isInstanceReferenceType) {
+                var typeParameters = rootType.getTypeParameters();
+                for (var i = 0; i < typeParameters.length; i++) {
+                    if (!TypeScript.PullHelpers.typeSymbolsAreIdentical(typeParameters[i], typeParameterArgumentMap[typeParameters[i].pullSymbolID])) {
+                        isInstanceReferenceType = false;
+                        break;
+                    }
+                }
+
+                if (isInstanceReferenceType) {
+                    typeParameterArgumentMap = [];
+                }
+            }
+
+            instantiation = new PullInstantiatedTypeReferenceSymbol(rootType, typeParameterArgumentMap, isInstanceReferenceType);
+
+            rootType.addSpecialization(instantiation, resolvedTypeParameterArgumentMap);
+
+            return instantiation;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.isGeneric = function () {
+            return this.getRootSymbol().isGeneric();
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getTypeParameterArgumentMap = function () {
+            return this._typeParameterArgumentMap;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getTypeArguments = function () {
+            if (this.isInstanceReferenceType) {
+                return this.getTypeParameters();
+            }
+
+            if (this._typeArgumentReferences === undefined) {
+                var typeParameters = this.referencedTypeSymbol.getTypeParameters();
+
+                if (typeParameters.length) {
+                    var typeArgument = null;
+                    var typeArguments = [];
+
+                    for (var i = 0; i < typeParameters.length; i++) {
+                        typeArgument = this._typeParameterArgumentMap[typeParameters[i].pullSymbolID];
+
+                        if (!typeArgument) {
+                            TypeScript.Debug.fail("type argument count mismatch");
+                        }
+
+                        if (typeArgument) {
+                            typeArguments[typeArguments.length] = typeArgument;
+                        }
+                    }
+
+                    this._typeArgumentReferences = typeArguments;
+                } else {
+                    this._typeArgumentReferences = null;
+                }
+            }
+
+            return this._typeArgumentReferences;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getTypeArgumentsOrTypeParameters = function () {
+            return this.getTypeArguments();
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.populateInstantiatedMemberFromReferencedMember = function (referencedMember) {
+            var instantiatedMember;
+            TypeScript.PullHelpers.resolveDeclaredSymbolToUseType(referencedMember);
+
+            if (!referencedMember.type.wrapsSomeTypeParameter(this._typeParameterArgumentMap)) {
+                instantiatedMember = referencedMember;
+            } else {
+                instantiatedMember = new TypeScript.PullSymbol(referencedMember.name, referencedMember.kind);
+                instantiatedMember.setRootSymbol(referencedMember);
+                instantiatedMember.type = this._getResolver().instantiateType(referencedMember.type, this._typeParameterArgumentMap);
+                instantiatedMember.isOptional = referencedMember.isOptional;
+            }
+            this._instantiatedMemberNameCache[instantiatedMember.name] = instantiatedMember;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getMembers = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            if (this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.getMembers();
+            }
+
+            if (!this._instantiatedMembers) {
+                var referencedMembers = this.referencedTypeSymbol.getMembers();
+                var referencedMember = null;
+                var instantiatedMember = null;
+
+                this._instantiatedMembers = [];
+
+                for (var i = 0; i < referencedMembers.length; i++) {
+                    referencedMember = referencedMembers[i];
+
+                    this._getResolver().resolveDeclaredSymbol(referencedMember);
+
+                    if (!this._instantiatedMemberNameCache[referencedMember.name]) {
+                        this.populateInstantiatedMemberFromReferencedMember(referencedMember);
+                    }
+
+                    this._instantiatedMembers[this._instantiatedMembers.length] = this._instantiatedMemberNameCache[referencedMember.name];
+                }
+            }
+
+            return this._instantiatedMembers;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.findMember = function (name, lookInParent) {
+            if (typeof lookInParent === "undefined") { lookInParent = true; }
+            this.ensureReferencedTypeIsResolved();
+
+            if (this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.findMember(name, lookInParent);
+            }
+
+            var memberSymbol = this._instantiatedMemberNameCache[name];
+
+            if (!memberSymbol) {
+                var referencedMemberSymbol = this.referencedTypeSymbol.findMember(name, lookInParent);
+
+                if (referencedMemberSymbol) {
+                    this.populateInstantiatedMemberFromReferencedMember(referencedMemberSymbol);
+                    memberSymbol = this._instantiatedMemberNameCache[name];
+                } else {
+                    memberSymbol = null;
+                }
+            }
+
+            return memberSymbol;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisiblity) {
+            this.ensureReferencedTypeIsResolved();
+
+            if (this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.getAllMembers(searchDeclKind, memberVisiblity);
+            }
+
+            var requestedMembers = [];
+            var allReferencedMembers = this.referencedTypeSymbol.getAllMembers(searchDeclKind, memberVisiblity);
+
+            if (!this._allInstantiatedMemberNameCache) {
+                this._allInstantiatedMemberNameCache = TypeScript.createIntrinsicsObject();
+
+                var members = this.getMembers();
+
+                for (var i = 0; i < members.length; i++) {
+                    this._allInstantiatedMemberNameCache[members[i].name] = members[i];
+                }
+            }
+
+            var referencedMember = null;
+            var requestedMember = null;
+
+            for (var i = 0; i < allReferencedMembers.length; i++) {
+                referencedMember = allReferencedMembers[i];
+
+                this._getResolver().resolveDeclaredSymbol(referencedMember);
+
+                if (this._allInstantiatedMemberNameCache[referencedMember.name]) {
+                    requestedMembers[requestedMembers.length] = this._allInstantiatedMemberNameCache[referencedMember.name];
+                } else {
+                    if (!referencedMember.type.wrapsSomeTypeParameter(this._typeParameterArgumentMap)) {
+                        this._allInstantiatedMemberNameCache[referencedMember.name] = referencedMember;
+                        requestedMembers[requestedMembers.length] = referencedMember;
+                    } else {
+                        requestedMember = new TypeScript.PullSymbol(referencedMember.name, referencedMember.kind);
+                        requestedMember.setRootSymbol(referencedMember);
+
+                        requestedMember.type = this._getResolver().instantiateType(referencedMember.type, this._typeParameterArgumentMap);
+                        requestedMember.isOptional = referencedMember.isOptional;
+
+                        this._allInstantiatedMemberNameCache[requestedMember.name] = requestedMember;
+                        requestedMembers[requestedMembers.length] = requestedMember;
+                    }
+                }
+            }
+
+            return requestedMembers;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getConstructorMethod = function () {
+            if (this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.getConstructorMethod();
+            }
+
+            if (!this._instantiatedConstructorMethod) {
+                var referencedConstructorMethod = this.referencedTypeSymbol.getConstructorMethod();
+                this._instantiatedConstructorMethod = new TypeScript.PullSymbol(referencedConstructorMethod.name, referencedConstructorMethod.kind);
+                this._instantiatedConstructorMethod.setRootSymbol(referencedConstructorMethod);
+                this._instantiatedConstructorMethod.setResolved();
+
+                this._instantiatedConstructorMethod.type = PullInstantiatedTypeReferenceSymbol.create(this._getResolver(), referencedConstructorMethod.type, this._typeParameterArgumentMap);
+            }
+
+            return this._instantiatedConstructorMethod;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getAssociatedContainerType = function () {
+            if (!this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.getAssociatedContainerType();
+            }
+
+            if (!this._instantiatedAssociatedContainerType) {
+                var referencedAssociatedContainerType = this.referencedTypeSymbol.getAssociatedContainerType();
+
+                if (referencedAssociatedContainerType) {
+                    this._instantiatedAssociatedContainerType = PullInstantiatedTypeReferenceSymbol.create(this._getResolver(), referencedAssociatedContainerType, this._typeParameterArgumentMap);
+                }
+            }
+
+            return this._instantiatedAssociatedContainerType;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getCallSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            if (this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.getCallSignatures();
+            }
+
+            if (this._instantiatedCallSignatures) {
+                return this._instantiatedCallSignatures;
+            }
+
+            var referencedCallSignatures = this.referencedTypeSymbol.getCallSignatures();
+            this._instantiatedCallSignatures = [];
+
+            for (var i = 0; i < referencedCallSignatures.length; i++) {
+                this._getResolver().resolveDeclaredSymbol(referencedCallSignatures[i]);
+
+                if (!referencedCallSignatures[i].wrapsSomeTypeParameter(this._typeParameterArgumentMap)) {
+                    this._instantiatedCallSignatures[this._instantiatedCallSignatures.length] = referencedCallSignatures[i];
+                } else {
+                    this._instantiatedCallSignatures[this._instantiatedCallSignatures.length] = this._getResolver().instantiateSignature(referencedCallSignatures[i], this._typeParameterArgumentMap);
+                    this._instantiatedCallSignatures[this._instantiatedCallSignatures.length - 1].functionType = this;
+                }
+            }
+
+            return this._instantiatedCallSignatures;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getConstructSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            if (this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.getConstructSignatures();
+            }
+
+            if (this._instantiatedConstructSignatures) {
+                return this._instantiatedConstructSignatures;
+            }
+
+            var referencedConstructSignatures = this.referencedTypeSymbol.getConstructSignatures();
+            this._instantiatedConstructSignatures = [];
+
+            for (var i = 0; i < referencedConstructSignatures.length; i++) {
+                this._getResolver().resolveDeclaredSymbol(referencedConstructSignatures[i]);
+
+                if (!referencedConstructSignatures[i].wrapsSomeTypeParameter(this._typeParameterArgumentMap)) {
+                    this._instantiatedConstructSignatures[this._instantiatedConstructSignatures.length] = referencedConstructSignatures[i];
+                } else {
+                    this._instantiatedConstructSignatures[this._instantiatedConstructSignatures.length] = this._getResolver().instantiateSignature(referencedConstructSignatures[i], this._typeParameterArgumentMap);
+                    this._instantiatedConstructSignatures[this._instantiatedConstructSignatures.length - 1].functionType = this;
+                }
+            }
+
+            return this._instantiatedConstructSignatures;
+        };
+
+        PullInstantiatedTypeReferenceSymbol.prototype.getIndexSignatures = function () {
+            this.ensureReferencedTypeIsResolved();
+
+            if (this.isInstanceReferenceType) {
+                return this.referencedTypeSymbol.getIndexSignatures();
+            }
+
+            if (this._instantiatedIndexSignatures) {
+                return this._instantiatedIndexSignatures;
+            }
+
+            var referencedIndexSignatures = this.referencedTypeSymbol.getIndexSignatures();
+            this._instantiatedIndexSignatures = [];
+
+            for (var i = 0; i < referencedIndexSignatures.length; i++) {
+                this._getResolver().resolveDeclaredSymbol(referencedIndexSignatures[i]);
+
+                if (!referencedIndexSignatures[i].wrapsSomeTypeParameter(this._typeParameterArgumentMap)) {
+                    this._instantiatedIndexSignatures[this._instantiatedIndexSignatures.length] = referencedIndexSignatures[i];
+                } else {
+                    this._instantiatedIndexSignatures[this._instantiatedIndexSignatures.length] = this._getResolver().instantiateSignature(referencedIndexSignatures[i], this._typeParameterArgumentMap);
+                    this._instantiatedIndexSignatures[this._instantiatedIndexSignatures.length - 1].functionType = this;
+                }
+            }
+
+            return this._instantiatedIndexSignatures;
+        };
+        return PullInstantiatedTypeReferenceSymbol;
+    })(PullTypeReferenceSymbol);
+    TypeScript.PullInstantiatedTypeReferenceSymbol = PullInstantiatedTypeReferenceSymbol;
+
+    var PullInstantiatedSignatureSymbol = (function (_super) {
+        __extends(PullInstantiatedSignatureSymbol, _super);
+        function PullInstantiatedSignatureSymbol(rootSignature, _typeParameterArgumentMap) {
+            _super.call(this, rootSignature.kind, rootSignature.isDefinition());
+            this._typeParameterArgumentMap = _typeParameterArgumentMap;
+            this.setRootSymbol(rootSignature);
+            TypeScript.nSpecializedSignaturesCreated++;
+
+            rootSignature.addSpecialization(this, _typeParameterArgumentMap);
+        }
+        PullInstantiatedSignatureSymbol.prototype.getTypeParameterArgumentMap = function () {
+            return this._typeParameterArgumentMap;
+        };
+
+        PullInstantiatedSignatureSymbol.prototype.getIsSpecialized = function () {
+            return true;
+        };
+
+        PullInstantiatedSignatureSymbol.prototype._getResolver = function () {
+            return this.getRootSymbol()._getResolver();
+        };
+
+        PullInstantiatedSignatureSymbol.prototype.getTypeParameters = function () {
+            var _this = this;
+            if (!this._typeParameters) {
+                var rootSymbol = this.getRootSymbol();
+                var typeParameters = rootSymbol.getTypeParameters();
+                var hasInstantiatedTypeParametersOfThisSignature = TypeScript.ArrayUtilities.all(typeParameters, function (typeParameter) {
+                    return _this._typeParameterArgumentMap[typeParameter.pullSymbolID] !== undefined;
+                });
+
+                if (!hasInstantiatedTypeParametersOfThisSignature && typeParameters.length) {
+                    this._typeParameters = [];
+                    for (var i = 0; i < typeParameters.length; i++) {
+                        this._typeParameters[this._typeParameters.length] = this._getResolver().instantiateTypeParameter(typeParameters[i], this._typeParameterArgumentMap);
+                    }
+                } else {
+                    this._typeParameters = TypeScript.sentinelEmptyArray;
+                }
+            }
+
+            return this._typeParameters;
+        };
+
+        PullInstantiatedSignatureSymbol.prototype.getAllowedToReferenceTypeParameters = function () {
+            var rootSymbol = this.getRootSymbol();
+            return rootSymbol.getAllowedToReferenceTypeParameters();
+        };
+        return PullInstantiatedSignatureSymbol;
+    })(TypeScript.PullSignatureSymbol);
+    TypeScript.PullInstantiatedSignatureSymbol = PullInstantiatedSignatureSymbol;
+
+    var PullInstantiatedTypeParameterSymbol = (function (_super) {
+        __extends(PullInstantiatedTypeParameterSymbol, _super);
+        function PullInstantiatedTypeParameterSymbol(rootTypeParameter, constraintType) {
+            _super.call(this, rootTypeParameter.name);
+            TypeScript.nSpecializedTypeParameterCreated++;
+
+            this.setRootSymbol(rootTypeParameter);
+            this.setConstraint(constraintType);
+
+            rootTypeParameter.addSpecialization(this, [constraintType]);
+        }
+        PullInstantiatedTypeParameterSymbol.prototype._getResolver = function () {
+            return this.getRootSymbol()._getResolver();
+        };
+        return PullInstantiatedTypeParameterSymbol;
+    })(TypeScript.PullTypeParameterSymbol);
+    TypeScript.PullInstantiatedTypeParameterSymbol = PullInstantiatedTypeParameterSymbol;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var SyntaxTreeToAstVisitor = (function () {
+        function SyntaxTreeToAstVisitor(fileName, lineMap, compilationSettings) {
+            this.fileName = fileName;
+            this.lineMap = lineMap;
+            this.compilationSettings = compilationSettings;
+            this.position = 0;
+            this.previousTokenTrailingComments = null;
+        }
+        SyntaxTreeToAstVisitor.visit = function (syntaxTree, fileName, compilationSettings, incrementalAST) {
+            var visitor = incrementalAST ? new SyntaxTreeToIncrementalAstVisitor(fileName, syntaxTree.lineMap(), compilationSettings) : new SyntaxTreeToAstVisitor(fileName, syntaxTree.lineMap(), compilationSettings);
+            return syntaxTree.sourceUnit().accept(visitor);
+        };
+
+        SyntaxTreeToAstVisitor.prototype.movePast = function (element) {
+            if (element !== null) {
+                this.position += element.fullWidth();
+            }
+        };
+
+        SyntaxTreeToAstVisitor.prototype.moveTo = function (element1, element2) {
+            if (element2 !== null) {
+                this.position += TypeScript.Syntax.childOffset(element1, element2);
+            }
+        };
+
+        SyntaxTreeToAstVisitor.prototype.setCommentsAndSpan = function (ast, fullStart, node) {
+            var firstToken = node.firstToken();
+            var lastToken = node.lastToken();
+
+            this.setSpan(ast, fullStart, node, firstToken, lastToken);
+            ast.setPreComments(this.convertTokenLeadingComments(firstToken, fullStart));
+            ast.setPostComments(this.convertNodeTrailingComments(node, lastToken, fullStart));
+        };
+
+        SyntaxTreeToAstVisitor.prototype.createTokenSpan = function (fullStart, element) {
+            if (element === null) {
+                return null;
+            }
+
+            if (element.fullWidth() === 0) {
+                return new TypeScript.ASTSpan(-1, -1);
+            }
+
+            var leadingTriviaWidth = element.leadingTriviaWidth();
+            var trailingTriviaWidth = element.trailingTriviaWidth();
+
+            var start = fullStart + leadingTriviaWidth;
+            var end = fullStart + element.fullWidth() - trailingTriviaWidth;
+
+            return new TypeScript.ASTSpan(start, end);
+        };
+
+        SyntaxTreeToAstVisitor.prototype.setSpan = function (span, fullStart, element, firstToken, lastToken) {
+            if (typeof firstToken === "undefined") { firstToken = element.firstToken(); }
+            if (typeof lastToken === "undefined") { lastToken = element.lastToken(); }
+            var leadingTriviaWidth = firstToken ? firstToken.leadingTriviaWidth() : 0;
+            var trailingTriviaWidth = lastToken ? lastToken.trailingTriviaWidth() : 0;
+
+            var desiredMinChar = fullStart + leadingTriviaWidth;
+            var desiredLimChar = fullStart + element.fullWidth() - trailingTriviaWidth;
+
+            this.setSpanExplicit(span, desiredMinChar, desiredLimChar);
+
+            span._trailingTriviaWidth = trailingTriviaWidth;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.setSpanExplicit = function (span, start, end) {
+            span._start = start;
+            span._end = end;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitSyntaxList = function (node) {
+            var start = this.position;
+            var array = new Array(node.childCount());
+
+            for (var i = 0, n = node.childCount(); i < n; i++) {
+                array[i] = node.childAt(i).accept(this);
+            }
+
+            var result = new TypeScript.ISyntaxList2(this.fileName, array);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitSeparatedSyntaxList = function (list) {
+            var start = this.position;
+            var array = new Array(list.nonSeparatorCount());
+
+            for (var i = 0, n = list.childCount(); i < n; i++) {
+                if (i % 2 === 0) {
+                    array[i / 2] = list.childAt(i).accept(this);
+                    this.previousTokenTrailingComments = null;
+                } else {
+                    var separatorToken = list.childAt(i);
+                    this.previousTokenTrailingComments = this.convertTokenTrailingComments(separatorToken, this.position + separatorToken.leadingTriviaWidth() + separatorToken.width());
+                    this.movePast(separatorToken);
+                }
+            }
+
+            var result = new TypeScript.ISeparatedSyntaxList2(this.fileName, array, list.separatorCount());
+            this.setSpan(result, start, list);
+
+            result.setPostComments(this.previousTokenTrailingComments);
+            this.previousTokenTrailingComments = null;
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.convertComment = function (trivia, commentStartPosition, hasTrailingNewLine) {
+            var comment = new TypeScript.Comment(trivia, hasTrailingNewLine, commentStartPosition, commentStartPosition + trivia.fullWidth());
+
+            return comment;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.convertComments = function (triviaList, commentStartPosition) {
+            var result = [];
+
+            for (var i = 0, n = triviaList.count(); i < n; i++) {
+                var trivia = triviaList.syntaxTriviaAt(i);
+
+                if (trivia.isComment()) {
+                    var hasTrailingNewLine = ((i + 1) < n) && triviaList.syntaxTriviaAt(i + 1).isNewLine();
+                    result.push(this.convertComment(trivia, commentStartPosition, hasTrailingNewLine));
+                }
+
+                commentStartPosition += trivia.fullWidth();
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.mergeComments = function (comments1, comments2) {
+            if (comments1 === null) {
+                return comments2;
+            }
+
+            if (comments2 === null) {
+                return comments1;
+            }
+
+            return comments1.concat(comments2);
+        };
+
+        SyntaxTreeToAstVisitor.prototype.convertTokenLeadingComments = function (token, commentStartPosition) {
+            if (token === null) {
+                return null;
+            }
+
+            var preComments = token.hasLeadingComment() ? this.convertComments(token.leadingTrivia(), commentStartPosition) : null;
+
+            var previousTokenTrailingComments = this.previousTokenTrailingComments;
+            this.previousTokenTrailingComments = null;
+
+            return this.mergeComments(previousTokenTrailingComments, preComments);
+        };
+
+        SyntaxTreeToAstVisitor.prototype.convertTokenTrailingComments = function (token, commentStartPosition) {
+            if (token === null || !token.hasTrailingComment() || token.hasTrailingNewLine()) {
+                return null;
+            }
+
+            return this.convertComments(token.trailingTrivia(), commentStartPosition);
+        };
+
+        SyntaxTreeToAstVisitor.prototype.convertNodeTrailingComments = function (node, lastToken, nodeStart) {
+            if (lastToken === null || !lastToken.hasTrailingComment() || lastToken.hasTrailingNewLine()) {
+                return null;
+            }
+
+            return this.convertComments(lastToken.trailingTrivia(), nodeStart + node.fullWidth() - lastToken.trailingTriviaWidth());
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitIdentifier = function (token) {
+            return this.visitToken(token);
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitToken = function (token) {
+            var fullStart = this.position;
+
+            var result = this.visitTokenWorker(token);
+
+            this.movePast(token);
+
+            var start = fullStart + token.leadingTriviaWidth();
+            this.setSpanExplicit(result, start, start + token.width());
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTokenWorker = function (token) {
+            switch (token.tokenKind) {
+                case 60 /* AnyKeyword */:
+                    return new TypeScript.BuiltInType(60 /* AnyKeyword */, token.text(), token.valueText());
+                case 61 /* BooleanKeyword */:
+                    return new TypeScript.BuiltInType(61 /* BooleanKeyword */, token.text(), token.valueText());
+                case 67 /* NumberKeyword */:
+                    return new TypeScript.BuiltInType(67 /* NumberKeyword */, token.text(), token.valueText());
+                case 69 /* StringKeyword */:
+                    return new TypeScript.BuiltInType(69 /* StringKeyword */, token.text(), token.valueText());
+                case 41 /* VoidKeyword */:
+                    return new TypeScript.BuiltInType(41 /* VoidKeyword */, token.text(), token.valueText());
+                case 35 /* ThisKeyword */:
+                    return new TypeScript.ThisExpression(token.text(), token.valueText());
+                case 50 /* SuperKeyword */:
+                    return new TypeScript.SuperExpression(token.text(), token.valueText());
+                case 37 /* TrueKeyword */:
+                    return new TypeScript.LiteralExpression(37 /* TrueKeyword */, token.text(), token.valueText());
+                case 24 /* FalseKeyword */:
+                    return new TypeScript.LiteralExpression(24 /* FalseKeyword */, token.text(), token.valueText());
+                case 32 /* NullKeyword */:
+                    return new TypeScript.LiteralExpression(32 /* NullKeyword */, token.text(), token.valueText());
+                case 14 /* StringLiteral */:
+                    return new TypeScript.StringLiteral(token.text(), token.valueText());
+                case 12 /* RegularExpressionLiteral */:
+                    return new TypeScript.RegularExpressionLiteral(token.text(), token.valueText());
+                case 13 /* NumericLiteral */:
+                    var fullStart = this.position;
+                    var preComments = this.convertTokenLeadingComments(token, fullStart);
+
+                    var result = new TypeScript.NumericLiteral(token.value(), token.text(), token.valueText());
+
+                    result.setPreComments(preComments);
+                    return result;
+                case 11 /* IdentifierName */:
+                    return new TypeScript.Identifier(token.text());
+                default:
+                    throw TypeScript.Errors.invalidOperation();
+            }
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitSourceUnit = function (node) {
+            var start = this.position;
+            TypeScript.Debug.assert(start === 0);
+
+            var bod = this.visitSyntaxList(node.moduleElements);
+            var comments = this.convertTokenLeadingComments(node.endOfFileToken, TypeScript.Syntax.childOffset(node, node.endOfFileToken));
+            var result = new TypeScript.SourceUnit(bod, comments, this.fileName);
+            this.setSpanExplicit(result, start, start + node.fullWidth());
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitExternalModuleReference = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.stringLiteral);
+            var stringLiteral = node.stringLiteral.accept(this);
+            this.movePast(node.closeParenToken);
+
+            var result = new TypeScript.ExternalModuleReference(stringLiteral);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitModuleNameModuleReference = function (node) {
+            var start = this.position;
+            var moduleName = node.moduleName.accept(this);
+
+            var result = new TypeScript.ModuleNameModuleReference(moduleName);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitClassDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.identifier);
+            var name = this.visitIdentifier(node.identifier);
+
+            var typeParameters = this.visitTypeParameterList(node.typeParameterList);
+            var heritageClauses = node.heritageClauses ? this.visitSyntaxList(node.heritageClauses) : null;
+
+            this.movePast(node.openBraceToken);
+            var members = this.visitSyntaxList(node.classElements);
+
+            var closeBraceToken = this.createTokenSpan(this.position, node.closeBraceToken);
+            this.movePast(node.closeBraceToken);
+
+            var modifiers = this.visitModifiers(node.modifiers);
+            var result = new TypeScript.ClassDeclaration(modifiers, name, typeParameters, heritageClauses, members, closeBraceToken);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitModifiers = function (modifiers) {
+            var result = null;
+            if (TypeScript.SyntaxUtilities.containsToken(modifiers, 47 /* ExportKeyword */)) {
+                result = result || [];
+                result.push(1 /* Exported */);
+            }
+
+            if (TypeScript.SyntaxUtilities.containsToken(modifiers, 63 /* DeclareKeyword */)) {
+                result = result || [];
+                result.push(8 /* Ambient */);
+            }
+
+            if (TypeScript.SyntaxUtilities.containsToken(modifiers, 58 /* StaticKeyword */)) {
+                result = result || [];
+                result.push(16 /* Static */);
+            }
+
+            if (TypeScript.SyntaxUtilities.containsToken(modifiers, 57 /* PublicKeyword */)) {
+                result = result || [];
+                result.push(4 /* Public */);
+            }
+
+            if (TypeScript.SyntaxUtilities.containsToken(modifiers, 55 /* PrivateKeyword */)) {
+                result = result || [];
+                result.push(2 /* Private */);
+            }
+
+            return result || TypeScript.sentinelEmptyArray;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitInterfaceDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.identifier);
+            var name = this.visitIdentifier(node.identifier);
+            var typeParameters = this.visitTypeParameterList(node.typeParameterList);
+            var heritageClauses = node.heritageClauses ? this.visitSyntaxList(node.heritageClauses) : null;
+
+            var body = this.visitObjectType(node.body);
+
+            var modifiers = this.visitModifiers(node.modifiers);
+            var result = new TypeScript.InterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, body);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitHeritageClause = function (node) {
+            var start = this.position;
+
+            this.movePast(node.extendsOrImplementsKeyword);
+            var typeNames = this.visitSeparatedSyntaxList(node.typeNames);
+
+            var result = new TypeScript.HeritageClause(node.extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */ ? 230 /* ExtendsHeritageClause */ : 231 /* ImplementsHeritageClause */, typeNames);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitModuleDeclaration = function (node) {
+            var start = this.position;
+
+            var modifiers = this.visitModifiers(node.modifiers);
+
+            this.moveTo(node, node.moduleKeyword);
+            this.movePast(node.moduleKeyword);
+
+            var moduleName = node.name ? node.name.accept(this) : null;
+            var stringLiteral = node.stringLiteral ? node.stringLiteral.accept(this) : null;
+
+            this.movePast(node.openBraceToken);
+
+            var moduleElements = this.visitSyntaxList(node.moduleElements);
+
+            var closeBraceToken = this.createTokenSpan(this.position, node.closeBraceToken);
+            this.movePast(node.closeBraceToken);
+
+            var result = new TypeScript.ModuleDeclaration(modifiers, moduleName, stringLiteral, moduleElements, closeBraceToken);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitFunctionDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.identifier);
+            var name = this.visitIdentifier(node.identifier);
+
+            var callSignature = this.visitCallSignature(node.callSignature);
+            var block = node.block ? this.visitBlock(node.block) : null;
+
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.FunctionDeclaration(this.visitModifiers(node.modifiers), name, callSignature, block);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitEnumDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.identifier);
+            var identifier = this.visitIdentifier(node.identifier);
+
+            this.movePast(node.openBraceToken);
+
+            var enumElements = this.visitSeparatedSyntaxList(node.enumElements);
+
+            this.movePast(node.closeBraceToken);
+
+            var result = new TypeScript.EnumDeclaration(this.visitModifiers(node.modifiers), identifier, enumElements);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitEnumElement = function (node) {
+            var start = this.position;
+
+            var memberName = this.visitToken(node.propertyName);
+
+            var value = node.equalsValueClause !== null ? this.visitEqualsValueClause(node.equalsValueClause) : null;
+
+            var result = new TypeScript.EnumElement(memberName, value);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitImportDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.identifier);
+            var name = this.visitIdentifier(node.identifier);
+            this.movePast(node.equalsToken);
+            var alias = node.moduleReference.accept(this);
+            this.movePast(node.semicolonToken);
+
+            var modifiers = this.visitModifiers(node.modifiers);
+            var result = new TypeScript.ImportDeclaration(modifiers, name, alias);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitExportAssignment = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.identifier);
+            var name = this.visitIdentifier(node.identifier);
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.ExportAssignment(name);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitVariableStatement = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.variableDeclaration);
+
+            var declaration = node.variableDeclaration.accept(this);
+            this.movePast(node.semicolonToken);
+
+            var modifiers = this.visitModifiers(node.modifiers);
+
+            var result = new TypeScript.VariableStatement(modifiers, declaration);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitVariableDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.variableDeclarators);
+            var variableDecls = this.visitSeparatedSyntaxList(node.variableDeclarators);
+
+            var result = new TypeScript.VariableDeclaration(variableDecls);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitVariableDeclarator = function (node) {
+            var start = this.position;
+            var propertyName = this.visitToken(node.propertyName);
+            var typeExpr = this.visitTypeAnnotation(node.typeAnnotation);
+            var init = node.equalsValueClause ? this.visitEqualsValueClause(node.equalsValueClause) : null;
+
+            var result = new TypeScript.VariableDeclarator(propertyName, typeExpr, init);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitEqualsValueClause = function (node) {
+            var start = this.position;
+            var afterEqualsComments = this.convertTokenTrailingComments(node.equalsToken, this.position + node.equalsToken.leadingTriviaWidth() + node.equalsToken.width());
+
+            this.movePast(node.equalsToken);
+            var value = node.value.accept(this);
+            value.setPreComments(this.mergeComments(afterEqualsComments, value.preComments()));
+
+            var result = new TypeScript.EqualsValueClause(value);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitPrefixUnaryExpression = function (node) {
+            var start = this.position;
+
+            this.movePast(node.operatorToken);
+            var operand = node.operand.accept(this);
+
+            var result = new TypeScript.PrefixUnaryExpression(node.kind(), operand);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitArrayLiteralExpression = function (node) {
+            var start = this.position;
+            var openStart = this.position + node.openBracketToken.leadingTriviaWidth();
+            this.movePast(node.openBracketToken);
+
+            var expressions = this.visitSeparatedSyntaxList(node.expressions);
+
+            var closeStart = this.position + node.closeBracketToken.leadingTriviaWidth();
+            this.movePast(node.closeBracketToken);
+
+            var result = new TypeScript.ArrayLiteralExpression(expressions);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitOmittedExpression = function (node) {
+            var start = this.position;
+
+            var result = new TypeScript.OmittedExpression();
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitParenthesizedExpression = function (node) {
+            var start = this.position;
+
+            var openParenToken = node.openParenToken;
+            var openParenTrailingComments = this.convertTokenTrailingComments(openParenToken, start + openParenToken.leadingTriviaWidth() + openParenToken.width());
+
+            this.movePast(openParenToken);
+
+            var expr = node.expression.accept(this);
+            this.movePast(node.closeParenToken);
+
+            var result = new TypeScript.ParenthesizedExpression(openParenTrailingComments, expr);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitSimpleArrowFunctionExpression = function (node) {
+            var start = this.position;
+
+            var identifier = node.identifier.accept(this);
+            this.movePast(node.equalsGreaterThanToken);
+
+            var block = node.block ? this.visitBlock(node.block) : null;
+            var expression = node.expression ? node.expression.accept(this) : null;
+
+            var result = new TypeScript.SimpleArrowFunctionExpression(identifier, block, expression);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitParenthesizedArrowFunctionExpression = function (node) {
+            var start = this.position;
+
+            var callSignature = this.visitCallSignature(node.callSignature);
+            this.movePast(node.equalsGreaterThanToken);
+
+            var block = node.block ? this.visitBlock(node.block) : null;
+            var expression = node.expression ? node.expression.accept(this) : null;
+
+            var result = new TypeScript.ParenthesizedArrowFunctionExpression(callSignature, block, expression);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitType = function (type) {
+            return type ? type.accept(this) : null;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTypeQuery = function (node) {
+            var start = this.position;
+            this.movePast(node.typeOfKeyword);
+            var name = node.name.accept(this);
+
+            var result = new TypeScript.TypeQuery(name);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitQualifiedName = function (node) {
+            var start = this.position;
+            var left = this.visitType(node.left);
+            this.movePast(node.dotToken);
+            var right = this.visitIdentifier(node.right);
+
+            var result = new TypeScript.QualifiedName(left, right);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTypeArgumentList = function (node) {
+            if (node === null) {
+                return null;
+            }
+
+            var start = this.position;
+            this.movePast(node.lessThanToken);
+            var typeArguments = this.visitSeparatedSyntaxList(node.typeArguments);
+            this.movePast(node.greaterThanToken);
+
+            var result = new TypeScript.TypeArgumentList(typeArguments);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitConstructorType = function (node) {
+            var start = this.position;
+
+            this.movePast(node.newKeyword);
+            var typeParameters = this.visitTypeParameterList(node.typeParameterList);
+            var parameters = this.visitParameterList(node.parameterList);
+            this.movePast(node.equalsGreaterThanToken);
+            var returnType = this.visitType(node.type);
+
+            var result = new TypeScript.ConstructorType(typeParameters, parameters, returnType);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitFunctionType = function (node) {
+            var start = this.position;
+            var typeParameters = this.visitTypeParameterList(node.typeParameterList);
+            var parameters = this.visitParameterList(node.parameterList);
+            this.movePast(node.equalsGreaterThanToken);
+            var returnType = this.visitType(node.type);
+
+            var result = new TypeScript.FunctionType(typeParameters, parameters, returnType);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitObjectType = function (node) {
+            var start = this.position;
+
+            this.movePast(node.openBraceToken);
+            var typeMembers = this.visitSeparatedSyntaxList(node.typeMembers);
+            this.movePast(node.closeBraceToken);
+
+            var result = new TypeScript.ObjectType(typeMembers);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitArrayType = function (node) {
+            var start = this.position;
+
+            var underlying = this.visitType(node.type);
+            this.movePast(node.openBracketToken);
+            this.movePast(node.closeBracketToken);
+
+            var result = new TypeScript.ArrayType(underlying);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitGenericType = function (node) {
+            var start = this.position;
+
+            var underlying = this.visitType(node.name);
+            var typeArguments = this.visitTypeArgumentList(node.typeArgumentList);
+
+            var result = new TypeScript.GenericType(underlying, typeArguments);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTypeAnnotation = function (node) {
+            if (!node) {
+                return null;
+            }
+
+            var start = this.position;
+            this.movePast(node.colonToken);
+            var type = this.visitType(node.type);
+
+            var result = new TypeScript.TypeAnnotation(type);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitBlock = function (node) {
+            if (!node) {
+                return null;
+            }
+
+            var start = this.position;
+
+            this.movePast(node.openBraceToken);
+            var statements = this.visitSyntaxList(node.statements);
+            var closeBracePosition = this.position;
+
+            var closeBraceLeadingComments = this.convertTokenLeadingComments(node.closeBraceToken, this.position);
+            var closeBraceToken = this.createTokenSpan(this.position, node.closeBraceToken);
+            this.movePast(node.closeBraceToken);
+
+            var result = new TypeScript.Block(statements, closeBraceLeadingComments, closeBraceToken);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitParameter = function (node) {
+            var start = this.position;
+
+            var dotDotDotToken = this.createTokenSpan(this.position, node.dotDotDotToken);
+
+            this.moveTo(node, node.identifier);
+            var identifier = this.visitIdentifier(node.identifier);
+
+            var questionToken = this.createTokenSpan(this.position, node.questionToken);
+            this.movePast(node.questionToken);
+            var typeExpr = this.visitTypeAnnotation(node.typeAnnotation);
+            var init = node.equalsValueClause ? node.equalsValueClause.accept(this) : null;
+
+            var modifiers = this.visitModifiers(node.modifiers);
+
+            var result = new TypeScript.Parameter(dotDotDotToken, modifiers, identifier, questionToken, typeExpr, init);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitMemberAccessExpression = function (node) {
+            var start = this.position;
+
+            var expression = node.expression.accept(this);
+            this.movePast(node.dotToken);
+            var name = this.visitIdentifier(node.name);
+
+            var result = new TypeScript.MemberAccessExpression(expression, name);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitPostfixUnaryExpression = function (node) {
+            var start = this.position;
+
+            var operand = node.operand.accept(this);
+            this.movePast(node.operatorToken);
+
+            var result = new TypeScript.PostfixUnaryExpression(node.kind() === 210 /* PostIncrementExpression */ ? 210 /* PostIncrementExpression */ : 211 /* PostDecrementExpression */, operand);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitElementAccessExpression = function (node) {
+            var start = this.position;
+
+            var expression = node.expression.accept(this);
+            this.movePast(node.openBracketToken);
+            var argumentExpression = node.argumentExpression.accept(this);
+            this.movePast(node.closeBracketToken);
+
+            var result = new TypeScript.ElementAccessExpression(expression, argumentExpression);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitInvocationExpression = function (node) {
+            var start = this.position;
+
+            var expression = node.expression.accept(this);
+            var argumentList = this.visitArgumentList(node.argumentList);
+
+            var result = new TypeScript.InvocationExpression(expression, argumentList);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitArgumentList = function (node) {
+            if (node === null) {
+                return null;
+            }
+
+            var start = this.position;
+
+            var typeArguments = this.visitTypeArgumentList(node.typeArgumentList);
+
+            this.movePast(node.openParenToken);
+
+            var _arguments = this.visitSeparatedSyntaxList(node.arguments);
+
+            if (node.arguments.fullWidth() === 0 && node.closeParenToken.fullWidth() === 0) {
+                var openParenTokenEnd = start + node.openParenToken.leadingTriviaWidth() + node.openParenToken.width();
+                this.setSpanExplicit(_arguments, openParenTokenEnd, openParenTokenEnd + node.openParenToken.trailingTriviaWidth());
+            }
+
+            var closeParenToken = this.createTokenSpan(this.position, node.closeParenToken);
+            this.movePast(node.closeParenToken);
+
+            var result = new TypeScript.ArgumentList(typeArguments, _arguments, closeParenToken);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitBinaryExpression = function (node) {
+            var start = this.position;
+
+            var left = node.left.accept(this);
+            this.movePast(node.operatorToken);
+            var right = node.right.accept(this);
+
+            var result = new TypeScript.BinaryExpression(node.kind(), left, right);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitConditionalExpression = function (node) {
+            var start = this.position;
+
+            var condition = node.condition.accept(this);
+            this.movePast(node.questionToken);
+            var whenTrue = node.whenTrue.accept(this);
+            this.movePast(node.colonToken);
+            var whenFalse = node.whenFalse.accept(this);
+
+            var result = new TypeScript.ConditionalExpression(condition, whenTrue, whenFalse);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitConstructSignature = function (node) {
+            var start = this.position;
+
+            this.movePast(node.newKeyword);
+            var callSignature = this.visitCallSignature(node.callSignature);
+
+            var result = new TypeScript.ConstructSignature(callSignature);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitMethodSignature = function (node) {
+            var start = this.position;
+
+            var name = this.visitToken(node.propertyName);
+
+            var questionToken = this.createTokenSpan(this.position, node.questionToken);
+            this.movePast(node.questionToken);
+
+            var callSignature = this.visitCallSignature(node.callSignature);
+
+            var result = new TypeScript.MethodSignature(name, questionToken, callSignature);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitIndexSignature = function (node) {
+            var start = this.position;
+
+            this.movePast(node.openBracketToken);
+
+            var parameter = node.parameter.accept(this);
+
+            this.movePast(node.closeBracketToken);
+            var returnType = this.visitTypeAnnotation(node.typeAnnotation);
+
+            var result = new TypeScript.IndexSignature(parameter, returnType);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitPropertySignature = function (node) {
+            var start = this.position;
+
+            var name = this.visitToken(node.propertyName);
+
+            var questionToken = this.createTokenSpan(this.position, node.questionToken);
+            this.movePast(node.questionToken);
+            var typeExpr = this.visitTypeAnnotation(node.typeAnnotation);
+
+            var result = new TypeScript.PropertySignature(name, questionToken, typeExpr);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitParameterList = function (node) {
+            if (!node) {
+                return null;
+            }
+
+            var start = this.position;
+
+            var openParenToken = node.openParenToken;
+
+            this.previousTokenTrailingComments = this.convertTokenTrailingComments(openParenToken, start + openParenToken.leadingTriviaWidth() + openParenToken.width());
+            var openParenTrailingComments = null;
+            if (node.parameters.childCount() === 0) {
+                openParenTrailingComments = this.previousTokenTrailingComments;
+                this.previousTokenTrailingComments = null;
+            }
+
+            this.movePast(node.openParenToken);
+            var parameters = this.visitSeparatedSyntaxList(node.parameters);
+            this.movePast(node.closeParenToken);
+
+            var result = new TypeScript.ParameterList(openParenTrailingComments, parameters);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitCallSignature = function (node) {
+            var start = this.position;
+
+            var typeParameters = this.visitTypeParameterList(node.typeParameterList);
+            var parameters = this.visitParameterList(node.parameterList);
+            var returnType = this.visitTypeAnnotation(node.typeAnnotation);
+
+            var result = new TypeScript.CallSignature(typeParameters, parameters, returnType);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTypeParameterList = function (node) {
+            if (!node) {
+                return null;
+            }
+
+            var start = this.position;
+            this.movePast(node.lessThanToken);
+            var typeParameters = this.visitSeparatedSyntaxList(node.typeParameters);
+            this.movePast(node.greaterThanToken);
+
+            var result = new TypeScript.TypeParameterList(typeParameters);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTypeParameter = function (node) {
+            var start = this.position;
+
+            var identifier = this.visitIdentifier(node.identifier);
+            var constraint = node.constraint ? node.constraint.accept(this) : null;
+
+            var result = new TypeScript.TypeParameter(identifier, constraint);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitConstraint = function (node) {
+            var start = this.position;
+            this.movePast(node.extendsKeyword);
+            var type = this.visitType(node.type);
+
+            var result = new TypeScript.Constraint(type);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitIfStatement = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.condition);
+            var condition = node.condition.accept(this);
+            this.movePast(node.closeParenToken);
+            var thenBod = node.statement.accept(this);
+            var elseBod = node.elseClause ? node.elseClause.accept(this) : null;
+
+            var result = new TypeScript.IfStatement(condition, thenBod, elseBod);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitElseClause = function (node) {
+            var start = this.position;
+
+            this.movePast(node.elseKeyword);
+            var statement = node.statement.accept(this);
+
+            var result = new TypeScript.ElseClause(statement);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitExpressionStatement = function (node) {
+            var start = this.position;
+
+            var preComments = this.convertTokenLeadingComments(node.firstToken(), start);
+            var expression = node.expression.accept(this);
+
+            var semicolonPosition = this.position;
+
+            var postComments = this.convertComments(node.semicolonToken.trailingTrivia(), this.position + node.semicolonToken.leadingTriviaWidth() + node.semicolonToken.width());
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.ExpressionStatement(expression);
+            this.setSpan(result, start, node);
+
+            result.setPreComments(preComments);
+            result.setPostComments(postComments);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitConstructorDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.callSignature);
+            var callSignature = this.visitCallSignature(node.callSignature);
+
+            var block = node.block ? node.block.accept(this) : null;
+
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.ConstructorDeclaration(callSignature, block);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitIndexMemberDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.indexSignature);
+            var indexSignature = node.indexSignature.accept(this);
+
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.IndexMemberDeclaration(indexSignature);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitMemberFunctionDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.propertyName);
+            var name = this.visitToken(node.propertyName);
+
+            var callSignature = this.visitCallSignature(node.callSignature);
+            var block = node.block ? this.visitBlock(node.block) : null;
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.MemberFunctionDeclaration(this.visitModifiers(node.modifiers), name, callSignature, block);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitGetAccessor = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.propertyName);
+            var name = this.visitToken(node.propertyName);
+            var parameters = this.visitParameterList(node.parameterList);
+            var returnType = this.visitTypeAnnotation(node.typeAnnotation);
+
+            var block = node.block ? node.block.accept(this) : null;
+            var result = new TypeScript.GetAccessor(this.visitModifiers(node.modifiers), name, parameters, returnType, block);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitSetAccessor = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.propertyName);
+            var name = this.visitToken(node.propertyName);
+            var parameters = this.visitParameterList(node.parameterList);
+            var block = node.block ? node.block.accept(this) : null;
+            var result = new TypeScript.SetAccessor(this.visitModifiers(node.modifiers), name, parameters, block);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitMemberVariableDeclaration = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.variableDeclarator);
+            var variableDeclarator = node.variableDeclarator.accept(this);
+            this.movePast(node.semicolonToken);
+
+            var modifiers = this.visitModifiers(node.modifiers);
+            var result = new TypeScript.MemberVariableDeclaration(modifiers, variableDeclarator);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitThrowStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.throwKeyword);
+            var expression = node.expression.accept(this);
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.ThrowStatement(expression);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitReturnStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.returnKeyword);
+            var expression = node.expression ? node.expression.accept(this) : null;
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.ReturnStatement(expression);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitObjectCreationExpression = function (node) {
+            var start = this.position;
+
+            this.movePast(node.newKeyword);
+            var expression = node.expression.accept(this);
+            var argumentList = this.visitArgumentList(node.argumentList);
+
+            var result = new TypeScript.ObjectCreationExpression(expression, argumentList);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitSwitchStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.switchKeyword);
+            this.movePast(node.openParenToken);
+            var expression = node.expression.accept(this);
+
+            var closeParenToken = this.createTokenSpan(this.position, node.closeParenToken);
+            this.movePast(node.closeParenToken);
+            this.movePast(node.openBraceToken);
+            var switchClauses = this.visitSyntaxList(node.switchClauses);
+            this.movePast(node.closeBraceToken);
+
+            var result = new TypeScript.SwitchStatement(expression, closeParenToken, switchClauses);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitCaseSwitchClause = function (node) {
+            var start = this.position;
+
+            this.movePast(node.caseKeyword);
+            var expression = node.expression.accept(this);
+            this.movePast(node.colonToken);
+            var statements = this.visitSyntaxList(node.statements);
+
+            var result = new TypeScript.CaseSwitchClause(expression, statements);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitDefaultSwitchClause = function (node) {
+            var start = this.position;
+
+            this.movePast(node.defaultKeyword);
+            this.movePast(node.colonToken);
+            var statements = this.visitSyntaxList(node.statements);
+
+            var result = new TypeScript.DefaultSwitchClause(statements);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitBreakStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.breakKeyword);
+            var identifier = node.identifier ? node.identifier.accept(this) : null;
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.BreakStatement(identifier);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitContinueStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.continueKeyword);
+            var identifier = node.identifier ? node.identifier.accept(this) : null;
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.ContinueStatement(identifier);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitForStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.forKeyword);
+            this.movePast(node.openParenToken);
+            var variableDeclaration = node.variableDeclaration ? node.variableDeclaration.accept(this) : null;
+            var initializer = node.initializer ? node.initializer.accept(this) : null;
+
+            this.movePast(node.firstSemicolonToken);
+            var cond = node.condition ? node.condition.accept(this) : null;
+            this.movePast(node.secondSemicolonToken);
+            var incr = node.incrementor ? node.incrementor.accept(this) : null;
+            this.movePast(node.closeParenToken);
+            var body = node.statement.accept(this);
+
+            var result = new TypeScript.ForStatement(variableDeclaration, initializer, cond, incr, body);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitForInStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.forKeyword);
+            this.movePast(node.openParenToken);
+            var variableDeclaration = node.variableDeclaration ? node.variableDeclaration.accept(this) : null;
+            var left = node.left ? node.left.accept(this) : null;
+
+            this.movePast(node.inKeyword);
+            var expression = node.expression.accept(this);
+            this.movePast(node.closeParenToken);
+            var body = node.statement.accept(this);
+
+            var result = new TypeScript.ForInStatement(variableDeclaration, left, expression, body);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitWhileStatement = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.condition);
+            var condition = node.condition.accept(this);
+            this.movePast(node.closeParenToken);
+            var statement = node.statement.accept(this);
+
+            var result = new TypeScript.WhileStatement(condition, statement);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitWithStatement = function (node) {
+            var start = this.position;
+
+            this.moveTo(node, node.condition);
+            var condition = node.condition.accept(this);
+            this.movePast(node.closeParenToken);
+            var statement = node.statement.accept(this);
+
+            var result = new TypeScript.WithStatement(condition, statement);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitCastExpression = function (node) {
+            var start = this.position;
+
+            this.movePast(node.lessThanToken);
+            var castTerm = this.visitType(node.type);
+            this.movePast(node.greaterThanToken);
+            var expression = node.expression.accept(this);
+
+            var result = new TypeScript.CastExpression(castTerm, expression);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitObjectLiteralExpression = function (node) {
+            var start = this.position;
+
+            var openStart = this.position + node.openBraceToken.leadingTriviaWidth();
+            this.movePast(node.openBraceToken);
+
+            var propertyAssignments = this.visitSeparatedSyntaxList(node.propertyAssignments);
+
+            var closeStart = this.position + node.closeBraceToken.leadingTriviaWidth();
+            this.movePast(node.closeBraceToken);
+
+            var result = new TypeScript.ObjectLiteralExpression(propertyAssignments);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitSimplePropertyAssignment = function (node) {
+            var start = this.position;
+
+            var preComments = this.convertTokenLeadingComments(node.firstToken(), start);
+            var postComments = this.convertNodeTrailingComments(node, node.lastToken(), start);
+
+            var propertyName = node.propertyName.accept(this);
+
+            var afterColonComments = this.convertTokenTrailingComments(node.colonToken, this.position + node.colonToken.leadingTriviaWidth() + node.colonToken.width());
+
+            this.movePast(node.colonToken);
+            var expression = node.expression.accept(this);
+            expression.setPreComments(this.mergeComments(afterColonComments, expression.preComments()));
+
+            var result = new TypeScript.SimplePropertyAssignment(propertyName, expression);
+            this.setSpan(result, start, node);
+
+            result.setPreComments(preComments);
+            result.setPostComments(postComments);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitFunctionPropertyAssignment = function (node) {
+            var start = this.position;
+
+            var propertyName = node.propertyName.accept(this);
+            var callSignature = this.visitCallSignature(node.callSignature);
+            var block = this.visitBlock(node.block);
+
+            var result = new TypeScript.FunctionPropertyAssignment(propertyName, callSignature, block);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitFunctionExpression = function (node) {
+            var start = this.position;
+
+            this.movePast(node.functionKeyword);
+            var name = node.identifier === null ? null : this.visitIdentifier(node.identifier);
+
+            var callSignature = this.visitCallSignature(node.callSignature);
+            var block = node.block ? node.block.accept(this) : null;
+
+            var result = new TypeScript.FunctionExpression(name, callSignature, block);
+            this.setCommentsAndSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitEmptyStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.EmptyStatement();
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTryStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.tryKeyword);
+            var tryBody = node.block.accept(this);
+
+            var catchClause = null;
+            if (node.catchClause !== null) {
+                catchClause = node.catchClause.accept(this);
+            }
+
+            var finallyBody = null;
+            if (node.finallyClause !== null) {
+                finallyBody = node.finallyClause.accept(this);
+            }
+
+            var result = new TypeScript.TryStatement(tryBody, catchClause, finallyBody);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitCatchClause = function (node) {
+            var start = this.position;
+
+            this.movePast(node.catchKeyword);
+            this.movePast(node.openParenToken);
+            var identifier = this.visitIdentifier(node.identifier);
+            var typeAnnotation = this.visitTypeAnnotation(node.typeAnnotation);
+            this.movePast(node.closeParenToken);
+            var block = node.block.accept(this);
+
+            var result = new TypeScript.CatchClause(identifier, typeAnnotation, block);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitFinallyClause = function (node) {
+            var start = this.position;
+            this.movePast(node.finallyKeyword);
+            var block = node.block.accept(this);
+
+            var result = new TypeScript.FinallyClause(block);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitLabeledStatement = function (node) {
+            var start = this.position;
+
+            var identifier = this.visitIdentifier(node.identifier);
+            this.movePast(node.colonToken);
+            var statement = node.statement.accept(this);
+
+            var result = new TypeScript.LabeledStatement(identifier, statement);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitDoStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.doKeyword);
+            var statement = node.statement.accept(this);
+            var whileKeyword = this.createTokenSpan(this.position, node.whileKeyword);
+
+            this.movePast(node.whileKeyword);
+            this.movePast(node.openParenToken);
+            var condition = node.condition.accept(this);
+            this.movePast(node.closeParenToken);
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.DoStatement(statement, whileKeyword, condition);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitTypeOfExpression = function (node) {
+            var start = this.position;
+
+            this.movePast(node.typeOfKeyword);
+            var expression = node.expression.accept(this);
+
+            var result = new TypeScript.TypeOfExpression(expression);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitDeleteExpression = function (node) {
+            var start = this.position;
+
+            this.movePast(node.deleteKeyword);
+            var expression = node.expression.accept(this);
+
+            var result = new TypeScript.DeleteExpression(expression);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitVoidExpression = function (node) {
+            var start = this.position;
+
+            this.movePast(node.voidKeyword);
+            var expression = node.expression.accept(this);
+
+            var result = new TypeScript.VoidExpression(expression);
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+
+        SyntaxTreeToAstVisitor.prototype.visitDebuggerStatement = function (node) {
+            var start = this.position;
+
+            this.movePast(node.debuggerKeyword);
+            this.movePast(node.semicolonToken);
+
+            var result = new TypeScript.DebuggerStatement();
+            this.setSpan(result, start, node);
+
+            return result;
+        };
+        return SyntaxTreeToAstVisitor;
+    })();
+    TypeScript.SyntaxTreeToAstVisitor = SyntaxTreeToAstVisitor;
+
+    function applyDelta(ast, delta) {
+        if (ast) {
+            if (ast._start !== -1) {
+                ast._start += delta;
+            }
+
+            if (ast._end !== -1) {
+                ast._end += delta;
+            }
+        }
+    }
+
+    function applyDeltaToComments(comments, delta) {
+        if (comments && comments.length > 0) {
+            for (var i = 0; i < comments.length; i++) {
+                var comment = comments[i];
+                applyDelta(comment, delta);
+            }
+        }
+    }
+
+    var SyntaxTreeToIncrementalAstVisitor = (function (_super) {
+        __extends(SyntaxTreeToIncrementalAstVisitor, _super);
+        function SyntaxTreeToIncrementalAstVisitor() {
+            _super.apply(this, arguments);
+        }
+        SyntaxTreeToIncrementalAstVisitor.prototype.applyDelta = function (ast, delta) {
+            if (delta === 0) {
+                return;
+            }
+
+            var pre = function (cur) {
+                applyDelta(cur, delta);
+                applyDeltaToComments(cur.preComments(), delta);
+                applyDeltaToComments(cur.postComments(), delta);
+
+                switch (cur.kind()) {
+                    case 146 /* Block */:
+                        applyDelta(cur.closeBraceToken, delta);
+                        break;
+
+                    case 226 /* ArgumentList */:
+                        applyDelta(cur.closeParenToken, delta);
+                        break;
+
+                    case 130 /* ModuleDeclaration */:
+                        applyDelta(cur.endingToken, delta);
+                        break;
+
+                    case 131 /* ClassDeclaration */:
+                        applyDelta(cur.closeBraceToken, delta);
+                        break;
+
+                    case 161 /* DoStatement */:
+                        applyDelta(cur.whileKeyword, delta);
+                        break;
+
+                    case 151 /* SwitchStatement */:
+                        applyDelta(cur.closeParenToken, delta);
+                        break;
+                }
+            };
+
+            TypeScript.getAstWalkerFactory().simpleWalk(ast, pre);
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.setSpanExplicit = function (span, start, end) {
+            if (span._start !== -1) {
+                var delta = start - span._start;
+                this.applyDelta(span, delta);
+
+                span._end = end;
+            } else {
+                _super.prototype.setSpanExplicit.call(this, span, start, end);
+            }
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.getAndMovePastAST = function (element) {
+            if (this.previousTokenTrailingComments !== null) {
+                return null;
+            }
+
+            var result = element._ast;
+            if (!result) {
+                return null;
+            }
+
+            var start = this.position;
+            this.movePast(element);
+            this.setSpan(result, start, element);
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.setAST = function (element, ast) {
+            element._ast = ast;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitSyntaxList = function (list) {
+            var result = this.getAndMovePastAST(list);
+            if (!result) {
+                result = _super.prototype.visitSyntaxList.call(this, list);
+
+                if (list.childCount() > 0) {
+                    this.setAST(list, result);
+                }
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitSeparatedSyntaxList = function (list) {
+            var result = this.getAndMovePastAST(list);
+            if (!result) {
+                result = _super.prototype.visitSeparatedSyntaxList.call(this, list);
+
+                if (list.childCount() > 0) {
+                    this.setAST(list, result);
+                }
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitToken = function (token) {
+            var result = this.getAndMovePastAST(token);
+
+            if (!result) {
+                result = _super.prototype.visitToken.call(this, token);
+                this.setAST(token, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitClassDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitClassDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitInterfaceDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitInterfaceDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitHeritageClause = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitHeritageClause.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitModuleDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitModuleDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitFunctionDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitImportDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitImportDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitExportAssignment = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitExportAssignment.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitPrefixUnaryExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitPrefixUnaryExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitArrayLiteralExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitArrayLiteralExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitOmittedExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitOmittedExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitParenthesizedExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitParenthesizedExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitSimpleArrowFunctionExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitSimpleArrowFunctionExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitParenthesizedArrowFunctionExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitParenthesizedArrowFunctionExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitQualifiedName = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                var result = _super.prototype.visitQualifiedName.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitConstructorType = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitConstructorType.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionType = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitFunctionType.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitObjectType = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitObjectType.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitArrayType = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitArrayType.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitGenericType = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitGenericType.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitBlock = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitBlock.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitParameter = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitParameter.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitMemberAccessExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitMemberAccessExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitPostfixUnaryExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitPostfixUnaryExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitElementAccessExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitElementAccessExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitInvocationExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitInvocationExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitBinaryExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitBinaryExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitConditionalExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitConditionalExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitConstructSignature = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitConstructSignature.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitMethodSignature = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitMethodSignature.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitIndexSignature = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitIndexSignature.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitPropertySignature = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitPropertySignature.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitCallSignature = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitCallSignature.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitTypeParameter = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitTypeParameter.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitIfStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitIfStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitExpressionStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitExpressionStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitConstructorDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitConstructorDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitMemberFunctionDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitMemberFunctionDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitGetAccessor = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitGetAccessor.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitSetAccessor = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitSetAccessor.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitMemberVariableDeclaration = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitMemberVariableDeclaration.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitThrowStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitThrowStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitReturnStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitReturnStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitObjectCreationExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitObjectCreationExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitSwitchStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitSwitchStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitCaseSwitchClause = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitCaseSwitchClause.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitDefaultSwitchClause = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitDefaultSwitchClause.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitBreakStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitBreakStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitContinueStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitContinueStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitForStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitForStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitForInStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitForInStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitWhileStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitWhileStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitWithStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitWithStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitCastExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitCastExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitObjectLiteralExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitObjectLiteralExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitSimplePropertyAssignment = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitSimplePropertyAssignment.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionPropertyAssignment = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitFunctionPropertyAssignment.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitFunctionExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitEmptyStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitEmptyStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitTryStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitTryStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitCatchClause = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitCatchClause.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitLabeledStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitLabeledStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitDoStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitDoStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitTypeOfExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitTypeOfExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitDeleteExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitDeleteExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitVoidExpression = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitVoidExpression.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+
+        SyntaxTreeToIncrementalAstVisitor.prototype.visitDebuggerStatement = function (node) {
+            var result = this.getAndMovePastAST(node);
+            if (!result) {
+                result = _super.prototype.visitDebuggerStatement.call(this, node);
+                this.setAST(node, result);
+            }
+
+            return result;
+        };
+        return SyntaxTreeToIncrementalAstVisitor;
+    })(SyntaxTreeToAstVisitor);
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+    var ASTSpan = (function () {
+        function ASTSpan(_start, _end) {
+            this._start = _start;
+            this._end = _end;
+        }
+        ASTSpan.prototype.start = function () {
+            return this._start;
+        };
+
+        ASTSpan.prototype.end = function () {
+            return this._end;
+        };
+        return ASTSpan;
+    })();
+    TypeScript.ASTSpan = ASTSpan;
+
+    var astID = 0;
+
+    function structuralEqualsNotIncludingPosition(ast1, ast2) {
+        return structuralEquals(ast1, ast2, false);
+    }
+    TypeScript.structuralEqualsNotIncludingPosition = structuralEqualsNotIncludingPosition;
+
+    function structuralEqualsIncludingPosition(ast1, ast2) {
+        return structuralEquals(ast1, ast2, true);
+    }
+    TypeScript.structuralEqualsIncludingPosition = structuralEqualsIncludingPosition;
+
+    function commentStructuralEqualsNotIncludingPosition(ast1, ast2) {
+        return commentStructuralEquals(ast1, ast2, false);
+    }
+
+    function commentStructuralEqualsIncludingPosition(ast1, ast2) {
+        return commentStructuralEquals(ast1, ast2, true);
+    }
+
+    function structuralEquals(ast1, ast2, includingPosition) {
+        if (ast1 === ast2) {
+            return true;
+        }
+
+        return ast1 !== null && ast2 !== null && ast1.kind() === ast2.kind() && ast1.structuralEquals(ast2, includingPosition);
+    }
+
+    function commentStructuralEquals(ast1, ast2, includingPosition) {
+        if (ast1 === ast2) {
+            return true;
+        }
+
+        return ast1 !== null && ast2 !== null && ast1.structuralEquals(ast2, includingPosition);
+    }
+
+    function astArrayStructuralEquals(array1, array2, includingPosition) {
+        return TypeScript.ArrayUtilities.sequenceEquals(array1, array2, includingPosition ? structuralEqualsIncludingPosition : structuralEqualsNotIncludingPosition);
+    }
+
+    function commentArrayStructuralEquals(array1, array2, includingPosition) {
+        return TypeScript.ArrayUtilities.sequenceEquals(array1, array2, includingPosition ? commentStructuralEqualsIncludingPosition : commentStructuralEqualsNotIncludingPosition);
+    }
+
+    var AST = (function () {
+        function AST() {
+            this.parent = null;
+            this._start = -1;
+            this._end = -1;
+            this._trailingTriviaWidth = 0;
+            this._astID = astID++;
+            this._preComments = null;
+            this._postComments = null;
+        }
+        AST.prototype.syntaxID = function () {
+            return this._astID;
+        };
+
+        AST.prototype.start = function () {
+            return this._start;
+        };
+
+        AST.prototype.end = function () {
+            return this._end;
+        };
+
+        AST.prototype.trailingTriviaWidth = function () {
+            return this._trailingTriviaWidth;
+        };
+
+        AST.prototype.fileName = function () {
+            return this.parent.fileName();
+        };
+
+        AST.prototype.kind = function () {
+            throw TypeScript.Errors.abstract();
+        };
+
+        AST.prototype.preComments = function () {
+            return this._preComments;
+        };
+
+        AST.prototype.postComments = function () {
+            return this._postComments;
+        };
+
+        AST.prototype.setPreComments = function (comments) {
+            if (comments && comments.length) {
+                this._preComments = comments;
+            } else if (this._preComments) {
+                this._preComments = null;
+            }
+        };
+
+        AST.prototype.setPostComments = function (comments) {
+            if (comments && comments.length) {
+                this._postComments = comments;
+            } else if (this._postComments) {
+                this._postComments = null;
+            }
+        };
+
+        AST.prototype.width = function () {
+            return this.end() - this.start();
+        };
+
+        AST.prototype.structuralEquals = function (ast, includingPosition) {
+            if (includingPosition) {
+                if (this.start() !== ast.start() || this.end() !== ast.end()) {
+                    return false;
+                }
+            }
+
+            return commentArrayStructuralEquals(this.preComments(), ast.preComments(), includingPosition) && commentArrayStructuralEquals(this.postComments(), ast.postComments(), includingPosition);
+        };
+
+        AST.prototype.isExpression = function () {
+            return false;
+        };
+        return AST;
+    })();
+    TypeScript.AST = AST;
+
+    var ISyntaxList2 = (function (_super) {
+        __extends(ISyntaxList2, _super);
+        function ISyntaxList2(_fileName, members) {
+            _super.call(this);
+            this._fileName = _fileName;
+            this.members = members;
+
+            for (var i = 0, n = members.length; i < n; i++) {
+                members[i].parent = this;
+            }
+        }
+        ISyntaxList2.prototype.childCount = function () {
+            return this.members.length;
+        };
+
+        ISyntaxList2.prototype.childAt = function (index) {
+            return this.members[index];
+        };
+
+        ISyntaxList2.prototype.fileName = function () {
+            return this._fileName;
+        };
+
+        ISyntaxList2.prototype.kind = function () {
+            return 1 /* List */;
+        };
+
+        ISyntaxList2.prototype.firstOrDefault = function (func) {
+            return TypeScript.ArrayUtilities.firstOrDefault(this.members, func);
+        };
+
+        ISyntaxList2.prototype.lastOrDefault = function (func) {
+            return TypeScript.ArrayUtilities.lastOrDefault(this.members, func);
+        };
+
+        ISyntaxList2.prototype.any = function (func) {
+            return TypeScript.ArrayUtilities.any(this.members, func);
+        };
+
+        ISyntaxList2.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && astArrayStructuralEquals(this.members, ast.members, includingPosition);
+        };
+        return ISyntaxList2;
+    })(AST);
+    TypeScript.ISyntaxList2 = ISyntaxList2;
+
+    var ISeparatedSyntaxList2 = (function (_super) {
+        __extends(ISeparatedSyntaxList2, _super);
+        function ISeparatedSyntaxList2(_fileName, members, _separatorCount) {
+            _super.call(this);
+            this._fileName = _fileName;
+            this.members = members;
+            this._separatorCount = _separatorCount;
+
+            for (var i = 0, n = members.length; i < n; i++) {
+                members[i].parent = this;
+            }
+        }
+        ISeparatedSyntaxList2.prototype.nonSeparatorCount = function () {
+            return this.members.length;
+        };
+
+        ISeparatedSyntaxList2.prototype.separatorCount = function () {
+            return this._separatorCount;
+        };
+
+        ISeparatedSyntaxList2.prototype.nonSeparatorAt = function (index) {
+            return this.members[index];
+        };
+
+        ISeparatedSyntaxList2.prototype.nonSeparatorIndexOf = function (ast) {
+            for (var i = 0, n = this.nonSeparatorCount(); i < n; i++) {
+                if (this.nonSeparatorAt(i) === ast) {
+                    return i;
+                }
+            }
+
+            return -1;
+        };
+
+        ISeparatedSyntaxList2.prototype.fileName = function () {
+            return this._fileName;
+        };
+
+        ISeparatedSyntaxList2.prototype.kind = function () {
+            return 2 /* SeparatedList */;
+        };
+
+        ISeparatedSyntaxList2.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && astArrayStructuralEquals(this.members, ast.members, includingPosition);
+        };
+        return ISeparatedSyntaxList2;
+    })(AST);
+    TypeScript.ISeparatedSyntaxList2 = ISeparatedSyntaxList2;
+
+    var SourceUnit = (function (_super) {
+        __extends(SourceUnit, _super);
+        function SourceUnit(moduleElements, endOfFileTokenLeadingComments, _fileName) {
+            _super.call(this);
+            this.moduleElements = moduleElements;
+            this.endOfFileTokenLeadingComments = endOfFileTokenLeadingComments;
+            this._fileName = _fileName;
+            moduleElements && (moduleElements.parent = this);
+        }
+        SourceUnit.prototype.fileName = function () {
+            return this._fileName;
+        };
+
+        SourceUnit.prototype.kind = function () {
+            return 120 /* SourceUnit */;
+        };
+
+        SourceUnit.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.moduleElements, ast.moduleElements, includingPosition);
+        };
+        return SourceUnit;
+    })(AST);
+    TypeScript.SourceUnit = SourceUnit;
+
+    var Identifier = (function (_super) {
+        __extends(Identifier, _super);
+        function Identifier(_text) {
+            _super.call(this);
+            this._text = _text;
+            this._valueText = null;
+        }
+        Identifier.prototype.text = function () {
+            return this._text;
+        };
+        Identifier.prototype.valueText = function () {
+            if (!this._valueText) {
+                var text = this._text;
+                if (text === "__proto__") {
+                    this._valueText = "#__proto__";
+                } else {
+                    this._valueText = TypeScript.Syntax.massageEscapes(text);
+                }
+            }
+
+            return this._valueText;
+        };
+
+        Identifier.prototype.kind = function () {
+            return 11 /* IdentifierName */;
+        };
+
+        Identifier.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && this._text === ast._text;
+        };
+
+        Identifier.prototype.isExpression = function () {
+            return true;
+        };
+        return Identifier;
+    })(AST);
+    TypeScript.Identifier = Identifier;
+
+    var LiteralExpression = (function (_super) {
+        __extends(LiteralExpression, _super);
+        function LiteralExpression(_nodeType, _text, _valueText) {
+            _super.call(this);
+            this._nodeType = _nodeType;
+            this._text = _text;
+            this._valueText = _valueText;
+        }
+        LiteralExpression.prototype.text = function () {
+            return this._text;
+        };
+
+        LiteralExpression.prototype.valueText = function () {
+            return this._valueText;
+        };
+
+        LiteralExpression.prototype.kind = function () {
+            return this._nodeType;
+        };
+
+        LiteralExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition);
+        };
+
+        LiteralExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return LiteralExpression;
+    })(AST);
+    TypeScript.LiteralExpression = LiteralExpression;
+
+    var ThisExpression = (function (_super) {
+        __extends(ThisExpression, _super);
+        function ThisExpression(_text, _valueText) {
+            _super.call(this);
+            this._text = _text;
+            this._valueText = _valueText;
+        }
+        ThisExpression.prototype.text = function () {
+            return this._text;
+        };
+
+        ThisExpression.prototype.valueText = function () {
+            return this._valueText;
+        };
+
+        ThisExpression.prototype.kind = function () {
+            return 35 /* ThisKeyword */;
+        };
+
+        ThisExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition);
+        };
+
+        ThisExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ThisExpression;
+    })(AST);
+    TypeScript.ThisExpression = ThisExpression;
+
+    var SuperExpression = (function (_super) {
+        __extends(SuperExpression, _super);
+        function SuperExpression(_text, _valueText) {
+            _super.call(this);
+            this._text = _text;
+            this._valueText = _valueText;
+        }
+        SuperExpression.prototype.text = function () {
+            return this._text;
+        };
+
+        SuperExpression.prototype.valueText = function () {
+            return this._valueText;
+        };
+
+        SuperExpression.prototype.kind = function () {
+            return 50 /* SuperKeyword */;
+        };
+
+        SuperExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition);
+        };
+
+        SuperExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return SuperExpression;
+    })(AST);
+    TypeScript.SuperExpression = SuperExpression;
+
+    var NumericLiteral = (function (_super) {
+        __extends(NumericLiteral, _super);
+        function NumericLiteral(_value, _text, _valueText) {
+            _super.call(this);
+            this._value = _value;
+            this._text = _text;
+            this._valueText = _valueText;
+        }
+        NumericLiteral.prototype.text = function () {
+            return this._text;
+        };
+        NumericLiteral.prototype.valueText = function () {
+            return this._valueText;
+        };
+        NumericLiteral.prototype.value = function () {
+            return this._value;
+        };
+
+        NumericLiteral.prototype.kind = function () {
+            return 13 /* NumericLiteral */;
+        };
+
+        NumericLiteral.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && (this._value === ast._value || (isNaN(this._value) && isNaN(ast._value))) && this._text === ast._text;
+        };
+
+        NumericLiteral.prototype.isExpression = function () {
+            return true;
+        };
+        return NumericLiteral;
+    })(AST);
+    TypeScript.NumericLiteral = NumericLiteral;
+
+    var RegularExpressionLiteral = (function (_super) {
+        __extends(RegularExpressionLiteral, _super);
+        function RegularExpressionLiteral(_text, _valueText) {
+            _super.call(this);
+            this._text = _text;
+            this._valueText = _valueText;
+        }
+        RegularExpressionLiteral.prototype.text = function () {
+            return this._text;
+        };
+
+        RegularExpressionLiteral.prototype.valueText = function () {
+            return this._valueText;
+        };
+
+        RegularExpressionLiteral.prototype.kind = function () {
+            return 12 /* RegularExpressionLiteral */;
+        };
+
+        RegularExpressionLiteral.prototype.isExpression = function () {
+            return true;
+        };
+        return RegularExpressionLiteral;
+    })(AST);
+    TypeScript.RegularExpressionLiteral = RegularExpressionLiteral;
+
+    var StringLiteral = (function (_super) {
+        __extends(StringLiteral, _super);
+        function StringLiteral(_text, _valueText) {
+            _super.call(this);
+            this._text = _text;
+            this._valueText = _valueText;
+            this._valueText = _valueText === "__proto__" ? "#__proto__" : _valueText;
+        }
+        StringLiteral.prototype.text = function () {
+            return this._text;
+        };
+        StringLiteral.prototype.valueText = function () {
+            return this._valueText;
+        };
+
+        StringLiteral.prototype.kind = function () {
+            return 14 /* StringLiteral */;
+        };
+
+        StringLiteral.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && this._text === ast._text;
+        };
+
+        StringLiteral.prototype.isExpression = function () {
+            return true;
+        };
+        return StringLiteral;
+    })(AST);
+    TypeScript.StringLiteral = StringLiteral;
+
+    var TypeAnnotation = (function (_super) {
+        __extends(TypeAnnotation, _super);
+        function TypeAnnotation(type) {
+            _super.call(this);
+            this.type = type;
+            type && (type.parent = this);
+        }
+        TypeAnnotation.prototype.kind = function () {
+            return 244 /* TypeAnnotation */;
+        };
+        return TypeAnnotation;
+    })(AST);
+    TypeScript.TypeAnnotation = TypeAnnotation;
+
+    var BuiltInType = (function (_super) {
+        __extends(BuiltInType, _super);
+        function BuiltInType(_nodeType, _text, _valueText) {
+            _super.call(this);
+            this._nodeType = _nodeType;
+            this._text = _text;
+            this._valueText = _valueText;
+        }
+        BuiltInType.prototype.text = function () {
+            return this._text;
+        };
+
+        BuiltInType.prototype.valueText = function () {
+            return this._valueText;
+        };
+
+        BuiltInType.prototype.kind = function () {
+            return this._nodeType;
+        };
+        return BuiltInType;
+    })(AST);
+    TypeScript.BuiltInType = BuiltInType;
+
+    var ExternalModuleReference = (function (_super) {
+        __extends(ExternalModuleReference, _super);
+        function ExternalModuleReference(stringLiteral) {
+            _super.call(this);
+            this.stringLiteral = stringLiteral;
+            stringLiteral && (stringLiteral.parent = this);
+        }
+        ExternalModuleReference.prototype.kind = function () {
+            return 245 /* ExternalModuleReference */;
+        };
+        return ExternalModuleReference;
+    })(AST);
+    TypeScript.ExternalModuleReference = ExternalModuleReference;
+
+    var ModuleNameModuleReference = (function (_super) {
+        __extends(ModuleNameModuleReference, _super);
+        function ModuleNameModuleReference(moduleName) {
+            _super.call(this);
+            this.moduleName = moduleName;
+            moduleName && (moduleName.parent = this);
+        }
+        ModuleNameModuleReference.prototype.kind = function () {
+            return 246 /* ModuleNameModuleReference */;
+        };
+        return ModuleNameModuleReference;
+    })(AST);
+    TypeScript.ModuleNameModuleReference = ModuleNameModuleReference;
+
+    var ImportDeclaration = (function (_super) {
+        __extends(ImportDeclaration, _super);
+        function ImportDeclaration(modifiers, identifier, moduleReference) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.identifier = identifier;
+            this.moduleReference = moduleReference;
+            identifier && (identifier.parent = this);
+            moduleReference && (moduleReference.parent = this);
+        }
+        ImportDeclaration.prototype.kind = function () {
+            return 133 /* ImportDeclaration */;
+        };
+
+        ImportDeclaration.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.moduleReference, ast.moduleReference, includingPosition);
+        };
+        return ImportDeclaration;
+    })(AST);
+    TypeScript.ImportDeclaration = ImportDeclaration;
+
+    var ExportAssignment = (function (_super) {
+        __extends(ExportAssignment, _super);
+        function ExportAssignment(identifier) {
+            _super.call(this);
+            this.identifier = identifier;
+            identifier && (identifier.parent = this);
+        }
+        ExportAssignment.prototype.kind = function () {
+            return 134 /* ExportAssignment */;
+        };
+
+        ExportAssignment.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition);
+        };
+        return ExportAssignment;
+    })(AST);
+    TypeScript.ExportAssignment = ExportAssignment;
+
+    var TypeParameterList = (function (_super) {
+        __extends(TypeParameterList, _super);
+        function TypeParameterList(typeParameters) {
+            _super.call(this);
+            this.typeParameters = typeParameters;
+            typeParameters && (typeParameters.parent = this);
+        }
+        TypeParameterList.prototype.kind = function () {
+            return 229 /* TypeParameterList */;
+        };
+        return TypeParameterList;
+    })(AST);
+    TypeScript.TypeParameterList = TypeParameterList;
+
+    var ClassDeclaration = (function (_super) {
+        __extends(ClassDeclaration, _super);
+        function ClassDeclaration(modifiers, identifier, typeParameterList, heritageClauses, classElements, closeBraceToken) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.identifier = identifier;
+            this.typeParameterList = typeParameterList;
+            this.heritageClauses = heritageClauses;
+            this.classElements = classElements;
+            this.closeBraceToken = closeBraceToken;
+            identifier && (identifier.parent = this);
+            typeParameterList && (typeParameterList.parent = this);
+            heritageClauses && (heritageClauses.parent = this);
+            classElements && (classElements.parent = this);
+        }
+        ClassDeclaration.prototype.kind = function () {
+            return 131 /* ClassDeclaration */;
+        };
+
+        ClassDeclaration.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.classElements, ast.classElements, includingPosition) && structuralEquals(this.typeParameterList, ast.typeParameterList, includingPosition) && structuralEquals(this.heritageClauses, ast.heritageClauses, includingPosition);
+        };
+        return ClassDeclaration;
+    })(AST);
+    TypeScript.ClassDeclaration = ClassDeclaration;
+
+    var InterfaceDeclaration = (function (_super) {
+        __extends(InterfaceDeclaration, _super);
+        function InterfaceDeclaration(modifiers, identifier, typeParameterList, heritageClauses, body) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.identifier = identifier;
+            this.typeParameterList = typeParameterList;
+            this.heritageClauses = heritageClauses;
+            this.body = body;
+            identifier && (identifier.parent = this);
+            typeParameterList && (typeParameterList.parent = this);
+            body && (body.parent = this);
+            heritageClauses && (heritageClauses.parent = this);
+        }
+        InterfaceDeclaration.prototype.kind = function () {
+            return 128 /* InterfaceDeclaration */;
+        };
+
+        InterfaceDeclaration.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.body, ast.body, includingPosition) && structuralEquals(this.typeParameterList, ast.typeParameterList, includingPosition) && structuralEquals(this.heritageClauses, ast.heritageClauses, includingPosition);
+        };
+        return InterfaceDeclaration;
+    })(AST);
+    TypeScript.InterfaceDeclaration = InterfaceDeclaration;
+
+    var HeritageClause = (function (_super) {
+        __extends(HeritageClause, _super);
+        function HeritageClause(_nodeType, typeNames) {
+            _super.call(this);
+            this._nodeType = _nodeType;
+            this.typeNames = typeNames;
+            typeNames && (typeNames.parent = this);
+        }
+        HeritageClause.prototype.kind = function () {
+            return this._nodeType;
+        };
+
+        HeritageClause.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.typeNames, ast.typeNames, includingPosition);
+        };
+        return HeritageClause;
+    })(AST);
+    TypeScript.HeritageClause = HeritageClause;
+
+    var ModuleDeclaration = (function (_super) {
+        __extends(ModuleDeclaration, _super);
+        function ModuleDeclaration(modifiers, name, stringLiteral, moduleElements, endingToken) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.name = name;
+            this.stringLiteral = stringLiteral;
+            this.moduleElements = moduleElements;
+            this.endingToken = endingToken;
+            name && (name.parent = this);
+            stringLiteral && (stringLiteral.parent = this);
+            moduleElements && (moduleElements.parent = this);
+        }
+        ModuleDeclaration.prototype.kind = function () {
+            return 130 /* ModuleDeclaration */;
+        };
+
+        ModuleDeclaration.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.name, ast.name, includingPosition) && structuralEquals(this.moduleElements, ast.moduleElements, includingPosition);
+        };
+        return ModuleDeclaration;
+    })(AST);
+    TypeScript.ModuleDeclaration = ModuleDeclaration;
+
+    var FunctionDeclaration = (function (_super) {
+        __extends(FunctionDeclaration, _super);
+        function FunctionDeclaration(modifiers, identifier, callSignature, block) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.identifier = identifier;
+            this.callSignature = callSignature;
+            this.block = block;
+            identifier && (identifier.parent = this);
+            callSignature && (callSignature.parent = this);
+            block && (block.parent = this);
+        }
+        FunctionDeclaration.prototype.kind = function () {
+            return 129 /* FunctionDeclaration */;
+        };
+
+        FunctionDeclaration.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.block, ast.block, includingPosition) && structuralEquals(this.callSignature, ast.callSignature, includingPosition);
+        };
+        return FunctionDeclaration;
+    })(AST);
+    TypeScript.FunctionDeclaration = FunctionDeclaration;
+
+    var VariableStatement = (function (_super) {
+        __extends(VariableStatement, _super);
+        function VariableStatement(modifiers, declaration) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.declaration = declaration;
+            declaration && (declaration.parent = this);
+        }
+        VariableStatement.prototype.kind = function () {
+            return 148 /* VariableStatement */;
+        };
+
+        VariableStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.declaration, ast.declaration, includingPosition);
+        };
+        return VariableStatement;
+    })(AST);
+    TypeScript.VariableStatement = VariableStatement;
+
+    var VariableDeclaration = (function (_super) {
+        __extends(VariableDeclaration, _super);
+        function VariableDeclaration(declarators) {
+            _super.call(this);
+            this.declarators = declarators;
+            declarators && (declarators.parent = this);
+        }
+        VariableDeclaration.prototype.kind = function () {
+            return 224 /* VariableDeclaration */;
+        };
+
+        VariableDeclaration.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.declarators, ast.declarators, includingPosition);
+        };
+        return VariableDeclaration;
+    })(AST);
+    TypeScript.VariableDeclaration = VariableDeclaration;
+
+    var VariableDeclarator = (function (_super) {
+        __extends(VariableDeclarator, _super);
+        function VariableDeclarator(propertyName, typeAnnotation, equalsValueClause) {
+            _super.call(this);
+            this.propertyName = propertyName;
+            this.typeAnnotation = typeAnnotation;
+            this.equalsValueClause = equalsValueClause;
+            propertyName && (propertyName.parent = this);
+            typeAnnotation && (typeAnnotation.parent = this);
+            equalsValueClause && (equalsValueClause.parent = this);
+        }
+        VariableDeclarator.prototype.kind = function () {
+            return 225 /* VariableDeclarator */;
+        };
+        return VariableDeclarator;
+    })(AST);
+    TypeScript.VariableDeclarator = VariableDeclarator;
+
+    var EqualsValueClause = (function (_super) {
+        __extends(EqualsValueClause, _super);
+        function EqualsValueClause(value) {
+            _super.call(this);
+            this.value = value;
+            value && (value.parent = this);
+        }
+        EqualsValueClause.prototype.kind = function () {
+            return 232 /* EqualsValueClause */;
+        };
+        return EqualsValueClause;
+    })(AST);
+    TypeScript.EqualsValueClause = EqualsValueClause;
+
+    var PrefixUnaryExpression = (function (_super) {
+        __extends(PrefixUnaryExpression, _super);
+        function PrefixUnaryExpression(_nodeType, operand) {
+            _super.call(this);
+            this._nodeType = _nodeType;
+            this.operand = operand;
+            operand && (operand.parent = this);
+        }
+        PrefixUnaryExpression.prototype.kind = function () {
+            return this._nodeType;
+        };
+
+        PrefixUnaryExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.operand, ast.operand, includingPosition);
+        };
+
+        PrefixUnaryExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return PrefixUnaryExpression;
+    })(AST);
+    TypeScript.PrefixUnaryExpression = PrefixUnaryExpression;
+
+    var ArrayLiteralExpression = (function (_super) {
+        __extends(ArrayLiteralExpression, _super);
+        function ArrayLiteralExpression(expressions) {
+            _super.call(this);
+            this.expressions = expressions;
+            expressions && (expressions.parent = this);
+        }
+        ArrayLiteralExpression.prototype.kind = function () {
+            return 214 /* ArrayLiteralExpression */;
+        };
+
+        ArrayLiteralExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expressions, ast.expressions, includingPosition);
+        };
+
+        ArrayLiteralExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ArrayLiteralExpression;
+    })(AST);
+    TypeScript.ArrayLiteralExpression = ArrayLiteralExpression;
+
+    var OmittedExpression = (function (_super) {
+        __extends(OmittedExpression, _super);
+        function OmittedExpression() {
+            _super.apply(this, arguments);
+        }
+        OmittedExpression.prototype.kind = function () {
+            return 223 /* OmittedExpression */;
+        };
+
+        OmittedExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition);
+        };
+
+        OmittedExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return OmittedExpression;
+    })(AST);
+    TypeScript.OmittedExpression = OmittedExpression;
+
+    var ParenthesizedExpression = (function (_super) {
+        __extends(ParenthesizedExpression, _super);
+        function ParenthesizedExpression(openParenTrailingComments, expression) {
+            _super.call(this);
+            this.openParenTrailingComments = openParenTrailingComments;
+            this.expression = expression;
+            expression && (expression.parent = this);
+        }
+        ParenthesizedExpression.prototype.kind = function () {
+            return 217 /* ParenthesizedExpression */;
+        };
+
+        ParenthesizedExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+
+        ParenthesizedExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ParenthesizedExpression;
+    })(AST);
+    TypeScript.ParenthesizedExpression = ParenthesizedExpression;
+
+    var SimpleArrowFunctionExpression = (function (_super) {
+        __extends(SimpleArrowFunctionExpression, _super);
+        function SimpleArrowFunctionExpression(identifier, block, expression) {
+            _super.call(this);
+            this.identifier = identifier;
+            this.block = block;
+            this.expression = expression;
+            identifier && (identifier.parent = this);
+            block && (block.parent = this);
+            expression && (expression.parent = this);
+        }
+        SimpleArrowFunctionExpression.prototype.kind = function () {
+            return 219 /* SimpleArrowFunctionExpression */;
+        };
+
+        SimpleArrowFunctionExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return SimpleArrowFunctionExpression;
+    })(AST);
+    TypeScript.SimpleArrowFunctionExpression = SimpleArrowFunctionExpression;
+
+    var ParenthesizedArrowFunctionExpression = (function (_super) {
+        __extends(ParenthesizedArrowFunctionExpression, _super);
+        function ParenthesizedArrowFunctionExpression(callSignature, block, expression) {
+            _super.call(this);
+            this.callSignature = callSignature;
+            this.block = block;
+            this.expression = expression;
+            callSignature && (callSignature.parent = this);
+            block && (block.parent = this);
+            expression && (expression.parent = this);
+        }
+        ParenthesizedArrowFunctionExpression.prototype.kind = function () {
+            return 218 /* ParenthesizedArrowFunctionExpression */;
+        };
+
+        ParenthesizedArrowFunctionExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ParenthesizedArrowFunctionExpression;
+    })(AST);
+    TypeScript.ParenthesizedArrowFunctionExpression = ParenthesizedArrowFunctionExpression;
+
+    var QualifiedName = (function (_super) {
+        __extends(QualifiedName, _super);
+        function QualifiedName(left, right) {
+            _super.call(this);
+            this.left = left;
+            this.right = right;
+            left && (left.parent = this);
+            right && (right.parent = this);
+        }
+        QualifiedName.prototype.kind = function () {
+            return 121 /* QualifiedName */;
+        };
+
+        QualifiedName.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.left, ast.left, includingPosition) && structuralEquals(this.right, ast.right, includingPosition);
+        };
+        return QualifiedName;
+    })(AST);
+    TypeScript.QualifiedName = QualifiedName;
+
+    var ParameterList = (function (_super) {
+        __extends(ParameterList, _super);
+        function ParameterList(openParenTrailingComments, parameters) {
+            _super.call(this);
+            this.openParenTrailingComments = openParenTrailingComments;
+            this.parameters = parameters;
+            parameters && (parameters.parent = this);
+        }
+        ParameterList.prototype.kind = function () {
+            return 227 /* ParameterList */;
+        };
+        return ParameterList;
+    })(AST);
+    TypeScript.ParameterList = ParameterList;
+
+    var ConstructorType = (function (_super) {
+        __extends(ConstructorType, _super);
+        function ConstructorType(typeParameterList, parameterList, type) {
+            _super.call(this);
+            this.typeParameterList = typeParameterList;
+            this.parameterList = parameterList;
+            this.type = type;
+            typeParameterList && (typeParameterList.parent = this);
+            parameterList && (parameterList.parent = this);
+            type && (type.parent = this);
+        }
+        ConstructorType.prototype.kind = function () {
+            return 125 /* ConstructorType */;
+        };
+        return ConstructorType;
+    })(AST);
+    TypeScript.ConstructorType = ConstructorType;
+
+    var FunctionType = (function (_super) {
+        __extends(FunctionType, _super);
+        function FunctionType(typeParameterList, parameterList, type) {
+            _super.call(this);
+            this.typeParameterList = typeParameterList;
+            this.parameterList = parameterList;
+            this.type = type;
+            typeParameterList && (typeParameterList.parent = this);
+            parameterList && (parameterList.parent = this);
+            type && (type.parent = this);
+        }
+        FunctionType.prototype.kind = function () {
+            return 123 /* FunctionType */;
+        };
+        return FunctionType;
+    })(AST);
+    TypeScript.FunctionType = FunctionType;
+
+    var ObjectType = (function (_super) {
+        __extends(ObjectType, _super);
+        function ObjectType(typeMembers) {
+            _super.call(this);
+            this.typeMembers = typeMembers;
+            typeMembers && (typeMembers.parent = this);
+        }
+        ObjectType.prototype.kind = function () {
+            return 122 /* ObjectType */;
+        };
+
+        ObjectType.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.typeMembers, ast.typeMembers, includingPosition);
+        };
+        return ObjectType;
+    })(AST);
+    TypeScript.ObjectType = ObjectType;
+
+    var ArrayType = (function (_super) {
+        __extends(ArrayType, _super);
+        function ArrayType(type) {
+            _super.call(this);
+            this.type = type;
+            type && (type.parent = this);
+        }
+        ArrayType.prototype.kind = function () {
+            return 124 /* ArrayType */;
+        };
+
+        ArrayType.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.type, ast.type, includingPosition);
+        };
+        return ArrayType;
+    })(AST);
+    TypeScript.ArrayType = ArrayType;
+
+    var TypeArgumentList = (function (_super) {
+        __extends(TypeArgumentList, _super);
+        function TypeArgumentList(typeArguments) {
+            _super.call(this);
+            this.typeArguments = typeArguments;
+            typeArguments && (typeArguments.parent = this);
+        }
+        TypeArgumentList.prototype.kind = function () {
+            return 228 /* TypeArgumentList */;
+        };
+        return TypeArgumentList;
+    })(AST);
+    TypeScript.TypeArgumentList = TypeArgumentList;
+
+    var GenericType = (function (_super) {
+        __extends(GenericType, _super);
+        function GenericType(name, typeArgumentList) {
+            _super.call(this);
+            this.name = name;
+            this.typeArgumentList = typeArgumentList;
+            name && (name.parent = this);
+            typeArgumentList && (typeArgumentList.parent = this);
+        }
+        GenericType.prototype.kind = function () {
+            return 126 /* GenericType */;
+        };
+
+        GenericType.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.name, ast.name, includingPosition) && structuralEquals(this.typeArgumentList, ast.typeArgumentList, includingPosition);
+        };
+        return GenericType;
+    })(AST);
+    TypeScript.GenericType = GenericType;
+
+    var TypeQuery = (function (_super) {
+        __extends(TypeQuery, _super);
+        function TypeQuery(name) {
+            _super.call(this);
+            this.name = name;
+            name && (name.parent = this);
+        }
+        TypeQuery.prototype.kind = function () {
+            return 127 /* TypeQuery */;
+        };
+
+        TypeQuery.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.name, ast.name, includingPosition);
+        };
+        return TypeQuery;
+    })(AST);
+    TypeScript.TypeQuery = TypeQuery;
+
+    var Block = (function (_super) {
+        __extends(Block, _super);
+        function Block(statements, closeBraceLeadingComments, closeBraceToken) {
+            _super.call(this);
+            this.statements = statements;
+            this.closeBraceLeadingComments = closeBraceLeadingComments;
+            this.closeBraceToken = closeBraceToken;
+            statements && (statements.parent = this);
+        }
+        Block.prototype.kind = function () {
+            return 146 /* Block */;
+        };
+
+        Block.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statements, ast.statements, includingPosition);
+        };
+        return Block;
+    })(AST);
+    TypeScript.Block = Block;
+
+    var Parameter = (function (_super) {
+        __extends(Parameter, _super);
+        function Parameter(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) {
+            _super.call(this);
+            this.dotDotDotToken = dotDotDotToken;
+            this.modifiers = modifiers;
+            this.identifier = identifier;
+            this.questionToken = questionToken;
+            this.typeAnnotation = typeAnnotation;
+            this.equalsValueClause = equalsValueClause;
+            identifier && (identifier.parent = this);
+            typeAnnotation && (typeAnnotation.parent = this);
+            equalsValueClause && (equalsValueClause.parent = this);
+        }
+        Parameter.prototype.kind = function () {
+            return 242 /* Parameter */;
+        };
+        return Parameter;
+    })(AST);
+    TypeScript.Parameter = Parameter;
+
+    var MemberAccessExpression = (function (_super) {
+        __extends(MemberAccessExpression, _super);
+        function MemberAccessExpression(expression, name) {
+            _super.call(this);
+            this.expression = expression;
+            this.name = name;
+            expression && (expression.parent = this);
+            name && (name.parent = this);
+        }
+        MemberAccessExpression.prototype.kind = function () {
+            return 212 /* MemberAccessExpression */;
+        };
+
+        MemberAccessExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.name, ast.name, includingPosition);
+        };
+
+        MemberAccessExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return MemberAccessExpression;
+    })(AST);
+    TypeScript.MemberAccessExpression = MemberAccessExpression;
+
+    var PostfixUnaryExpression = (function (_super) {
+        __extends(PostfixUnaryExpression, _super);
+        function PostfixUnaryExpression(_nodeType, operand) {
+            _super.call(this);
+            this._nodeType = _nodeType;
+            this.operand = operand;
+            operand && (operand.parent = this);
+        }
+        PostfixUnaryExpression.prototype.kind = function () {
+            return this._nodeType;
+        };
+
+        PostfixUnaryExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.operand, ast.operand, includingPosition);
+        };
+
+        PostfixUnaryExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return PostfixUnaryExpression;
+    })(AST);
+    TypeScript.PostfixUnaryExpression = PostfixUnaryExpression;
+
+    var ElementAccessExpression = (function (_super) {
+        __extends(ElementAccessExpression, _super);
+        function ElementAccessExpression(expression, argumentExpression) {
+            _super.call(this);
+            this.expression = expression;
+            this.argumentExpression = argumentExpression;
+            expression && (expression.parent = this);
+            argumentExpression && (argumentExpression.parent = this);
+        }
+        ElementAccessExpression.prototype.kind = function () {
+            return 221 /* ElementAccessExpression */;
+        };
+
+        ElementAccessExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.argumentExpression, ast.argumentExpression, includingPosition);
+        };
+
+        ElementAccessExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ElementAccessExpression;
+    })(AST);
+    TypeScript.ElementAccessExpression = ElementAccessExpression;
+
+    var InvocationExpression = (function (_super) {
+        __extends(InvocationExpression, _super);
+        function InvocationExpression(expression, argumentList) {
+            _super.call(this);
+            this.expression = expression;
+            this.argumentList = argumentList;
+            expression && (expression.parent = this);
+            argumentList && (argumentList.parent = this);
+        }
+        InvocationExpression.prototype.kind = function () {
+            return 213 /* InvocationExpression */;
+        };
+
+        InvocationExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.argumentList, ast.argumentList, includingPosition);
+        };
+
+        InvocationExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return InvocationExpression;
+    })(AST);
+    TypeScript.InvocationExpression = InvocationExpression;
+
+    var ArgumentList = (function (_super) {
+        __extends(ArgumentList, _super);
+        function ArgumentList(typeArgumentList, _arguments, closeParenToken) {
+            _super.call(this);
+            this.typeArgumentList = typeArgumentList;
+            this.closeParenToken = closeParenToken;
+            this.arguments = _arguments;
+
+            typeArgumentList && (typeArgumentList.parent = this);
+            _arguments && (_arguments.parent = this);
+        }
+        ArgumentList.prototype.kind = function () {
+            return 226 /* ArgumentList */;
+        };
+        return ArgumentList;
+    })(AST);
+    TypeScript.ArgumentList = ArgumentList;
+
+    var BinaryExpression = (function (_super) {
+        __extends(BinaryExpression, _super);
+        function BinaryExpression(_nodeType, left, right) {
+            _super.call(this);
+            this._nodeType = _nodeType;
+            this.left = left;
+            this.right = right;
+            left && (left.parent = this);
+            right && (right.parent = this);
+        }
+        BinaryExpression.prototype.kind = function () {
+            return this._nodeType;
+        };
+
+        BinaryExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.left, ast.left, includingPosition) && structuralEquals(this.right, ast.right, includingPosition);
+        };
+
+        BinaryExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return BinaryExpression;
+    })(AST);
+    TypeScript.BinaryExpression = BinaryExpression;
+
+    var ConditionalExpression = (function (_super) {
+        __extends(ConditionalExpression, _super);
+        function ConditionalExpression(condition, whenTrue, whenFalse) {
+            _super.call(this);
+            this.condition = condition;
+            this.whenTrue = whenTrue;
+            this.whenFalse = whenFalse;
+            condition && (condition.parent = this);
+            whenTrue && (whenTrue.parent = this);
+            whenFalse && (whenFalse.parent = this);
+        }
+        ConditionalExpression.prototype.kind = function () {
+            return 186 /* ConditionalExpression */;
+        };
+
+        ConditionalExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.whenTrue, ast.whenTrue, includingPosition) && structuralEquals(this.whenFalse, ast.whenFalse, includingPosition);
+        };
+
+        ConditionalExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ConditionalExpression;
+    })(AST);
+    TypeScript.ConditionalExpression = ConditionalExpression;
+
+    var ConstructSignature = (function (_super) {
+        __extends(ConstructSignature, _super);
+        function ConstructSignature(callSignature) {
+            _super.call(this);
+            this.callSignature = callSignature;
+            callSignature && (callSignature.parent = this);
+        }
+        ConstructSignature.prototype.kind = function () {
+            return 143 /* ConstructSignature */;
+        };
+        return ConstructSignature;
+    })(AST);
+    TypeScript.ConstructSignature = ConstructSignature;
+
+    var MethodSignature = (function (_super) {
+        __extends(MethodSignature, _super);
+        function MethodSignature(propertyName, questionToken, callSignature) {
+            _super.call(this);
+            this.propertyName = propertyName;
+            this.questionToken = questionToken;
+            this.callSignature = callSignature;
+            propertyName && (propertyName.parent = this);
+            callSignature && (callSignature.parent = this);
+        }
+        MethodSignature.prototype.kind = function () {
+            return 145 /* MethodSignature */;
+        };
+        return MethodSignature;
+    })(AST);
+    TypeScript.MethodSignature = MethodSignature;
+
+    var IndexSignature = (function (_super) {
+        __extends(IndexSignature, _super);
+        function IndexSignature(parameter, typeAnnotation) {
+            _super.call(this);
+            this.parameter = parameter;
+            this.typeAnnotation = typeAnnotation;
+            parameter && (parameter.parent = this);
+            typeAnnotation && (typeAnnotation.parent = this);
+        }
+        IndexSignature.prototype.kind = function () {
+            return 144 /* IndexSignature */;
+        };
+        return IndexSignature;
+    })(AST);
+    TypeScript.IndexSignature = IndexSignature;
+
+    var PropertySignature = (function (_super) {
+        __extends(PropertySignature, _super);
+        function PropertySignature(propertyName, questionToken, typeAnnotation) {
+            _super.call(this);
+            this.propertyName = propertyName;
+            this.questionToken = questionToken;
+            this.typeAnnotation = typeAnnotation;
+            propertyName && (propertyName.parent = this);
+            typeAnnotation && (typeAnnotation.parent = this);
+        }
+        PropertySignature.prototype.kind = function () {
+            return 141 /* PropertySignature */;
+        };
+        return PropertySignature;
+    })(AST);
+    TypeScript.PropertySignature = PropertySignature;
+
+    var CallSignature = (function (_super) {
+        __extends(CallSignature, _super);
+        function CallSignature(typeParameterList, parameterList, typeAnnotation) {
+            _super.call(this);
+            this.typeParameterList = typeParameterList;
+            this.parameterList = parameterList;
+            this.typeAnnotation = typeAnnotation;
+            typeParameterList && (typeParameterList.parent = this);
+            parameterList && (parameterList.parent = this);
+            typeAnnotation && (typeAnnotation.parent = this);
+        }
+        CallSignature.prototype.kind = function () {
+            return 142 /* CallSignature */;
+        };
+        return CallSignature;
+    })(AST);
+    TypeScript.CallSignature = CallSignature;
+
+    var TypeParameter = (function (_super) {
+        __extends(TypeParameter, _super);
+        function TypeParameter(identifier, constraint) {
+            _super.call(this);
+            this.identifier = identifier;
+            this.constraint = constraint;
+            identifier && (identifier.parent = this);
+            constraint && (constraint.parent = this);
+        }
+        TypeParameter.prototype.kind = function () {
+            return 238 /* TypeParameter */;
+        };
+
+        TypeParameter.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.constraint, ast.constraint, includingPosition);
+        };
+        return TypeParameter;
+    })(AST);
+    TypeScript.TypeParameter = TypeParameter;
+
+    var Constraint = (function (_super) {
+        __extends(Constraint, _super);
+        function Constraint(type) {
+            _super.call(this);
+            this.type = type;
+            type && (type.parent = this);
+        }
+        Constraint.prototype.kind = function () {
+            return 239 /* Constraint */;
+        };
+        return Constraint;
+    })(AST);
+    TypeScript.Constraint = Constraint;
+
+    var ElseClause = (function (_super) {
+        __extends(ElseClause, _super);
+        function ElseClause(statement) {
+            _super.call(this);
+            this.statement = statement;
+            statement && (statement.parent = this);
+        }
+        ElseClause.prototype.kind = function () {
+            return 235 /* ElseClause */;
+        };
+
+        ElseClause.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition);
+        };
+        return ElseClause;
+    })(AST);
+    TypeScript.ElseClause = ElseClause;
+
+    var IfStatement = (function (_super) {
+        __extends(IfStatement, _super);
+        function IfStatement(condition, statement, elseClause) {
+            _super.call(this);
+            this.condition = condition;
+            this.statement = statement;
+            this.elseClause = elseClause;
+            condition && (condition.parent = this);
+            statement && (statement.parent = this);
+            elseClause && (elseClause.parent = this);
+        }
+        IfStatement.prototype.kind = function () {
+            return 147 /* IfStatement */;
+        };
+
+        IfStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition) && structuralEquals(this.elseClause, ast.elseClause, includingPosition);
+        };
+        return IfStatement;
+    })(AST);
+    TypeScript.IfStatement = IfStatement;
+
+    var ExpressionStatement = (function (_super) {
+        __extends(ExpressionStatement, _super);
+        function ExpressionStatement(expression) {
+            _super.call(this);
+            this.expression = expression;
+            expression && (expression.parent = this);
+        }
+        ExpressionStatement.prototype.kind = function () {
+            return 149 /* ExpressionStatement */;
+        };
+
+        ExpressionStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+        return ExpressionStatement;
+    })(AST);
+    TypeScript.ExpressionStatement = ExpressionStatement;
+
+    var ConstructorDeclaration = (function (_super) {
+        __extends(ConstructorDeclaration, _super);
+        function ConstructorDeclaration(callSignature, block) {
+            _super.call(this);
+            this.callSignature = callSignature;
+            this.block = block;
+            callSignature && (callSignature.parent = this);
+            block && (block.parent = this);
+        }
+        ConstructorDeclaration.prototype.kind = function () {
+            return 137 /* ConstructorDeclaration */;
+        };
+        return ConstructorDeclaration;
+    })(AST);
+    TypeScript.ConstructorDeclaration = ConstructorDeclaration;
+
+    var MemberFunctionDeclaration = (function (_super) {
+        __extends(MemberFunctionDeclaration, _super);
+        function MemberFunctionDeclaration(modifiers, propertyName, callSignature, block) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.propertyName = propertyName;
+            this.callSignature = callSignature;
+            this.block = block;
+            propertyName && (propertyName.parent = this);
+            callSignature && (callSignature.parent = this);
+            block && (block.parent = this);
+        }
+        MemberFunctionDeclaration.prototype.kind = function () {
+            return 135 /* MemberFunctionDeclaration */;
+        };
+        return MemberFunctionDeclaration;
+    })(AST);
+    TypeScript.MemberFunctionDeclaration = MemberFunctionDeclaration;
+
+    var GetAccessor = (function (_super) {
+        __extends(GetAccessor, _super);
+        function GetAccessor(modifiers, propertyName, parameterList, typeAnnotation, block) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.propertyName = propertyName;
+            this.parameterList = parameterList;
+            this.typeAnnotation = typeAnnotation;
+            this.block = block;
+            propertyName && (propertyName.parent = this);
+            parameterList && (parameterList.parent = this);
+            typeAnnotation && (typeAnnotation.parent = this);
+            block && (block.parent = this);
+        }
+        GetAccessor.prototype.kind = function () {
+            return 139 /* GetAccessor */;
+        };
+        return GetAccessor;
+    })(AST);
+    TypeScript.GetAccessor = GetAccessor;
+
+    var SetAccessor = (function (_super) {
+        __extends(SetAccessor, _super);
+        function SetAccessor(modifiers, propertyName, parameterList, block) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.propertyName = propertyName;
+            this.parameterList = parameterList;
+            this.block = block;
+            propertyName && (propertyName.parent = this);
+            parameterList && (parameterList.parent = this);
+            block && (block.parent = this);
+        }
+        SetAccessor.prototype.kind = function () {
+            return 140 /* SetAccessor */;
+        };
+        return SetAccessor;
+    })(AST);
+    TypeScript.SetAccessor = SetAccessor;
+
+    var MemberVariableDeclaration = (function (_super) {
+        __extends(MemberVariableDeclaration, _super);
+        function MemberVariableDeclaration(modifiers, variableDeclarator) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.variableDeclarator = variableDeclarator;
+            variableDeclarator && (variableDeclarator.parent = this);
+        }
+        MemberVariableDeclaration.prototype.kind = function () {
+            return 136 /* MemberVariableDeclaration */;
+        };
+        return MemberVariableDeclaration;
+    })(AST);
+    TypeScript.MemberVariableDeclaration = MemberVariableDeclaration;
+
+    var IndexMemberDeclaration = (function (_super) {
+        __extends(IndexMemberDeclaration, _super);
+        function IndexMemberDeclaration(indexSignature) {
+            _super.call(this);
+            this.indexSignature = indexSignature;
+            indexSignature && (indexSignature.parent = this);
+        }
+        IndexMemberDeclaration.prototype.kind = function () {
+            return 138 /* IndexMemberDeclaration */;
+        };
+        return IndexMemberDeclaration;
+    })(AST);
+    TypeScript.IndexMemberDeclaration = IndexMemberDeclaration;
+
+    var ThrowStatement = (function (_super) {
+        __extends(ThrowStatement, _super);
+        function ThrowStatement(expression) {
+            _super.call(this);
+            this.expression = expression;
+            expression && (expression.parent = this);
+        }
+        ThrowStatement.prototype.kind = function () {
+            return 157 /* ThrowStatement */;
+        };
+
+        ThrowStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+        return ThrowStatement;
+    })(AST);
+    TypeScript.ThrowStatement = ThrowStatement;
+
+    var ReturnStatement = (function (_super) {
+        __extends(ReturnStatement, _super);
+        function ReturnStatement(expression) {
+            _super.call(this);
+            this.expression = expression;
+            expression && (expression.parent = this);
+        }
+        ReturnStatement.prototype.kind = function () {
+            return 150 /* ReturnStatement */;
+        };
+
+        ReturnStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+        return ReturnStatement;
+    })(AST);
+    TypeScript.ReturnStatement = ReturnStatement;
+
+    var ObjectCreationExpression = (function (_super) {
+        __extends(ObjectCreationExpression, _super);
+        function ObjectCreationExpression(expression, argumentList) {
+            _super.call(this);
+            this.expression = expression;
+            this.argumentList = argumentList;
+            expression && (expression.parent = this);
+            argumentList && (argumentList.parent = this);
+        }
+        ObjectCreationExpression.prototype.kind = function () {
+            return 216 /* ObjectCreationExpression */;
+        };
+
+        ObjectCreationExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.argumentList, ast.argumentList, includingPosition);
+        };
+
+        ObjectCreationExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ObjectCreationExpression;
+    })(AST);
+    TypeScript.ObjectCreationExpression = ObjectCreationExpression;
+
+    var SwitchStatement = (function (_super) {
+        __extends(SwitchStatement, _super);
+        function SwitchStatement(expression, closeParenToken, switchClauses) {
+            _super.call(this);
+            this.expression = expression;
+            this.closeParenToken = closeParenToken;
+            this.switchClauses = switchClauses;
+            expression && (expression.parent = this);
+            switchClauses && (switchClauses.parent = this);
+        }
+        SwitchStatement.prototype.kind = function () {
+            return 151 /* SwitchStatement */;
+        };
+
+        SwitchStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.switchClauses, ast.switchClauses, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+        return SwitchStatement;
+    })(AST);
+    TypeScript.SwitchStatement = SwitchStatement;
+
+    var CaseSwitchClause = (function (_super) {
+        __extends(CaseSwitchClause, _super);
+        function CaseSwitchClause(expression, statements) {
+            _super.call(this);
+            this.expression = expression;
+            this.statements = statements;
+            expression && (expression.parent = this);
+            statements && (statements.parent = this);
+        }
+        CaseSwitchClause.prototype.kind = function () {
+            return 233 /* CaseSwitchClause */;
+        };
+
+        CaseSwitchClause.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.statements, ast.statements, includingPosition);
+        };
+        return CaseSwitchClause;
+    })(AST);
+    TypeScript.CaseSwitchClause = CaseSwitchClause;
+
+    var DefaultSwitchClause = (function (_super) {
+        __extends(DefaultSwitchClause, _super);
+        function DefaultSwitchClause(statements) {
+            _super.call(this);
+            this.statements = statements;
+            statements && (statements.parent = this);
+        }
+        DefaultSwitchClause.prototype.kind = function () {
+            return 234 /* DefaultSwitchClause */;
+        };
+
+        DefaultSwitchClause.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statements, ast.statements, includingPosition);
+        };
+        return DefaultSwitchClause;
+    })(AST);
+    TypeScript.DefaultSwitchClause = DefaultSwitchClause;
+
+    var BreakStatement = (function (_super) {
+        __extends(BreakStatement, _super);
+        function BreakStatement(identifier) {
+            _super.call(this);
+            this.identifier = identifier;
+        }
+        BreakStatement.prototype.kind = function () {
+            return 152 /* BreakStatement */;
+        };
+
+        BreakStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition);
+        };
+        return BreakStatement;
+    })(AST);
+    TypeScript.BreakStatement = BreakStatement;
+
+    var ContinueStatement = (function (_super) {
+        __extends(ContinueStatement, _super);
+        function ContinueStatement(identifier) {
+            _super.call(this);
+            this.identifier = identifier;
+        }
+        ContinueStatement.prototype.kind = function () {
+            return 153 /* ContinueStatement */;
+        };
+
+        ContinueStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition);
+        };
+        return ContinueStatement;
+    })(AST);
+    TypeScript.ContinueStatement = ContinueStatement;
+
+    var ForStatement = (function (_super) {
+        __extends(ForStatement, _super);
+        function ForStatement(variableDeclaration, initializer, condition, incrementor, statement) {
+            _super.call(this);
+            this.variableDeclaration = variableDeclaration;
+            this.initializer = initializer;
+            this.condition = condition;
+            this.incrementor = incrementor;
+            this.statement = statement;
+            variableDeclaration && (variableDeclaration.parent = this);
+            initializer && (initializer.parent = this);
+            condition && (condition.parent = this);
+            incrementor && (incrementor.parent = this);
+            statement && (statement.parent = this);
+        }
+        ForStatement.prototype.kind = function () {
+            return 154 /* ForStatement */;
+        };
+
+        ForStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.initializer, ast.initializer, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.incrementor, ast.incrementor, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition);
+        };
+        return ForStatement;
+    })(AST);
+    TypeScript.ForStatement = ForStatement;
+
+    var ForInStatement = (function (_super) {
+        __extends(ForInStatement, _super);
+        function ForInStatement(variableDeclaration, left, expression, statement) {
+            _super.call(this);
+            this.variableDeclaration = variableDeclaration;
+            this.left = left;
+            this.expression = expression;
+            this.statement = statement;
+            variableDeclaration && (variableDeclaration.parent = this);
+            left && (left.parent = this);
+            expression && (expression.parent = this);
+            statement && (statement.parent = this);
+        }
+        ForInStatement.prototype.kind = function () {
+            return 155 /* ForInStatement */;
+        };
+
+        ForInStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.variableDeclaration, ast.variableDeclaration, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition);
+        };
+        return ForInStatement;
+    })(AST);
+    TypeScript.ForInStatement = ForInStatement;
+
+    var WhileStatement = (function (_super) {
+        __extends(WhileStatement, _super);
+        function WhileStatement(condition, statement) {
+            _super.call(this);
+            this.condition = condition;
+            this.statement = statement;
+            condition && (condition.parent = this);
+            statement && (statement.parent = this);
+        }
+        WhileStatement.prototype.kind = function () {
+            return 158 /* WhileStatement */;
+        };
+
+        WhileStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition);
+        };
+        return WhileStatement;
+    })(AST);
+    TypeScript.WhileStatement = WhileStatement;
+
+    var WithStatement = (function (_super) {
+        __extends(WithStatement, _super);
+        function WithStatement(condition, statement) {
+            _super.call(this);
+            this.condition = condition;
+            this.statement = statement;
+            condition && (condition.parent = this);
+            statement && (statement.parent = this);
+        }
+        WithStatement.prototype.kind = function () {
+            return 163 /* WithStatement */;
+        };
+
+        WithStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition);
+        };
+        return WithStatement;
+    })(AST);
+    TypeScript.WithStatement = WithStatement;
+
+    var EnumDeclaration = (function (_super) {
+        __extends(EnumDeclaration, _super);
+        function EnumDeclaration(modifiers, identifier, enumElements) {
+            _super.call(this);
+            this.modifiers = modifiers;
+            this.identifier = identifier;
+            this.enumElements = enumElements;
+            identifier && (identifier.parent = this);
+            enumElements && (enumElements.parent = this);
+        }
+        EnumDeclaration.prototype.kind = function () {
+            return 132 /* EnumDeclaration */;
+        };
+        return EnumDeclaration;
+    })(AST);
+    TypeScript.EnumDeclaration = EnumDeclaration;
+
+    var EnumElement = (function (_super) {
+        __extends(EnumElement, _super);
+        function EnumElement(propertyName, equalsValueClause) {
+            _super.call(this);
+            this.propertyName = propertyName;
+            this.equalsValueClause = equalsValueClause;
+            propertyName && (propertyName.parent = this);
+            equalsValueClause && (equalsValueClause.parent = this);
+        }
+        EnumElement.prototype.kind = function () {
+            return 243 /* EnumElement */;
+        };
+        return EnumElement;
+    })(AST);
+    TypeScript.EnumElement = EnumElement;
+
+    var CastExpression = (function (_super) {
+        __extends(CastExpression, _super);
+        function CastExpression(type, expression) {
+            _super.call(this);
+            this.type = type;
+            this.expression = expression;
+            type && (type.parent = this);
+            expression && (expression.parent = this);
+        }
+        CastExpression.prototype.kind = function () {
+            return 220 /* CastExpression */;
+        };
+
+        CastExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.type, ast.type, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+
+        CastExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return CastExpression;
+    })(AST);
+    TypeScript.CastExpression = CastExpression;
+
+    var ObjectLiteralExpression = (function (_super) {
+        __extends(ObjectLiteralExpression, _super);
+        function ObjectLiteralExpression(propertyAssignments) {
+            _super.call(this);
+            this.propertyAssignments = propertyAssignments;
+            propertyAssignments && (propertyAssignments.parent = this);
+        }
+        ObjectLiteralExpression.prototype.kind = function () {
+            return 215 /* ObjectLiteralExpression */;
+        };
+
+        ObjectLiteralExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.propertyAssignments, ast.propertyAssignments, includingPosition);
+        };
+
+        ObjectLiteralExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return ObjectLiteralExpression;
+    })(AST);
+    TypeScript.ObjectLiteralExpression = ObjectLiteralExpression;
+
+    var SimplePropertyAssignment = (function (_super) {
+        __extends(SimplePropertyAssignment, _super);
+        function SimplePropertyAssignment(propertyName, expression) {
+            _super.call(this);
+            this.propertyName = propertyName;
+            this.expression = expression;
+            propertyName && (propertyName.parent = this);
+            expression && (expression.parent = this);
+        }
+        SimplePropertyAssignment.prototype.kind = function () {
+            return 240 /* SimplePropertyAssignment */;
+        };
+        return SimplePropertyAssignment;
+    })(AST);
+    TypeScript.SimplePropertyAssignment = SimplePropertyAssignment;
+
+    var FunctionPropertyAssignment = (function (_super) {
+        __extends(FunctionPropertyAssignment, _super);
+        function FunctionPropertyAssignment(propertyName, callSignature, block) {
+            _super.call(this);
+            this.propertyName = propertyName;
+            this.callSignature = callSignature;
+            this.block = block;
+            propertyName && (propertyName.parent = this);
+            callSignature && (callSignature.parent = this);
+            block && (block.parent = this);
+        }
+        FunctionPropertyAssignment.prototype.kind = function () {
+            return 241 /* FunctionPropertyAssignment */;
+        };
+        return FunctionPropertyAssignment;
+    })(AST);
+    TypeScript.FunctionPropertyAssignment = FunctionPropertyAssignment;
+
+    var FunctionExpression = (function (_super) {
+        __extends(FunctionExpression, _super);
+        function FunctionExpression(identifier, callSignature, block) {
+            _super.call(this);
+            this.identifier = identifier;
+            this.callSignature = callSignature;
+            this.block = block;
+            identifier && (identifier.parent = this);
+            callSignature && (callSignature.parent = this);
+            block && (block.parent = this);
+        }
+        FunctionExpression.prototype.kind = function () {
+            return 222 /* FunctionExpression */;
+        };
+
+        FunctionExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return FunctionExpression;
+    })(AST);
+    TypeScript.FunctionExpression = FunctionExpression;
+
+    var EmptyStatement = (function (_super) {
+        __extends(EmptyStatement, _super);
+        function EmptyStatement() {
+            _super.apply(this, arguments);
+        }
+        EmptyStatement.prototype.kind = function () {
+            return 156 /* EmptyStatement */;
+        };
+
+        EmptyStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition);
+        };
+        return EmptyStatement;
+    })(AST);
+    TypeScript.EmptyStatement = EmptyStatement;
+
+    var TryStatement = (function (_super) {
+        __extends(TryStatement, _super);
+        function TryStatement(block, catchClause, finallyClause) {
+            _super.call(this);
+            this.block = block;
+            this.catchClause = catchClause;
+            this.finallyClause = finallyClause;
+            block && (block.parent = this);
+            catchClause && (catchClause.parent = this);
+            finallyClause && (finallyClause.parent = this);
+        }
+        TryStatement.prototype.kind = function () {
+            return 159 /* TryStatement */;
+        };
+
+        TryStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.block, ast.block, includingPosition) && structuralEquals(this.catchClause, ast.catchClause, includingPosition) && structuralEquals(this.finallyClause, ast.finallyClause, includingPosition);
+        };
+        return TryStatement;
+    })(AST);
+    TypeScript.TryStatement = TryStatement;
+
+    var CatchClause = (function (_super) {
+        __extends(CatchClause, _super);
+        function CatchClause(identifier, typeAnnotation, block) {
+            _super.call(this);
+            this.identifier = identifier;
+            this.typeAnnotation = typeAnnotation;
+            this.block = block;
+            identifier && (identifier.parent = this);
+            typeAnnotation && (typeAnnotation.parent = this);
+            block && (block.parent = this);
+        }
+        CatchClause.prototype.kind = function () {
+            return 236 /* CatchClause */;
+        };
+
+        CatchClause.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.typeAnnotation, ast.typeAnnotation, includingPosition) && structuralEquals(this.block, ast.block, includingPosition);
+        };
+        return CatchClause;
+    })(AST);
+    TypeScript.CatchClause = CatchClause;
+
+    var FinallyClause = (function (_super) {
+        __extends(FinallyClause, _super);
+        function FinallyClause(block) {
+            _super.call(this);
+            this.block = block;
+            block && (block.parent = this);
+        }
+        FinallyClause.prototype.kind = function () {
+            return 237 /* FinallyClause */;
+        };
+
+        FinallyClause.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.block, ast.block, includingPosition);
+        };
+        return FinallyClause;
+    })(AST);
+    TypeScript.FinallyClause = FinallyClause;
+
+    var LabeledStatement = (function (_super) {
+        __extends(LabeledStatement, _super);
+        function LabeledStatement(identifier, statement) {
+            _super.call(this);
+            this.identifier = identifier;
+            this.statement = statement;
+            identifier && (identifier.parent = this);
+            statement && (statement.parent = this);
+        }
+        LabeledStatement.prototype.kind = function () {
+            return 160 /* LabeledStatement */;
+        };
+
+        LabeledStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition);
+        };
+        return LabeledStatement;
+    })(AST);
+    TypeScript.LabeledStatement = LabeledStatement;
+
+    var DoStatement = (function (_super) {
+        __extends(DoStatement, _super);
+        function DoStatement(statement, whileKeyword, condition) {
+            _super.call(this);
+            this.statement = statement;
+            this.whileKeyword = whileKeyword;
+            this.condition = condition;
+            statement && (statement.parent = this);
+            condition && (condition.parent = this);
+        }
+        DoStatement.prototype.kind = function () {
+            return 161 /* DoStatement */;
+        };
+
+        DoStatement.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition);
+        };
+        return DoStatement;
+    })(AST);
+    TypeScript.DoStatement = DoStatement;
+
+    var TypeOfExpression = (function (_super) {
+        __extends(TypeOfExpression, _super);
+        function TypeOfExpression(expression) {
+            _super.call(this);
+            this.expression = expression;
+            expression && (expression.parent = this);
+        }
+        TypeOfExpression.prototype.kind = function () {
+            return 171 /* TypeOfExpression */;
+        };
+
+        TypeOfExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+
+        TypeOfExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return TypeOfExpression;
+    })(AST);
+    TypeScript.TypeOfExpression = TypeOfExpression;
+
+    var DeleteExpression = (function (_super) {
+        __extends(DeleteExpression, _super);
+        function DeleteExpression(expression) {
+            _super.call(this);
+            this.expression = expression;
+            expression && (expression.parent = this);
+        }
+        DeleteExpression.prototype.kind = function () {
+            return 170 /* DeleteExpression */;
+        };
+
+        DeleteExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+
+        DeleteExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return DeleteExpression;
+    })(AST);
+    TypeScript.DeleteExpression = DeleteExpression;
+
+    var VoidExpression = (function (_super) {
+        __extends(VoidExpression, _super);
+        function VoidExpression(expression) {
+            _super.call(this);
+            this.expression = expression;
+            expression && (expression.parent = this);
+        }
+        VoidExpression.prototype.kind = function () {
+            return 172 /* VoidExpression */;
+        };
+
+        VoidExpression.prototype.structuralEquals = function (ast, includingPosition) {
+            return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition);
+        };
+
+        VoidExpression.prototype.isExpression = function () {
+            return true;
+        };
+        return VoidExpression;
+    })(AST);
+    TypeScript.VoidExpression = VoidExpression;
+
+    var DebuggerStatement = (function (_super) {
+        __extends(DebuggerStatement, _super);
+        function DebuggerStatement() {
+            _super.apply(this, arguments);
+        }
+        DebuggerStatement.prototype.kind = function () {
+            return 162 /* DebuggerStatement */;
+        };
+        return DebuggerStatement;
+    })(AST);
+    TypeScript.DebuggerStatement = DebuggerStatement;
+
+    var Comment = (function () {
+        function Comment(_trivia, endsLine, _start, _end) {
+            this._trivia = _trivia;
+            this.endsLine = endsLine;
+            this._start = _start;
+            this._end = _end;
+        }
+        Comment.prototype.start = function () {
+            return this._start;
+        };
+
+        Comment.prototype.end = function () {
+            return this._end;
+        };
+
+        Comment.prototype.fullText = function () {
+            return this._trivia.fullText();
+        };
+
+        Comment.prototype.kind = function () {
+            return this._trivia.kind();
+        };
+
+        Comment.prototype.structuralEquals = function (ast, includingPosition) {
+            if (includingPosition) {
+                if (this.start() !== ast.start() || this.end() !== ast.end()) {
+                    return false;
+                }
+            }
+
+            return this._trivia.fullText() === ast._trivia.fullText() && this.endsLine === ast.endsLine;
+        };
+        return Comment;
+    })();
+    TypeScript.Comment = Comment;
+})(TypeScript || (TypeScript = {}));

From 5766af981195ff14fe09abb96d9b46ddf20d112b Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Thu, 3 Apr 2014 09:23:12 +0900
Subject: [PATCH 276/309] update package.json run script. 0.9.7 to 1.0.0.

---
 package.json | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/package.json b/package.json
index aded68951..c4c29460a 100644
--- a/package.json
+++ b/package.json
@@ -20,10 +20,10 @@
     "node": ">= 0.10.0"
   },
   "scripts": {
-    "test": "node ./_infrastructure/tests/runner.js --tsc-version 0.9.7 --test-changes",
-    "all": "node ./_infrastructure/tests/runner.js --tsc-version 0.9.7",
-    "dry": "node ./_infrastructure/tests/runner.js --tsc-version 0.9.7 --skip-tests --test-changes",
-    "list": "node ./_infrastructure/tests/runner.js --tsc-version 0.9.7 --skip-tests --print-files --print-refmap",
+    "test": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0 --test-changes",
+    "all": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0",
+    "dry": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0 --skip-tests --test-changes",
+    "list": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0 --skip-tests --print-files --print-refmap",
     "help": "node ./_infrastructure/tests/runner.js -h"
   },
   "dependencies": {

From 4f226b26506896b04d0c37efe6b267a64c3734d1 Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Thu, 3 Apr 2014 09:31:52 +0900
Subject: [PATCH 277/309] fix urlrouter/urlrouter.d.ts

---
 urlrouter/urlrouter-tests.ts |   2 +-
 urlrouter/urlrouter.d.ts     | 120 +++++++++++++++++------------------
 2 files changed, 61 insertions(+), 61 deletions(-)

diff --git a/urlrouter/urlrouter-tests.ts b/urlrouter/urlrouter-tests.ts
index c1411c3a3..713b8cfe4 100644
--- a/urlrouter/urlrouter-tests.ts
+++ b/urlrouter/urlrouter-tests.ts
@@ -16,4 +16,4 @@ var req: urlrouter.ServerRequest;
 var res: urlrouter.ServerResponse;
 function next() { }
 
-result(req, res, next);
\ No newline at end of file
+result(req, res, next);
diff --git a/urlrouter/urlrouter.d.ts b/urlrouter/urlrouter.d.ts
index 925484308..732f7a05c 100644
--- a/urlrouter/urlrouter.d.ts
+++ b/urlrouter/urlrouter.d.ts
@@ -5,65 +5,65 @@
 
 /// <reference path="../node/node.d.ts" />
 
-declare module "_UrlRouterInternal" {
-    import http = require("http");
-
-    export interface ServerRequest extends http.ServerRequest {
-        params: any;
-    }
-
-    export interface ServerResponse extends http.ServerResponse {
-
-    }
-
-    export interface App {
-        // https://github.com/visionmedia/node-methods/blob/master/index.js
-        get(urlpattern: string, handler: HttpHandler): void;
-        post(urlpattern: string, handler: HttpHandler): void;
-        put(urlpattern: string, handler: HttpHandler): void;
-        head(urlpattern: string, handler: HttpHandler): void;
-        delete(urlpattern: string, handler: HttpHandler): void;
-        options(urlpattern: string, handler: HttpHandler): void;
-        trace(urlpattern: string, handler: HttpHandler): void;
-        copy(urlpattern: string, handler: HttpHandler): void;
-        lock(urlpattern: string, handler: HttpHandler): void;
-        mkcol(urlpattern: string, handler: HttpHandler): void;
-        move(urlpattern: string, handler: HttpHandler): void;
-        propfind(urlpattern: string, handler: HttpHandler): void;
-        proppatch(urlpattern: string, handler: HttpHandler): void;
-        unlock(urlpattern: string, handler: HttpHandler): void;
-        report(urlpattern: string, handler: HttpHandler): void;
-        mkactivity(urlpattern: string, handler: HttpHandler): void;
-        checkout(urlpattern: string, handler: HttpHandler): void;
-        merge(urlpattern: string, handler: HttpHandler): void;
-        "m-search"(urlpattern: string, handler: HttpHandler): void;
-        notify(urlpattern: string, handler: HttpHandler): void;
-        subscribe(urlpattern: string, handler: HttpHandler): void;
-        unsubscribe(urlpattern: string, handler: HttpHandler): void;
-        patch(urlpattern: string, handler: HttpHandler): void;
-        search(urlpattern: string, handler: HttpHandler): void;
-
-        all(urlpattern: string, handler: HttpHandler): void;
-        redirect(urlpattern: string, to: string): void;
-    }
-
-    export interface Options {
-        paramsName?: string;
-        pageNotFound?: (req: ServerRequest, res: ServerResponse) => void;
-        errorHandler?: (err:Error, req: ServerRequest, res: ServerResponse) => void;
-    }
-
-    export function _UrlRouterfunc(handler: (app: App) => void, options?: any): void;
-
-    export interface HttpHandler {
-        (req: ServerRequest, res: ServerResponse, next?: () => void): void;
-    }
-
-}
-
 declare module "urlrouter" {
-    import _UrlRouterInternal = require("_UrlRouterInternal");
+	import http = require("http");
 
-    function _UrlRouterInternal(handler: (app: _UrlRouterInternal.App) => void): _UrlRouterInternal.HttpHandler;
-    export = _UrlRouterInternal;
-}
\ No newline at end of file
+	function UrlRouterInternal(handler:(app:UrlRouterInternal.App) => void):UrlRouterInternal.HttpHandler;
+
+	module UrlRouterInternal {
+
+
+		interface ServerRequest extends http.ServerRequest {
+			params: any;
+		}
+
+		interface ServerResponse extends http.ServerResponse {
+
+		}
+
+		interface App {
+			// https://github.com/visionmedia/node-methods/blob/master/index.js
+			get(urlpattern:string, handler:HttpHandler): void;
+			post(urlpattern:string, handler:HttpHandler): void;
+			put(urlpattern:string, handler:HttpHandler): void;
+			head(urlpattern:string, handler:HttpHandler): void;
+			delete(urlpattern:string, handler:HttpHandler): void;
+			options(urlpattern:string, handler:HttpHandler): void;
+			trace(urlpattern:string, handler:HttpHandler): void;
+			copy(urlpattern:string, handler:HttpHandler): void;
+			lock(urlpattern:string, handler:HttpHandler): void;
+			mkcol(urlpattern:string, handler:HttpHandler): void;
+			move(urlpattern:string, handler:HttpHandler): void;
+			propfind(urlpattern:string, handler:HttpHandler): void;
+			proppatch(urlpattern:string, handler:HttpHandler): void;
+			unlock(urlpattern:string, handler:HttpHandler): void;
+			report(urlpattern:string, handler:HttpHandler): void;
+			mkactivity(urlpattern:string, handler:HttpHandler): void;
+			checkout(urlpattern:string, handler:HttpHandler): void;
+			merge(urlpattern:string, handler:HttpHandler): void;
+			"m-search"(urlpattern:string, handler:HttpHandler): void;
+			notify(urlpattern:string, handler:HttpHandler): void;
+			subscribe(urlpattern:string, handler:HttpHandler): void;
+			unsubscribe(urlpattern:string, handler:HttpHandler): void;
+			patch(urlpattern:string, handler:HttpHandler): void;
+			search(urlpattern:string, handler:HttpHandler): void;
+
+			all(urlpattern:string, handler:HttpHandler): void;
+			redirect(urlpattern:string, to:string): void;
+		}
+
+		interface Options {
+			paramsName?: string;
+			pageNotFound?: (req:ServerRequest, res:ServerResponse) => void;
+			errorHandler?: (err:Error, req:ServerRequest, res:ServerResponse) => void;
+		}
+
+		function _UrlRouterfunc(handler:(app:App) => void, options?:any):void;
+
+		interface HttpHandler {
+			(req:ServerRequest, res:ServerResponse, next?:() => void): void;
+		}
+	}
+
+	export = UrlRouterInternal;
+}

From a535e49f08a3a89a3e45bd12ebfd0cadc96b96a7 Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Thu, 3 Apr 2014 09:45:35 +0900
Subject: [PATCH 278/309] change package.json, test of --test-changes to test
 all

---
 package.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/package.json b/package.json
index c4c29460a..9ac814723 100644
--- a/package.json
+++ b/package.json
@@ -20,7 +20,8 @@
     "node": ">= 0.10.0"
   },
   "scripts": {
-    "test": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0 --test-changes",
+    "test": "npm run all",
+    "changes": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0 --test-changes",
     "all": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0",
     "dry": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0 --skip-tests --test-changes",
     "list": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0 --skip-tests --print-files --print-refmap",

From 268ca8a9c2fc110351afe5a4f1463439ba6afc96 Mon Sep 17 00:00:00 2001
From: satoru kimura <s_kimura@sa.il24.net>
Date: Thu, 3 Apr 2014 11:40:20 +0900
Subject: [PATCH 279/309] Fixed nomnom.d.ts for TypeScript 1.0.0.

---
 nomnom/nomnom.d.ts | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/nomnom/nomnom.d.ts b/nomnom/nomnom.d.ts
index 2e7259939..d5efd88d5 100644
--- a/nomnom/nomnom.d.ts
+++ b/nomnom/nomnom.d.ts
@@ -3,7 +3,7 @@
 // Definitions by: Paul Vick <https://github.com/panopticoncentral>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-declare module "nomnom"
+declare module nomnom_internal
 {
     /**
      * The command-line parser.
@@ -137,7 +137,7 @@ declare module "nomnom"
     /**
      * The command-line parser.
      */
-    interface Parser
+    export interface Parser
     {
         /**
          * Returns the parser.
@@ -220,6 +220,9 @@ declare module "nomnom"
          */
         parse(argv?: string[]): any;
     }
+}
 
-    export = Parser;
+declare var nomnom: nomnom_internal.Parser;
+declare module "nomnom" {
+    export = nomnom;
 }

From 05a7e0f0312d0124cd84255ff05c0058e0fdea58 Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Thu, 3 Apr 2014 13:29:24 +0900
Subject: [PATCH 280/309] add note and rename variable name.

---
 nomnom/nomnom.d.ts | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/nomnom/nomnom.d.ts b/nomnom/nomnom.d.ts
index d5efd88d5..19ce73c7b 100644
--- a/nomnom/nomnom.d.ts
+++ b/nomnom/nomnom.d.ts
@@ -3,7 +3,10 @@
 // Definitions by: Paul Vick <https://github.com/panopticoncentral>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-declare module nomnom_internal
+// NOTE: Extra identifier's been published is a work-around for the TypeScript 1.0.0.
+// original is here -> https://github.com/borisyankov/DefinitelyTyped/commit/9aef1ad84dc006e3d25f5e57709198e33996ba84#diff-0d78c90325d4bfb40327dcc36dcd939a
+
+declare module NomnomInternal
 {
     /**
      * The command-line parser.
@@ -222,7 +225,7 @@ declare module nomnom_internal
     }
 }
 
-declare var nomnom: nomnom_internal.Parser;
+declare var _nomnom: NomnomInternal.Parser;
 declare module "nomnom" {
-    export = nomnom;
+    export = _nomnom;
 }

From 3c1837162b19bc3313917ff9145cb786cd5d78c8 Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Thu, 3 Apr 2014 13:36:36 +0900
Subject: [PATCH 281/309] fix should/should.d.ts

---
 should/should.d.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/should/should.d.ts b/should/should.d.ts
index b3c37846a..13eca9ccf 100644
--- a/should/should.d.ts
+++ b/should/should.d.ts
@@ -111,8 +111,8 @@ interface Internal extends ShouldInternal {
   inspect(value: any, obj: any): any;
 }
 
-declare module "should" {
-  export = Internal;
-}
-
 declare var should: Internal;
+
+declare module "should" {
+  export = should;
+}

From 74f2d37b34b61ec5ee61d4cfdd9cde7b03f9a8d1 Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Thu, 3 Apr 2014 13:54:02 +0900
Subject: [PATCH 282/309] change package.json, test all to test changes

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 9ac814723..2002f0b19 100644
--- a/package.json
+++ b/package.json
@@ -20,7 +20,7 @@
     "node": ">= 0.10.0"
   },
   "scripts": {
-    "test": "npm run all",
+    "test": "npm run changes",
     "changes": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0 --test-changes",
     "all": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0",
     "dry": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0 --skip-tests --test-changes",

From 4370a43172b55754a481157a52ceb53e0dd95149 Mon Sep 17 00:00:00 2001
From: enternet <ad@ad.by>
Date: Thu, 3 Apr 2014 12:41:24 +0300
Subject: [PATCH 283/309] Compability with --noImplicitAny option.

The module will be compatible with --noImplicitAny option of tsc compiler.
---
 d3/plugins/d3.superformula.d.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/d3/plugins/d3.superformula.d.ts b/d3/plugins/d3.superformula.d.ts
index ce649446b..6f5c59b07 100644
--- a/d3/plugins/d3.superformula.d.ts
+++ b/d3/plugins/d3.superformula.d.ts
@@ -10,7 +10,7 @@ declare module D3 {
 
     interface SuperformulaType
     {
-        (any): any;//hans
+        (any: any): any;//hans
         m: number;
         n1: number;
         n2: number;
@@ -22,7 +22,7 @@ declare module D3 {
     interface Superformula
     {
         (): any;
-        type(any): any;
+        type(any: any): any;
         param(name: string, value: number): Superformula;
         size(x: number): Superformula;
         segments(x: number): Superformula;
@@ -35,4 +35,4 @@ declare module D3 {
         superformulaPath: SuperformulaPath;
         superformulaTypes: SuperformulaType[];
     }
-}
\ No newline at end of file
+}

From 82f2b025da31cce674b1262818296ef71fd98a8e Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Thu, 3 Apr 2014 18:19:48 +0400
Subject: [PATCH 284/309] RxJS: *-lite.ts renamed to *-lite.d.ts (to contribute
 with package)

---
 rx.js/{rx-lite.ts => rx-lite.d.ts}                     |  0
 rx.js/{rx.async-lite.ts => rx.async-lite.d.ts}         |  0
 rx.js/rx.async.d.ts                                    |  2 +-
 ....backpressure-lite.ts => rx.backpressure-lite.d.ts} |  0
 rx.js/rx.backpressure.d.ts                             |  2 +-
 rx.js/{rx.binding-lite.ts => rx.binding-lite.d.ts}     |  0
 rx.js/rx.binding.d.ts                                  |  2 +-
 rx.js/rx.d.ts                                          |  2 +-
 rx.js/rx.lite.d.ts                                     | 10 +++++-----
 rx.js/{rx.time-lite.ts => rx.time-lite.d.ts}           |  0
 rx.js/rx.time.d.ts                                     |  2 +-
 11 files changed, 10 insertions(+), 10 deletions(-)
 rename rx.js/{rx-lite.ts => rx-lite.d.ts} (100%)
 rename rx.js/{rx.async-lite.ts => rx.async-lite.d.ts} (100%)
 rename rx.js/{rx.backpressure-lite.ts => rx.backpressure-lite.d.ts} (100%)
 rename rx.js/{rx.binding-lite.ts => rx.binding-lite.d.ts} (100%)
 rename rx.js/{rx.time-lite.ts => rx.time-lite.d.ts} (100%)

diff --git a/rx.js/rx-lite.ts b/rx.js/rx-lite.d.ts
similarity index 100%
rename from rx.js/rx-lite.ts
rename to rx.js/rx-lite.d.ts
diff --git a/rx.js/rx.async-lite.ts b/rx.js/rx.async-lite.d.ts
similarity index 100%
rename from rx.js/rx.async-lite.ts
rename to rx.js/rx.async-lite.d.ts
diff --git a/rx.js/rx.async.d.ts b/rx.js/rx.async.d.ts
index ff8b61c49..522b87c0d 100644
--- a/rx.js/rx.async.d.ts
+++ b/rx.js/rx.async.d.ts
@@ -5,7 +5,7 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 ///<reference path="rx.d.ts" />
-///<reference path="rx.async-lite.ts" />
+///<reference path="rx.async-lite.d.ts" />
 
 declare module Rx {
     interface ObservableStatic {
diff --git a/rx.js/rx.backpressure-lite.ts b/rx.js/rx.backpressure-lite.d.ts
similarity index 100%
rename from rx.js/rx.backpressure-lite.ts
rename to rx.js/rx.backpressure-lite.d.ts
diff --git a/rx.js/rx.backpressure.d.ts b/rx.js/rx.backpressure.d.ts
index 4c9a9ae7d..4108ba410 100644
--- a/rx.js/rx.backpressure.d.ts
+++ b/rx.js/rx.backpressure.d.ts
@@ -4,4 +4,4 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 ///<reference path="rx.d.ts" />
-///<reference path="rx.backpressure-lite.ts" />
+///<reference path="rx.backpressure-lite.d.ts" />
diff --git a/rx.js/rx.binding-lite.ts b/rx.js/rx.binding-lite.d.ts
similarity index 100%
rename from rx.js/rx.binding-lite.ts
rename to rx.js/rx.binding-lite.d.ts
diff --git a/rx.js/rx.binding.d.ts b/rx.js/rx.binding.d.ts
index 526546353..4d165a637 100644
--- a/rx.js/rx.binding.d.ts
+++ b/rx.js/rx.binding.d.ts
@@ -5,7 +5,7 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 ///<reference path="rx.d.ts" />
-///<reference path="rx.binding-lite.ts" />
+///<reference path="rx.binding-lite.d.ts" />
 
 declare module Rx {
 	export interface Observable<T> {
diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index 3d9c0e0d5..597264fa8 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -4,7 +4,7 @@
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-///<reference path="rx-lite.ts"/>
+///<reference path="rx-lite.d.ts"/>
 
 declare module Rx {
 	export interface IScheduler {
diff --git a/rx.js/rx.lite.d.ts b/rx.js/rx.lite.d.ts
index a50f8c84d..e2640e9eb 100644
--- a/rx.js/rx.lite.d.ts
+++ b/rx.js/rx.lite.d.ts
@@ -4,11 +4,11 @@
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-///<reference path="rx-lite.ts"/>
-///<reference path="rx.async-lite.ts" />
-///<reference path="rx.binding-lite.ts" />
-///<reference path="rx.time-lite.ts" />
-///<reference path="rx.backpressure-lite.ts" />
+///<reference path="rx-lite.d.ts"/>
+///<reference path="rx.async-lite.d.ts" />
+///<reference path="rx.binding-lite.d.ts" />
+///<reference path="rx.time-lite.d.ts" />
+///<reference path="rx.backpressure-lite.d.ts" />
 
 declare module Rx {
 	export class Scheduler implements IScheduler {
diff --git a/rx.js/rx.time-lite.ts b/rx.js/rx.time-lite.d.ts
similarity index 100%
rename from rx.js/rx.time-lite.ts
rename to rx.js/rx.time-lite.d.ts
diff --git a/rx.js/rx.time.d.ts b/rx.js/rx.time.d.ts
index 925d16220..10290bfe8 100644
--- a/rx.js/rx.time.d.ts
+++ b/rx.js/rx.time.d.ts
@@ -5,7 +5,7 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 ///<reference path="rx.d.ts" />
-///<reference path="rx.time-lite.ts" />
+///<reference path="rx.time-lite.d.ts" />
 
 declare module Rx {
 	export interface Observable<T> {

From ba4f75d1f78765477a8efe4044b5a7d253fa7b75 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Thu, 3 Apr 2014 18:36:55 +0400
Subject: [PATCH 285/309] RxJS: fixed references

---
 rx.js/rx.binding-lite.d.ts | 2 +-
 rx.js/rx.time-lite.d.ts    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/rx.js/rx.binding-lite.d.ts b/rx.js/rx.binding-lite.d.ts
index fa1098368..1e5d95eaf 100644
--- a/rx.js/rx.binding-lite.d.ts
+++ b/rx.js/rx.binding-lite.d.ts
@@ -1,7 +1,7 @@
 // This file contains common part of defintions for rx.binding.d.ts and rx.lite.d.ts
 // Do not include the file separately.
 
-///<reference path="rx-lite.ts"/>
+///<reference path="rx-lite.d.ts"/>
 
 declare module Rx {
 	export interface BehaviorSubject<T> extends Subject<T> {
diff --git a/rx.js/rx.time-lite.d.ts b/rx.js/rx.time-lite.d.ts
index b79275fe4..736d872e8 100644
--- a/rx.js/rx.time-lite.d.ts
+++ b/rx.js/rx.time-lite.d.ts
@@ -1,7 +1,7 @@
 // This file contains common part of defintions for rx.time.d.ts and rx.lite.d.ts
 // Do not include the file separately.
 
-///<reference path="rx-lite.ts" />
+///<reference path="rx-lite.d.ts" />
 
 declare module Rx {
 	export interface TimeInterval<T> {

From 096eaefcbcb84d91f34e05241de7100ddc21a48d Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Thu, 3 Apr 2014 18:47:32 +0400
Subject: [PATCH 286/309] RxJS: added references of rx-lite.d.ts

---
 rx.js/rx.async-lite.d.ts        | 2 ++
 rx.js/rx.backpressure-lite.d.ts | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/rx.js/rx.async-lite.d.ts b/rx.js/rx.async-lite.d.ts
index 1b5bafd98..ce0f96778 100644
--- a/rx.js/rx.async-lite.d.ts
+++ b/rx.js/rx.async-lite.d.ts
@@ -1,6 +1,8 @@
 // This file contains common part of defintions for rx.async.d.ts and rx.lite.d.ts
 // Do not include the file separately.
 
+///<reference path="rx-lite.d.ts"/>
+
 declare module Rx {
     interface ObservableStatic {
 		/**
diff --git a/rx.js/rx.backpressure-lite.d.ts b/rx.js/rx.backpressure-lite.d.ts
index 52ff18225..3cc78f6ca 100644
--- a/rx.js/rx.backpressure-lite.d.ts
+++ b/rx.js/rx.backpressure-lite.d.ts
@@ -1,6 +1,8 @@
 // This file contains common part of defintions for rx.backpressure.d.ts and rx.lite.d.ts
 // Do not include the file separately.
 
+///<reference path="rx-lite.d.ts"/>
+
 declare module Rx {
 	export interface Observable<T> {
 		/**

From 0cfec1bfc3c167edf90d13af6a984a769c4913b2 Mon Sep 17 00:00:00 2001
From: Luigi Trabacchin <trabacchin.luigi@gmail.com>
Date: Thu, 3 Apr 2014 19:34:25 +0200
Subject: [PATCH 287/309] fix for Element.Children

Element.children is a function not a field, now it's correctly mapped
---
 svgjs/svgjs.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/svgjs/svgjs.d.ts b/svgjs/svgjs.d.ts
index f5ceb81f2..08513b78b 100644
--- a/svgjs/svgjs.d.ts
+++ b/svgjs/svgjs.d.ts
@@ -205,7 +205,7 @@ declare module svgjs {
     export interface Parent {
         put(element:Element, i?:number):Element;
         add(element:Element, i?:number):Element;
-        children:Element[];
+        children():Element[];
 
         rect(w:number, h:number):Element;
         ellipse(w:number, h:number):Element;

From 900f86cb1f7b17a2a3b6c8f7d749a0319e34a917 Mon Sep 17 00:00:00 2001
From: Luigi Trabacchin <trabacchin.luigi@gmail.com>
Date: Thu, 3 Apr 2014 19:44:18 +0200
Subject: [PATCH 288/309] added a Test to check Element.children()

as title says
---
 svgjs/svgjs-tests.ts | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/svgjs/svgjs-tests.ts b/svgjs/svgjs-tests.ts
index 60d07cab5..0a0a2357c 100644
--- a/svgjs/svgjs-tests.ts
+++ b/svgjs/svgjs-tests.ts
@@ -86,3 +86,27 @@ function elementTransformShouldReturnTransformObject() {
     if (trans.skewX != 10) { throw "skewX value is not correct" }
     if (trans.skewY != 25) { throw "skewY value is not correct" }
 }
+
+//Test if svgjs.Element.children() correctly return an svgjs.Element[]
+function elementTransformShouldReturnTransformObject() {
+    /* create an svg drawing */
+    var div = document.createElement('div')
+    var draw = SVG(div)
+
+    /* draw a rectangle scale, rotate and skew it */
+    var group = draw.group()
+    group.rect(10,10)
+    group.rect(20,20)
+    group.rect(30,30)
+    group.rect(40,40)
+    group.rect(50,50)
+    
+    /* first try to cast it */
+    var result:svgjs.Element[] = group.children()
+    /* then check values if they are correct */
+    if (!(result[0] instanceof svgjs.Element)) { throw "Element.children() is not working" }
+    if (!(result[1] instanceof svgjs.Element)) { throw "Element.children() is not working" }
+    if (!(result[2] instanceof svgjs.Element)) { throw "Element.children() is not working" }
+    if (!(result[3] instanceof svgjs.Element)) { throw "Element.children() is not working" }
+    if (!(result[4] instanceof svgjs.Element)) { throw "Element.children() is not working" }
+}

From 18dad4a676e2f6c9b8a8d95ea9958bddcd45a9ce Mon Sep 17 00:00:00 2001
From: Luigi Trabacchin <trabacchin.luigi@gmail.com>
Date: Thu, 3 Apr 2014 20:51:46 +0200
Subject: [PATCH 289/309] Update svgjs-tests.ts

---
 svgjs/svgjs-tests.ts | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/svgjs/svgjs-tests.ts b/svgjs/svgjs-tests.ts
index 0a0a2357c..5ea5d2d50 100644
--- a/svgjs/svgjs-tests.ts
+++ b/svgjs/svgjs-tests.ts
@@ -104,9 +104,8 @@ function elementTransformShouldReturnTransformObject() {
     /* first try to cast it */
     var result:svgjs.Element[] = group.children()
     /* then check values if they are correct */
-    if (!(result[0] instanceof svgjs.Element)) { throw "Element.children() is not working" }
-    if (!(result[1] instanceof svgjs.Element)) { throw "Element.children() is not working" }
-    if (!(result[2] instanceof svgjs.Element)) { throw "Element.children() is not working" }
-    if (!(result[3] instanceof svgjs.Element)) { throw "Element.children() is not working" }
-    if (!(result[4] instanceof svgjs.Element)) { throw "Element.children() is not working" }
+    for (var i = 0; i < 5; i++) {
+        var elem: svgjs.Element = result[i];
+        if (elem == null) { throw "Element.children() is not working" }
+	}
 }

From c801c1475f7fe5fa4d75641a48e49433f5ed8649 Mon Sep 17 00:00:00 2001
From: Luigi Trabacchin <trabacchin.luigi@gmail.com>
Date: Thu, 3 Apr 2014 20:56:44 +0200
Subject: [PATCH 290/309] wrong comment

---
 svgjs/svgjs-tests.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/svgjs/svgjs-tests.ts b/svgjs/svgjs-tests.ts
index 5ea5d2d50..a135aab25 100644
--- a/svgjs/svgjs-tests.ts
+++ b/svgjs/svgjs-tests.ts
@@ -93,7 +93,7 @@ function elementTransformShouldReturnTransformObject() {
     var div = document.createElement('div')
     var draw = SVG(div)
 
-    /* draw a rectangle scale, rotate and skew it */
+    /* draw some rectangle inside a group */
     var group = draw.group()
     group.rect(10,10)
     group.rect(20,20)
@@ -107,5 +107,5 @@ function elementTransformShouldReturnTransformObject() {
     for (var i = 0; i < 5; i++) {
         var elem: svgjs.Element = result[i];
         if (elem == null) { throw "Element.children() is not working" }
-	}
+    }
 }

From 8ec7c6fb1fc343b7a92a680b58c1046a2adf3d9e Mon Sep 17 00:00:00 2001
From: Paul Vick <paulvick@hotmail.com>
Date: Thu, 3 Apr 2014 12:14:59 -0700
Subject: [PATCH 291/309] Add param to complete()

---
 jake/jake.d.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/jake/jake.d.ts b/jake/jake.d.ts
index 59da4597f..2afaee338 100644
--- a/jake/jake.d.ts
+++ b/jake/jake.d.ts
@@ -7,8 +7,9 @@
 
 /**
  * Complets an asynchronous task, allowing Jake's execution to proceed to the next task
+ * @param value A value to return from the task.
  */
-declare function complete(): void;
+declare function complete(value?: any): void;
 
 /**
  * Creates a description for a Jake Task (or FileTask, DirectoryTask). When invoked, the description that iscreated will be associated with whatever Task is created next.

From a15b7d3a033a6e0c00f0030396451d0b369eb8a3 Mon Sep 17 00:00:00 2001
From: Greg Weber <greg@gregweber.info>
Date: Thu, 3 Apr 2014 15:39:07 -0700
Subject: [PATCH 292/309] name parameter is optional

---
 angular-ui/angular-ui-router.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/angular-ui/angular-ui-router.d.ts b/angular-ui/angular-ui-router.d.ts
index da3d92e5e..9ddd60cd7 100644
--- a/angular-ui/angular-ui-router.d.ts
+++ b/angular-ui/angular-ui-router.d.ts
@@ -26,6 +26,7 @@ declare module ng.ui {
 
     interface IStateProvider extends IServiceProvider {
         state(name:string, config:IState): IStateProvider;
+        state(config:IState): IStateProvider;
         decorator(name?: string, decorator?: (state: IState, parent: Function) => any): any;
     }
 

From e4cafe56f09a9b4de7a8e0b8545dd660c5d0f6b8 Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Fri, 4 Apr 2014 12:25:40 +0900
Subject: [PATCH 293/309] add pegjs.d.ts

---
 README.md            |  1 +
 pegjs/pegjs-tests.ts |  5 +++++
 pegjs/pegjs.d.ts     | 19 +++++++++++++++++++
 3 files changed, 25 insertions(+)
 create mode 100644 pegjs/pegjs-tests.ts
 create mode 100644 pegjs/pegjs.d.ts

diff --git a/README.md b/README.md
index 57bc26285..f8a103dd1 100755
--- a/README.md
+++ b/README.md
@@ -222,6 +222,7 @@ List of Definitions
 * [Parallel.js](https://github.com/adambom/parallel.js) (by [Josh Baldwin](https://github.com/jbaldwin))
 * [Parsimmon](https://github.com/jayferd/parsimmon) (by [Bart van der Schoor](https://github.com/Bartvds))
 * [PDF.js](https://github.com/mozilla/pdf.js) (by [Josh Baldwin](https://github.com/jbaldwin))
+* [PEG.js](http://pegjs.majda.cz/) (by [vvakame](https://github.com/vvakame))
 * [Persona](http://www.mozilla.org/en-US/persona) (by [James Frasca](https://github.com/Nycto))
 * [PhantomJS](http://phantomjs.org) (by [Jed Hunsaker](https://github.com/jedhunsaker))
 * [PhoneGap](http://phonegap.com) (by [Boris Yankov](https://github.com/borisyankov))
diff --git a/pegjs/pegjs-tests.ts b/pegjs/pegjs-tests.ts
new file mode 100644
index 000000000..90ebe2da1
--- /dev/null
+++ b/pegjs/pegjs-tests.ts
@@ -0,0 +1,5 @@
+/// <reference path="./pegjs.d.ts" />
+
+var input: string;
+var result = PEG.parse(input);
+console.log(result);
diff --git a/pegjs/pegjs.d.ts b/pegjs/pegjs.d.ts
new file mode 100644
index 000000000..c42b9aae5
--- /dev/null
+++ b/pegjs/pegjs.d.ts
@@ -0,0 +1,19 @@
+// Type definitions for PEG.js
+// Project: http://pegjs.majda.cz/
+// Definitions by: vvakame <https://github.com/vvakame>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module PEG {
+	function parse(input:string):any;
+
+	class SyntaxError {
+		line:number;
+		column:number;
+		offset:number;
+
+		expected:any[];
+		found:any;
+		name:string;
+		message:string;
+	}
+}

From 04eb30761acad48eb4a6339157153fb4ccb25ea7 Mon Sep 17 00:00:00 2001
From: Luigi Trabacchin <trabacchin.luigi@gmail.com>
Date: Fri, 4 Apr 2014 11:20:48 +0200
Subject: [PATCH 294/309] opz same function name

maybe less significative names can be ok too
---
 svgjs/svgjs-tests.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/svgjs/svgjs-tests.ts b/svgjs/svgjs-tests.ts
index a135aab25..63fcc1ce7 100644
--- a/svgjs/svgjs-tests.ts
+++ b/svgjs/svgjs-tests.ts
@@ -88,7 +88,7 @@ function elementTransformShouldReturnTransformObject() {
 }
 
 //Test if svgjs.Element.children() correctly return an svgjs.Element[]
-function elementTransformShouldReturnTransformObject() {
+function elementChildrenShouldReturnElementArray() {
     /* create an svg drawing */
     var div = document.createElement('div')
     var draw = SVG(div)

From f48c57d771b6e16e4ed12dff6e0e978db960f6d2 Mon Sep 17 00:00:00 2001
From: Kensuke Matsuzaki <zakki@peppermint.jp>
Date: Fri, 4 Apr 2014 17:29:51 +0900
Subject: [PATCH 295/309] add jsrender/jsrender.d.ts

---
 README.md                  |  1 +
 jsrender/jsrender-tests.ts | 50 ++++++++++++++++++++++++++++++++++
 jsrender/jsrender.d.ts     | 56 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 107 insertions(+)
 create mode 100644 jsrender/jsrender-tests.ts
 create mode 100644 jsrender/jsrender.d.ts

diff --git a/README.md b/README.md
index f8a103dd1..3b34ef2ec 100755
--- a/README.md
+++ b/README.md
@@ -172,6 +172,7 @@ List of Definitions
 * [JSDeferred](http://cho45.stfuawsc.com/jsdeferred/) (by [Daisuke Mino](https://github.com/minodisk))
 * [JSONEditorOnline](https://github.com/josdejong/jsoneditoronline) (by [Vincent Bortone](https://github.com/vbortone/))
 * [JSON-Pointer](https://www.npmjs.org/package/json-pointer) (by [Bart van der Schoor](https://github.com/Bartvds))
+* [JsRender](http://www.jsviews.com/#jsrender) (by [Kensuke MATSUZAKI](https://github.com/zakki))
 * [jStorage](http://www.jstorage.info/) (by [Danil Flores](https://github.com/dflor003/))
 * [JWPlayer](http://developer.longtailvideo.com/trac/) (by [Martin Duparc](https://github.com/martinduparc/))
 * [KeyboardJS](https://github.com/RobertWHurst/KeyboardJS) (by [Vincent Bortone](https://github.com/vbortone/))
diff --git a/jsrender/jsrender-tests.ts b/jsrender/jsrender-tests.ts
new file mode 100644
index 000000000..8b0fdd57f
--- /dev/null
+++ b/jsrender/jsrender-tests.ts
@@ -0,0 +1,50 @@
+/// <reference path="../jquery/jquery.d.ts"/>
+/// <reference path="jsrender.d.ts"/>
+
+$.views.converters("upper", function(val) {
+  return val.toUpperCase();
+});
+
+$.views.converters({
+  upper: (val: string) => val.toUpperCase(),
+  lower: (val: string) => val.toLowerCase()
+});
+
+$.views.converters.html("< > ' \" &");
+$.views.converters.attr( "< > ' \" &");
+$.views.converters.url("<_>_\"_ ");
+
+function renderBoldP(value: any): string {
+   return "<p><b>" + value + "</b></p>";
+}
+
+$.views.tags("boldp", renderBoldP);
+$.views.tags("boldp", {
+  template: "<p><b>{{:~tag.tagCtx.args[0]}}</b></p>"
+});
+
+function myFormatFunction(value: string, upper: string): string {
+  return upper ? value.toUpperCase() : value.toLowerCase();
+}
+$.views.helpers("format", myFormatFunction);
+$.views.helpers({format: myFormatFunction});
+
+var person = {
+    name: "Adriana"
+};
+
+$.templates("personTmpl", "<label>Name:</label> {{:name}}");
+var html = $.render["personTmpl"](person);
+console.log(html);
+
+var myTmpl = $.templates("<label>Name:</label> {{:name}}");
+var html = myTmpl.render(person);
+console.log(html);
+
+$.templates({
+  personTmpl: "#personTemplate",
+  labelTmpl: "Name:"
+});
+
+var html = $("#personTemplate").render(person);
+console.log(html);
diff --git a/jsrender/jsrender.d.ts b/jsrender/jsrender.d.ts
new file mode 100644
index 000000000..8cdfa13a1
--- /dev/null
+++ b/jsrender/jsrender.d.ts
@@ -0,0 +1,56 @@
+// Type definitions for JsRender
+// Project: http://www.jsviews.com/#jsrender
+// Definitions by: https://github.com/zakki
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../jquery/jquery.d.ts"/>
+
+declare module JsRender {
+    interface Converters {
+        (name: string, converterFn: (value: any) => any): any;
+        (namedConverters: any, parentTemplate?: any): any;
+
+        html(valueToEncode: string): string;
+        attr(valueToEncode: string): string;
+        url(valueToEncode: string): string;
+    }
+
+    interface Views {
+        converters: Converters;
+
+        tags(name: string, tagFn: (value: any) => any): any;
+        tags(name: string, tagOptions: any): any;
+        tags(namedTags: any): any;
+
+        helpers(name: string, helper: any): any;
+        helpers(namedHelpers: any, parentTemplate?: any): any;
+    }
+
+    interface Template {
+        render(data?: any): string;
+    }
+
+    interface NamedTemplate {
+        (data?: any): string;
+    }
+
+    interface Render {
+        (data?: any, helpersOrContext?: any): string;
+    }
+
+    interface RenderStatic {
+        [index: string]: NamedTemplate;
+    }
+}
+
+interface JQuery {
+    render: JsRender.Render;
+}
+
+interface JQueryStatic {
+    render: JsRender.RenderStatic;
+    views: JsRender.Views;
+    templates(markupOrSelector: string): JsRender.Template;
+    templates(name: string, markupOrSelector: string): JsRender.Template;
+    templates(namedTemplates: any): any;
+}

From 65fb86a5731ff0b136df866e545b7d3fcb118e47 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Fri, 4 Apr 2014 15:58:27 +0400
Subject: [PATCH 296/309] lodash: improved _.mapValues definitions

---
 lodash/lodash.d.ts | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index 9f186f433..a4b08242a 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -3475,14 +3475,10 @@ declare module _ {
 		* @param thisArg `this` object in `iterator`, optional.
 		* @return Returns a new object with values of the results of each callback execution.
 		*/
-		mapValues<Mapped, T>(
-			object: T,
-			callback: ObjectIterator<any, any>,
-			thisArg?: any): Mapped;
-
-		mapValues<Mapped, T>(
-			object: T,
-			pluckValue: string): Mapped;
+		mapValues<T, TResult>(obj: Dictionary<T>, callback: ObjectIterator<T, TResult>, thisArg?: any): Dictionary<TResult>;
+		mapValues<T>(obj: Dictionary<T>, where: Dictionary<T>): Dictionary<boolean>;
+		mapValues<T, TMapped>(obj: T, pluck: string): TMapped;
+		mapValues<T>(obj: T, callback: ObjectIterator<any, any>, thisArg?: any): T;
 	}
 
 	//_.merge

From b7844abae65ebd2a840e5a4e1201d9d46cb92cc3 Mon Sep 17 00:00:00 2001
From: Blake Niemyjski <bniemyjski@gmail.com>
Date: Fri, 4 Apr 2014 16:07:37 -0500
Subject: [PATCH 297/309] Removed a method that no longer exists.

---
 zeroclipboard/zeroclipboard.d.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/zeroclipboard/zeroclipboard.d.ts b/zeroclipboard/zeroclipboard.d.ts
index b8f0ebb92..76086f5bd 100644
--- a/zeroclipboard/zeroclipboard.d.ts
+++ b/zeroclipboard/zeroclipboard.d.ts
@@ -11,7 +11,6 @@ declare class ZeroClipboard {
     setText(newText: string): void;
     title(newTitle: string): void;
     setSize(width: number, height: number): void;
-    forceHandCursor(enabled: boolean): void;
     version: string;
     moviePath: string;
     trustedDomains: any;

From c4302957aafe92561a7cfe8d82e1c7b74ff21385 Mon Sep 17 00:00:00 2001
From: David Sichau <etutorial@sichau.eu>
Date: Fri, 4 Apr 2014 23:08:20 +0200
Subject: [PATCH 298/309] added the definition file for pnotify

---
 jquery.pnotify/jquery.pnotify-tests.ts | 242 +++++++++++++++++++++++++
 jquery.pnotify/jquery.pnotify.d.ts     | 173 ++++++++++++++++++
 2 files changed, 415 insertions(+)
 create mode 100644 jquery.pnotify/jquery.pnotify-tests.ts
 create mode 100644 jquery.pnotify/jquery.pnotify.d.ts

diff --git a/jquery.pnotify/jquery.pnotify-tests.ts b/jquery.pnotify/jquery.pnotify-tests.ts
new file mode 100644
index 000000000..779b32b16
--- /dev/null
+++ b/jquery.pnotify/jquery.pnotify-tests.ts
@@ -0,0 +1,242 @@
+/// <reference path="../jquery/jquery.d.ts"/>
+/// <reference path="jquery.pnotify.d.ts" />
+
+function test_pnotify() {
+
+
+    $.pnotify({
+        title: 'Regular Notice',
+        text: 'Check me out! I\'m a notice.'
+    });
+
+    $.pnotify({
+        title: 'Sticky Notice',
+        text: 'Check me out! I\'m a sticky notice. You\'ll have to close me yourself.',
+        hide: false
+    });
+    $.pnotify({
+        title: 'See Through Notice',
+        text: 'No one ever pays attention to me. Why should they? I\'m practically invisible.',
+        opacity: .8
+    });
+    $.pnotify({
+        title: 'No Shadow Notice',
+        text: 'I don\'t have a shadow. (It\'s cause I\'m a vampire or something. Or is that reflections...)',
+        shadow: false
+    });
+    $.pnotify('Check me out! I\'m a notice.');
+
+    $.pnotify(Math.round(Math.random() * 9999));
+
+    $.pnotify({
+        title: 'PIcon Notice',
+        text: 'I have an icon that uses the PIcon styles.',
+        icon: 'picon picon-mail-unread-new'
+    });
+
+    $.pnotify({
+        title: 'jQuery UI Icon Notice',
+        text: 'I have an icon that uses the jQuery UI icon styles.',
+        icon: 'ui-icon ui-icon-mail-closed'
+    });
+
+    $.pnotify({
+        title: 'Bootstrap Icon Notice',
+        text: 'I have an icon that uses the Bootstrap icon styles.',
+        icon: 'glyphicon glyphicon-envelope'
+    });
+
+    $.pnotify({
+        title: 'No Icon Notice',
+        text: 'I have no icon.',
+        icon: false
+    });
+
+    $.pnotify({
+        title: 'Bootstrap Notice',
+        text: 'Look at my beautiful styling! ^_^',
+        styling: 'bootstrap3'
+    });
+    $.pnotify({
+        title: 'Bootstrap Info',
+        text: 'Look at my beautiful styling! ^_^',
+        type: 'info',
+        styling: 'bootstrap3'
+    });
+    $.pnotify({
+        title: 'Bootstrap Success',
+        text: 'Look at my beautiful styling! ^_^',
+        type: 'success',
+        styling: 'bootstrap3'
+    });
+    $.pnotify({
+        title: 'Bootstrap Error',
+        text: 'Look at my beautiful styling! ^_^',
+        type: 'error',
+        styling: 'bootstrap3'
+    });
+    $.pnotify({
+        title: 'jQuery UI Notice',
+        text: 'Look at my beautiful styling! ^_^',
+        styling: 'jqueryui'
+    });
+    $.pnotify({
+        title: 'jQuery UI Info',
+        text: 'Look at my beautiful styling! ^_^',
+        type: 'info',
+        styling: 'jqueryui'
+    });
+    $.pnotify({
+        title: 'jQuery UI Success',
+        text: 'Look at my beautiful styling! ^_^',
+        type: 'success',
+        styling: 'jqueryui'
+    });
+    $.pnotify({
+        title: 'jQuery UI Error',
+        text: 'Look at my beautiful styling! ^_^',
+        type: 'error',
+        styling: 'jqueryui'
+    });
+    $.pnotify({
+        title: 'Font Awesome Notice',
+        text: 'Look at my beautiful styling! ^_^',
+        styling: 'fontawesome'
+    });
+    $.pnotify({
+        title: 'Font Awesome Info',
+        text: 'Look at my beautiful styling! ^_^',
+        type: 'info',
+        styling: 'fontawesome'
+    });
+    $.pnotify({
+        title: 'Font Awesome Success',
+        text: 'Look at my beautiful styling! ^_^',
+        type: 'success',
+        styling: 'fontawesome'
+    });
+    $.pnotify({
+        title: 'Font Awesome Error',
+        text: 'Look at my beautiful styling! ^_^',
+        type: 'error',
+        styling: 'fontawesome'
+    });
+
+    $.pnotify({
+        title: 'New Thing',
+        text: 'Just to let you know, something happened.',
+        type: 'info'
+    });
+
+    $.pnotify({
+        title: 'Sticky Info',
+        text: 'Sticky info, you know, like a newspaper covered in honey.',
+        type: 'info',
+        hide: false
+    });
+
+    $.pnotify({
+        title: 'See Through Info',
+        text: 'Not only does it not matter, but I don\'t even care if you see this info.',
+        type: 'info',
+        opacity: .8
+    });
+
+    $.pnotify({
+        title: 'No Shadow Success',
+        text: 'I don\'t have a shadow. (It\'s cause I\'m a vampire or something. Or is that reflections...)',
+        type: 'success',
+        shadow: false
+    });
+
+    $.pnotify({
+        title: 'PIcon Success',
+        text: 'We reached the moon first! See, we planted a flag.',
+        type: 'success',
+        icon: 'picon picon-flag-green'
+    });
+
+    $.pnotify({
+        title: 'Oh No!',
+        text: 'Something terrible happened.',
+        type: 'error'
+    });
+
+    $.pnotify({
+        title: 'No Icon Error',
+        text: 'I have no icon.',
+        type: 'error',
+        icon: false
+    });
+
+    $.pnotify({
+        title: 'No Sticky Button Notice',
+        text: 'Check me out! I\'m a sticky notice with no unsticky button. You\'ll have to close me yourself.',
+        hide: false,
+        sticker: false
+    });
+
+    $.pnotify({
+        title: 'No Mouse Reset Notice',
+        text: 'I don\'t care if you move your mouse over me, I\'ll disappear when I want.',
+        mouse_reset: false
+    });
+
+    $.pnotify({
+        title: '<em>Escaped Notice</em>',
+        title_escape: true,
+        text: $('#evil_html').html(),
+        text_escape: true
+    });
+
+    $.pnotify({
+        title: 'Non-Blocking Notice',
+        text: 'I\'m a special kind of notice called "non-blocking". When you hover over me I\'ll fade to show the elements underneath. Feel free to click any of them just like I wasn\'t even here.\n\nNote: HTML links don\'t trigger in some browsers, due to security settings.',
+        nonblock: true,
+        nonblock_opacity: .2
+    });
+
+    $.pnotify({
+        title: 'Custom Styling',
+        text: 'I have an additional class that\'s used to give me special styling. I always wanted to be pretty.',
+        addclass: 'custom',
+        icon: 'picon picon-32 picon-fill-color',
+        opacity: .8,
+        nonblock: true,
+        nonblock_opacity: .2
+    });
+
+    $.pnotify({
+        title: "PNotify Stacks",
+        text: "Stacks are used to position notices and determine where new notices will go when they're created. Each notice that's placed into a stack will be positioned related to the other notices in that stack. There is no limit to the number of stacks, and no limit to the number of notices in each stack.",
+        type: "info",
+        icon: "fa fa-bars",
+        delay: 20000,
+        history: false,
+        stack: false
+    });
+
+    var type = "error";
+    var stack_bottomright = {"dir1": "up", "dir2": "left", "firstpos1": 25, "firstpos2": 25};
+
+    var opts = {
+        title: "Over Here",
+        text: "Check me out. I'm in a different stack.",
+        addclass: "stack-bar-top",
+        cornerclass: "",
+        width: "100%",
+        stack: stack_bottomright,
+        type: "error"
+
+    };
+    $.pnotify(opts);
+
+    $.pnotify({
+        title: 'Show Effect',
+        text: 'I use a different effect.',
+        animation: 'show'
+    });
+
+    $.pnotify_remove_all();
+
+}
diff --git a/jquery.pnotify/jquery.pnotify.d.ts b/jquery.pnotify/jquery.pnotify.d.ts
new file mode 100644
index 000000000..d467a9999
--- /dev/null
+++ b/jquery.pnotify/jquery.pnotify.d.ts
@@ -0,0 +1,173 @@
+// Type definitions for jquery.pnotify 1.3.1
+// Project:  https://github.com/sciactive/pnotify
+// Definitions by: https://github.com/DavidSichau
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+
+/// <reference path="../jquery/jquery.d.ts"/>
+
+interface pnotifyStack {
+    dir1?: string;
+    dir2?: string;
+    push?: string;
+    spacing1?: number;
+    spacing2?: number;
+    context?: JQuery
+}
+
+interface pnotifyLabel {
+    redisplay?: string;
+    all?: string;
+    last?: string;
+    close?: string;
+    stick?: string;
+}
+
+interface pnotifyDefaults {
+    /**
+     * The notice's title. Either boolean false or string
+     */
+    title?: any;
+    /**
+     * Whether to escape the content of the title. (Not allow HTML.)
+     */
+    title_escape?: boolean;
+    /**
+     * The notice's text. Either boolean false or string
+     */
+    text?: any;
+    /**
+     * Whether to escape the content of the text. (Not allow HTML.)
+     */
+    text_escape?: boolean;
+    /**
+     * What styling classes to use. (Can be either jqueryui or bootstrap.)
+     */
+    styling?: string;
+    /**
+     * Additional classes to be added to the notice. (For custom styling.)
+     */
+    addclass?: string;
+    /**
+     * Class to be added to the notice for corner styling.
+     */
+    cornerclass?: string;
+    /**
+     * Create a non-blocking notice. It lets the user click elements underneath it.
+     */
+    nonblock?: boolean;
+    /**
+     * The opacity of the notice (if it's non-blocking) when the mouse is over it.
+     */
+    nonblock_opacity?: number;
+    /**
+     * Display a pull down menu to redisplay previous notices, and place the notice in the history.
+     */
+    history?: boolean;
+    /**
+     * Maximum number of notifications to have onscreen.
+     */
+    maxonscreen?: number;
+    /**
+     * Display the notice when it is created. Turn this off to add notifications to the history without displaying them.
+     */
+    auto_display?: boolean;
+    /**
+     * Width of the notice.
+     */
+    width?: string;
+    /**
+     * Minimum height of the notice. It will expand to fit content.
+     */
+    min_height?: string;
+    /**
+     * Type of the notice. "notice", "info", "success", or "error".
+     */
+    type?: string;
+    /**
+     * Set icon to true to use the default icon for the selected style/type, false for no icon, or a string for your own icon class.
+     */
+    icon?: any;
+    /**
+     * The animation to use when displaying and hiding the notice. "none", "show", "fade", and "slide" are built in to jQuery. Others require jQuery UI. Use an object with effect_in and effect_out to use different effects.
+     */
+    animation?: any;
+    /**
+     * Speed at which the notice animates in and out. "slow", "def" or "normal", "fast" or number of milliseconds.
+     */
+    animate_speed?: string;
+    /**
+     * Specify a specific duration of position animation
+     */
+    position_animate_speed?: number;
+    /**
+     * Opacity of the notice.
+     */
+    opacity?: number;
+    /**
+     * Display a drop shadow.
+     */
+    shadow?: boolean;
+    /**
+     * Provide a button for the user to manually close the notice.
+     */
+    closer?: boolean;
+    /**
+     * Only show the closer button on hover.
+     */
+    closer_hover?: boolean;
+    /**
+     * Provide a button for the user to manually stick the notice.
+     */
+    sticker?: boolean;
+    /**
+     * Only show the sticker button on hover.
+     */
+    sticker_hover?: boolean;
+    /**
+     * After a delay, remove the notice.
+     */
+    hide?: boolean;
+    /**
+     * Delay in milliseconds before the notice is removed.
+     */
+    delay?: number;
+    /**
+     * Reset the hide timer if the mouse moves over the notice.
+     */
+    mouse_reset?: boolean;
+    /**
+     * Remove the notice's elements from the DOM after it is removed.
+     */
+    remove?: boolean;
+    /**
+     * Change new lines to br tags.
+     */
+    insert_brs?: boolean;
+    /**
+     * The stack on which the notices will be placed. Also controls the direction the notices stack.
+     */
+    stack?: pnotifyStack;
+    /**
+     * The various displayed text, helps facilitating internationalization.
+     */
+    labels?: pnotifyLabel;
+}
+
+
+interface pnotifyInterface {
+    defaults?: pnotifyDefaults
+    (options: pnotifyDefaults): any;
+}
+
+interface JQueryStatic {
+    /**
+     * The pnotify object
+     */
+    pnotify: pnotifyInterface;
+    /**
+     * Removes all notifications
+     */
+    pnotify_remove_all(): void;
+}
+

From 97911421e2effa823e29e8433863fab0df9cd63f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Poul=20Kjeldager=20S=C3=B8rensen?= <pks@s-innovations.net>
Date: Sat, 5 Apr 2014 10:16:53 +0200
Subject: [PATCH 299/309] The changes fixes such it work with 1.0

Its also back compatible.
---
 knockout.mapping/knockout.mapping.d.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/knockout.mapping/knockout.mapping.d.ts b/knockout.mapping/knockout.mapping.d.ts
index cc116096d..e8ffc807e 100644
--- a/knockout.mapping/knockout.mapping.d.ts
+++ b/knockout.mapping/knockout.mapping.d.ts
@@ -48,5 +48,6 @@ interface KnockoutStatic {
 }
 
 declare module "knockout.mapping" {
-    export = KnockoutMapping;
+    export = mapping;
 }
+declare var mapping: KnockoutMapping;

From c663be4f3cc881428b72b833ff9ea98e159ef89c Mon Sep 17 00:00:00 2001
From: ofirgeller <ofirgeller22@gmail.com>
Date: Sat, 5 Apr 2014 11:32:32 +0300
Subject: [PATCH 300/309] go() returns a promise.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

from the wiki:

Returns
{promise} – A promise representing the state of the new transition. Possible success values:
$state.current
---
 angular-ui/angular-ui-router.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/angular-ui/angular-ui-router.d.ts b/angular-ui/angular-ui-router.d.ts
index da3d92e5e..4f9f8d453 100644
--- a/angular-ui/angular-ui-router.d.ts
+++ b/angular-ui/angular-ui-router.d.ts
@@ -73,7 +73,7 @@ declare module ng.ui {
     }
 
     interface IStateService {
-        go(to: string, params?: {}, options?: IStateOptions): void;
+        go(to: string, params?: {}, options?: IStateOptions): IPromise<any>;
         transitionTo(state: string, params?: {}, updateLocation?: boolean): void;
         transitionTo(state: string, params?: {}, options?: IStateOptions): void;
         includes(state: string, params?: {}): boolean;

From c7be3a17bc8f624c8ffe277f827e45effcec3a25 Mon Sep 17 00:00:00 2001
From: David Sichau <etutorial@sichau.eu>
Date: Sat, 5 Apr 2014 20:03:13 +0200
Subject: [PATCH 301/309] updated Reade Me with pnotify

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 3b34ef2ec..4fbe5a913 100755
--- a/README.md
+++ b/README.md
@@ -153,6 +153,7 @@ List of Definitions
 * [jQuery.noty](http://needim.github.io/noty/) (by [Aaron King](https://github.com/kingdango/))
 * [jQuery.pickadate](https://github.com/amsul/pickadate.js) (by [Theodore Brown](https://github.com/theodorejb))
 * [jQuery.payment](http://needim.github.io/noty/) (by [Eric J. Smith](https://github.com/ejsmith/))
+* [jQuery.pnotify](http://sciactive.github.io/pnotify/ (by [David Sichau](https://github.com/DavidSichau/))
 * [jQuery.scrollTo](https://github.com/flesler/jquery.scrollTo) (by [Neil Stalker](https://github.com/nestalk/))
 * [jQuery.simplePagination](https://github.com/flaviusmatis/simplePagination.js) (by [Natan Vivo](https://github.com/nvivo/))
 * [jquery.superLink](http://james.padolsey.com/demos/plugins/jQuery/superLink/superlink.jquery.js) (by [Blake Niemyjski](https://github.com/niemyjski))

From d2ccff18a4d0f303833eea0445f00185a252b605 Mon Sep 17 00:00:00 2001
From: otiai10 <otiai10@gmail.com>
Date: Sun, 6 Apr 2014 05:07:45 +0900
Subject: [PATCH 302/309] Update `chrome`

---
 chrome/chrome.d.ts | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/chrome/chrome.d.ts b/chrome/chrome.d.ts
index eb749f6e7..8f1bc3fd6 100755
--- a/chrome/chrome.d.ts
+++ b/chrome/chrome.d.ts
@@ -775,6 +775,14 @@ declare module chrome.downloads {
     export function resume(downloadId: number, callback?: Function): void;
     export function cancel(downloadId: number, callback?: Function): void;
     export function download(options: DownloadOptions, callback?: (downloadId: number) => void): void;
+    export function open(downloadId: number): void;
+    export function show(downloadId: number): void;
+    export function showDefaultFolder(): void;
+    export function erase(query: DownloadQuery, callback: (results: DownloadItem[]) => void): void;
+    export function removeFile(downloadId: number, callback: () => void): void;
+    export function acceptDanger(downloadId: number, callback: () => void): void;
+    export function drag(downloadId: number): void;
+    export function setShelfEnabled(enabled: boolean): void;
 
     var onChanged: DownloadChangedEvent;
     var onCreated: DownloadCreatedEvent;

From 0c17a69f841c8542eab029dc6464ae898cc173ae Mon Sep 17 00:00:00 2001
From: vvakame <vvakame+dev@gmail.com>
Date: Sun, 6 Apr 2014 10:46:34 +0900
Subject: [PATCH 303/309] fix jwplayer/jwplayer.d.ts. add optional parameter
 hint.

---
 jwplayer/jwplayer.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/jwplayer/jwplayer.d.ts b/jwplayer/jwplayer.d.ts
index 4af38a789..842a713cd 100644
--- a/jwplayer/jwplayer.d.ts
+++ b/jwplayer/jwplayer.d.ts
@@ -55,7 +55,7 @@ interface JWPlayer {
 	pause(): void;
 	play(): void;
 	playlistItem(index: number): void;
-	registerPlugin(id: string, target: string, jsPlugin: () => void, swfURL: string): void;
+	registerPlugin(id: string, target: string, jsPlugin: () => void, swfURL?: string): void;
 	remove(): void;
 	removeButton(id: string): void;
 	resize(width: number, height: number): void;

From bd8aef3b2be074dc904f1a016f85a0f50ba93944 Mon Sep 17 00:00:00 2001
From: otiai10 <otiai10@gmail.com>
Date: Sun, 6 Apr 2014 11:46:58 +0900
Subject: [PATCH 304/309] Update README for `chrome`

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 4fbe5a913..091bd915f 100755
--- a/README.md
+++ b/README.md
@@ -53,7 +53,7 @@ List of Definitions
 * [CasperJS](http://casperjs.org) (by [Jed Hunsaker](https://github.com/jedhunsaker))
 * [Cheerio](https://github.com/MatthewMueller/cheerio) (by [Bret Little](https://github.com/blittle))
 * [Chosen](http://harvesthq.github.com/chosen/) (by [Boris Yankov](https://github.com/borisyankov))
-* [Chrome](http://developer.chrome.com/extensions/) (by [Matthew Kimber](https://github.com/matthewkimber))
+* [Chrome](http://developer.chrome.com/extensions/) (by [Matthew Kimber](https://github.com/matthewkimber) and [otiai10](https://github.com/otiai10))
 * [Chrome App](http://developer.chrome.com/apps/) (by [Adam Lay](https://github.com/AdamLay))
 * [CKEditor](https://github.com/ckeditor/ckeditor-dev) (by [Ondrej Sevcik](https://github.com/ondrejsevcik))
 * [CodeMirror](http://codemirror.net) (by [François de Campredon](https://github.com/fdecampredon))

From b0d15ff311cd62dfcef13564f427edeafb9108c5 Mon Sep 17 00:00:00 2001
From: otiai10 <otiai10@gmail.com>
Date: Sun, 6 Apr 2014 12:11:47 +0900
Subject: [PATCH 305/309] Add author for `chrome`

---
 chrome/chrome.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/chrome/chrome.d.ts b/chrome/chrome.d.ts
index 8f1bc3fd6..9d3b9451c 100755
--- a/chrome/chrome.d.ts
+++ b/chrome/chrome.d.ts
@@ -1,6 +1,6 @@
 // Type definitions for Chrome extension development.
 // Project: http://developer.chrome.com/extensions/
-// Definitions by: Matthew Kimber <https://github.com/matthewkimber>
+// Definitions by: Matthew Kimber <https://github.com/matthewkimber> and otiai10 <https://github.com/otiai10>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 ////////////////////

From d45e918d66d3e90eb3758462fc7e3a0d6f0b7a15 Mon Sep 17 00:00:00 2001
From: Alan <altano@gmail.com>
Date: Sun, 6 Apr 2014 02:43:49 -0400
Subject: [PATCH 306/309] Fixed express definition and added asciify
 definitions.

---
 asciify/asciify-tests.ts     |  9 +++++++++
 asciify/asciify.d.ts         | 29 +++++++++++++++++++++++++++++
 asciify/asciify.ts.tscparams |  1 +
 express/express.d.ts         |  2 +-
 4 files changed, 40 insertions(+), 1 deletion(-)
 create mode 100644 asciify/asciify-tests.ts
 create mode 100644 asciify/asciify.d.ts
 create mode 100644 asciify/asciify.ts.tscparams

diff --git a/asciify/asciify-tests.ts b/asciify/asciify-tests.ts
new file mode 100644
index 000000000..c95b9c699
--- /dev/null
+++ b/asciify/asciify-tests.ts
@@ -0,0 +1,9 @@
+/// <reference path="./asciify.d.ts" />
+
+import asciify = require('asciify');
+
+asciify('Whoa', function(err, result){console.log(result)});
+asciify('Whoa', '3-d', function(err, result){console.log(result)});
+asciify('Whoa', {font:'3-d'}, function(err, result){console.log(result)});
+
+asciify.getFonts(function(err, fonts) { fonts.slice(0); });
\ No newline at end of file
diff --git a/asciify/asciify.d.ts b/asciify/asciify.d.ts
new file mode 100644
index 000000000..4dc47cd3a
--- /dev/null
+++ b/asciify/asciify.d.ts
@@ -0,0 +1,29 @@
+// Type definitions for asciify 1.3.5
+// Project: https://www.npmjs.org/package/asciify
+// Definitions by: Alan Norbauer http://alan.norbauer.com
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+interface AsciifyOptions {
+    font?: string;
+    maxWidth?: number;
+    color?: string;
+}
+
+interface AsciifyCallback {
+    // err is sometimes a string and sometimes an Error
+    (err: any, asciifiedText: string): void
+}
+
+declare module "asciify" {
+    function asciify(text: string, callback: AsciifyCallback): void;
+    function asciify(text: string, options: string, callback: AsciifyCallback): void;
+    function asciify(text: string, options: AsciifyOptions, callback: AsciifyCallback): void;
+
+    module asciify {
+        function getFonts(callback: (err: Error, fonts: string[]) => void): void;
+    }
+
+    export = asciify
+}
\ No newline at end of file
diff --git a/asciify/asciify.ts.tscparams b/asciify/asciify.ts.tscparams
new file mode 100644
index 000000000..64dbb84a5
--- /dev/null
+++ b/asciify/asciify.ts.tscparams
@@ -0,0 +1 @@
+"--noImplicitAny --module commonjs"
\ No newline at end of file
diff --git a/express/express.d.ts b/express/express.d.ts
index 7dd170629..96cda8e8b 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -258,7 +258,7 @@ declare module "express" {
 
             header(name: string): string;
 
-            headers: string[];
+            headers: { [key: string]: string; };
 
             /**
              * Check if the given `type(s)` is acceptable, returning

From d7f85b5df89a024065c950fd349461bb86ff8075 Mon Sep 17 00:00:00 2001
From: Bart van der Schoor <bartvanderschoor@gmail.com>
Date: Mon, 7 Apr 2014 01:52:46 +0200
Subject: [PATCH 307/309] quick fix for runner, added npm script to recompile
 runner

use less cores (24 vs 32)
use bundled compiler to rebuild
added '$ npm run tsc_runner'
---
 _infrastructure/tests/runner.js | 11 +++++++----
 _infrastructure/tests/runner.ts | 12 +++++++++++-
 package.json                    |  3 ++-
 3 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/_infrastructure/tests/runner.js b/_infrastructure/tests/runner.js
index 9a3647abd..171efe87d 100644
--- a/_infrastructure/tests/runner.js
+++ b/_infrastructure/tests/runner.js
@@ -1290,13 +1290,19 @@ var DT;
 
     if (argv.help) {
         optimist.showHelp();
+        var pkg = require('../../package.json');
+        console.log('Scripts:');
+        console.log('');
+        Lazy(pkg.scripts).keys().each(function (key) {
+            console.log('   $ npm run ' + key);
+        });
         process.exit(0);
     }
 
     var testFull = process.env['TRAVIS_BRANCH'] ? /\w\/full$/.test(process.env['TRAVIS_BRANCH']) : false;
 
     new TestRunner(dtPath, {
-        concurrent: argv['single-thread'] ? 1 : Math.max(cpuCores, 2),
+        concurrent: argv['single-thread'] ? 1 : Math.max(Math.min(24, cpuCores), 2),
         tscVersion: argv['tsc-version'],
         testChanges: testFull ? false : argv['test-changes'],
         skipTests: argv['skip-tests'],
@@ -1312,7 +1318,4 @@ var DT;
         process.exit(2);
     });
 })(DT || (DT = {}));
-//grunt-start
-/// <reference path="../runner.ts" />
-//grunt-end
 //# sourceMappingURL=runner.js.map
diff --git a/_infrastructure/tests/runner.ts b/_infrastructure/tests/runner.ts
index 5d4f42815..1f75aca7a 100644
--- a/_infrastructure/tests/runner.ts
+++ b/_infrastructure/tests/runner.ts
@@ -34,6 +34,10 @@ module DT {
 
 	export var DEFAULT_TSC_VERSION = '0.9.7';
 
+	interface PackageJSON {
+		scripts: {[key:string]: string};
+	}
+
 	/////////////////////////////////
 	// Single test
 	/////////////////////////////////
@@ -333,13 +337,19 @@ module DT {
 
 	if (argv.help) {
 		optimist.showHelp();
+		var pkg: PackageJSON = require('../../package.json');
+		console.log('Scripts:');
+		console.log('');
+		Lazy(pkg.scripts).keys().each((key) => {
+			console.log('   $ npm run ' + key);
+		});
 		process.exit(0);
 	}
 
 	var testFull = process.env['TRAVIS_BRANCH'] ? /\w\/full$/.test(process.env['TRAVIS_BRANCH']) : false;
 
 	new TestRunner(dtPath, {
-		concurrent: argv['single-thread'] ? 1 : Math.max(cpuCores, 2),
+		concurrent: argv['single-thread'] ? 1 : Math.max(Math.min(24, cpuCores), 2),
 		tscVersion: argv['tsc-version'],
 		testChanges: testFull ? false : argv['test-changes'], // allow magic branch
 		skipTests: argv['skip-tests'],
diff --git a/package.json b/package.json
index 2002f0b19..c45823b82 100644
--- a/package.json
+++ b/package.json
@@ -25,7 +25,8 @@
     "all": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0",
     "dry": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0 --skip-tests --test-changes",
     "list": "node ./_infrastructure/tests/runner.js --tsc-version 1.0.0 --skip-tests --print-files --print-refmap",
-    "help": "node ./_infrastructure/tests/runner.js -h"
+    "help": "node ./_infrastructure/tests/runner.js -h",
+    "tsc_runner": "node ./_infrastructure/tests/typescript/1.0.0/tsc ./_infrastructure/tests/runner.ts --target ES5 --out ./_infrastructure/tests/runner.js --module commonjs --sourcemap"
   },
   "dependencies": {
     "source-map-support": "~0.2.5",

From f66c251d74c5b71d9e61b53a0867dff2720ee185 Mon Sep 17 00:00:00 2001
From: Alan <altano@gmail.com>
Date: Sun, 6 Apr 2014 19:54:04 -0400
Subject: [PATCH 308/309] Updating the readme for asciify.

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 091bd915f..d79e0cbca 100755
--- a/README.md
+++ b/README.md
@@ -37,6 +37,7 @@ List of Definitions
 * [Angular UI Bootstrap](http://angular-ui.github.io/bootstrap) (by [Brian Surowiec](https://github.com/xt0rted))
 * [AppFramework](http://app-framework-software.intel.com/) (by [Kyo Ago](https://github.com/kyo-ago))
 * [Arbiter](http://arbiterjs.com/) (by [Arash Shakery](https://github.com/arash16))
+* [asciify](https://www.npmjs.org/package/asciify/) (by [Alan](http://alan.norbauer.com))
 * [assert](https://github.com/Jxck/assert) (by [vvakame](https://github.com/vvakame))
 * [async](https://github.com/caolan/async) (by [Boris Yankov](https://github.com/borisyankov))
 * [Backbone.js](http://backbonejs.org/) (by [Boris Yankov](https://github.com/borisyankov))

From ee63d5a00be377cf74485b50976c32b9653cd3bc Mon Sep 17 00:00:00 2001
From: Alan <altano@gmail.com>
Date: Sun, 6 Apr 2014 20:15:37 -0400
Subject: [PATCH 309/309] Switching asciify link to github repository.

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index d79e0cbca..4e8d6c170 100755
--- a/README.md
+++ b/README.md
@@ -37,7 +37,7 @@ List of Definitions
 * [Angular UI Bootstrap](http://angular-ui.github.io/bootstrap) (by [Brian Surowiec](https://github.com/xt0rted))
 * [AppFramework](http://app-framework-software.intel.com/) (by [Kyo Ago](https://github.com/kyo-ago))
 * [Arbiter](http://arbiterjs.com/) (by [Arash Shakery](https://github.com/arash16))
-* [asciify](https://www.npmjs.org/package/asciify/) (by [Alan](http://alan.norbauer.com))
+* [asciify](https://github.com/olizilla/asciify) (by [Alan](http://alan.norbauer.com))
 * [assert](https://github.com/Jxck/assert) (by [vvakame](https://github.com/vvakame))
 * [async](https://github.com/caolan/async) (by [Boris Yankov](https://github.com/borisyankov))
 * [Backbone.js](http://backbonejs.org/) (by [Boris Yankov](https://github.com/borisyankov))